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 0x03db 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x03db, 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 0x7ecebe00 0026 11 GT 0027 61 PUSH2 0x020a 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x020a, if 0x7ecebe00 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x7ecebe00 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xcc01053e 0031 11 GT 0032 61 PUSH2 0x0125 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0125, if 0xcc01053e > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xcc01053e > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe1560fd3 003C 11 GT 003D 61 PUSH2 0x00b8 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b8, if 0xe1560fd3 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe1560fd3 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xeb9253c0 0047 11 GT 0048 61 PUSH2 0x0087 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0087, if 0xeb9253c0 > stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xeb9253c0 > stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xeb9253c0 0052 14 EQ 0053 61 PUSH2 0x10ba 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10ba, if 0xeb9253c0 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xeb9253c0 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x10e6 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10e6, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf65d6638 0068 14 EQ 0069 61 PUSH2 0x110c 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x110c, if 0xf65d6638 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf65d6638 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xfc700bd1 0073 14 EQ 0074 61 PUSH2 0x12db 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12db, if 0xfc700bd1 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xfc700bd1 == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0xffa1ad74 007E 14 EQ 007F 61 PUSH2 0x1301 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1301, if 0xffa1ad74 == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0xffa1ad74 == stack[-1] 0083 61 PUSH2 0x03db 0086 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_0087: // Incoming jump from 0x004B, if 0xeb9253c0 > stack[-1] // Inputs[1] { @0088 stack[-1] } 0087 5B JUMPDEST 0088 80 DUP1 0089 63 PUSH4 0xe1560fd3 008E 14 EQ 008F 61 PUSH2 0x0f80 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f80, if 0xe1560fd3 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xe1560fd3 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xe1a8eafd 0099 14 EQ 009A 61 PUSH2 0x0fdf 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fdf, if 0xe1a8eafd == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xe1a8eafd == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xe3ee160e 00A4 14 EQ 00A5 61 PUSH2 0x1005 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1005, if 0xe3ee160e == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0xe3ee160e == stack[-1] // Inputs[1] { @00A9 stack[-1] } 00A9 80 DUP1 00AA 63 PUSH4 0xe46638e6 00AF 14 EQ 00B0 61 PUSH2 0x1064 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1064, if 0xe46638e6 == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xe46638e6 == stack[-1] 00B4 61 PUSH2 0x03db 00B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_00B8: // Incoming jump from 0x0040, if 0xe1560fd3 > stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B8 5B JUMPDEST 00B9 80 DUP1 00BA 63 PUSH4 0xd9169487 00BF 11 GT 00C0 61 PUSH2 0x00f4 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f4, if 0xd9169487 > stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xd9169487 > stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xd9169487 00CA 14 EQ 00CB 61 PUSH2 0x0eee 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eee, if 0xd9169487 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xd9169487 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xda2f030f 00D5 14 EQ 00D6 61 PUSH2 0x0ef6 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ef6, if 0xda2f030f == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xda2f030f == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0xdb18af6c 00E0 14 EQ 00E1 61 PUSH2 0x0f1c 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f1c, if 0xdb18af6c == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0xdb18af6c == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0xdd62ed3e 00EB 14 EQ 00EC 61 PUSH2 0x0f52 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f52, if 0xdd62ed3e == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0xdd62ed3e == stack[-1] 00F0 61 PUSH2 0x03db 00F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_00F4: // Incoming jump from 0x00C3, if 0xd9169487 > stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F4 5B JUMPDEST 00F5 80 DUP1 00F6 63 PUSH4 0xcc01053e 00FB 14 EQ 00FC 61 PUSH2 0x0e61 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e61, if 0xcc01053e == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0xcc01053e == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0xce1b1d43 0106 14 EQ 0107 61 PUSH2 0x0e69 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e69, if 0xce1b1d43 == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0xce1b1d43 == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0xd505accf 0111 14 EQ 0112 61 PUSH2 0x0e71 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e71, if 0xd505accf == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0xd505accf == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0xd73dd623 011C 14 EQ 011D 61 PUSH2 0x0ec2 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ec2, if 0xd73dd623 == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0xd73dd623 == stack[-1] 0121 61 PUSH2 0x03db 0124 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_0125: // Incoming jump from 0x0035, if 0xcc01053e > stack[-1] // Inputs[1] { @0126 stack[-1] } 0125 5B JUMPDEST 0126 80 DUP1 0127 63 PUSH4 0x9ddc1184 012C 11 GT 012D 61 PUSH2 0x019d 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019d, if 0x9ddc1184 > stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x9ddc1184 > stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0xb500329b 0137 11 GT 0138 61 PUSH2 0x016c 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x016c, if 0xb500329b > stack[-1] label_013C: // Incoming jump from 0x013B, if not 0xb500329b > stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0xb500329b 0142 14 EQ 0143 61 PUSH2 0x0cef 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cef, if 0xb500329b == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0xb500329b == stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0xb9be0ed3 014D 14 EQ 014E 61 PUSH2 0x0d15 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d15, if 0xb9be0ed3 == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0xb9be0ed3 == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0xba7b52e0 0158 14 EQ 0159 61 PUSH2 0x0d6d 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d6d, if 0xba7b52e0 == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0xba7b52e0 == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0xc9991176 0163 14 EQ 0164 61 PUSH2 0x0e3b 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e3b, if 0xc9991176 == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0xc9991176 == stack[-1] 0168 61 PUSH2 0x03db 016B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_016C: // Incoming jump from 0x013B, if 0xb500329b > stack[-1] // Inputs[1] { @016D stack[-1] } 016C 5B JUMPDEST 016D 80 DUP1 016E 63 PUSH4 0x9ddc1184 0173 14 EQ 0174 61 PUSH2 0x0c54 0177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c54, if 0x9ddc1184 == stack[-1] label_0178: // Incoming jump from 0x0177, if not 0x9ddc1184 == stack[-1] // Inputs[1] { @0178 stack[-1] } 0178 80 DUP1 0179 63 PUSH4 0xa0cc6a68 017E 14 EQ 017F 61 PUSH2 0x0cb3 0182 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cb3, if 0xa0cc6a68 == stack[-1] label_0183: // Incoming jump from 0x0182, if not 0xa0cc6a68 == stack[-1] // Inputs[1] { @0183 stack[-1] } 0183 80 DUP1 0184 63 PUSH4 0xa9059cbb 0189 14 EQ 018A 61 PUSH2 0x0cbb 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cbb, if 0xa9059cbb == stack[-1] label_018E: // Incoming jump from 0x018D, if not 0xa9059cbb == stack[-1] // Inputs[1] { @018E stack[-1] } 018E 80 DUP1 018F 63 PUSH4 0xac3e6742 0194 14 EQ 0195 61 PUSH2 0x0ce7 0198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ce7, if 0xac3e6742 == stack[-1] label_0199: // Incoming jump from 0x0198, if not 0xac3e6742 == stack[-1] 0199 61 PUSH2 0x03db 019C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_019D: // Incoming jump from 0x0130, if 0x9ddc1184 > stack[-1] // Inputs[1] { @019E stack[-1] } 019D 5B JUMPDEST 019E 80 DUP1 019F 63 PUSH4 0x95d89b41 01A4 11 GT 01A5 61 PUSH2 0x01d9 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d9, if 0x95d89b41 > stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x95d89b41 > stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 63 PUSH4 0x95d89b41 01AF 14 EQ 01B0 61 PUSH2 0x0bf2 01B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf2, if 0x95d89b41 == stack[-1] label_01B4: // Incoming jump from 0x01B3, if not 0x95d89b41 == stack[-1] // Inputs[1] { @01B4 stack[-1] } 01B4 80 DUP1 01B5 63 PUSH4 0x97ecb37f 01BA 14 EQ 01BB 61 PUSH2 0x0bfa 01BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bfa, if 0x97ecb37f == stack[-1] label_01BF: // Incoming jump from 0x01BE, if not 0x97ecb37f == stack[-1] // Inputs[1] { @01BF stack[-1] } 01BF 80 DUP1 01C0 63 PUSH4 0x9af38fbe 01C5 14 EQ 01C6 61 PUSH2 0x0c02 01C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c02, if 0x9af38fbe == stack[-1] label_01CA: // Incoming jump from 0x01C9, if not 0x9af38fbe == stack[-1] // Inputs[1] { @01CA stack[-1] } 01CA 80 DUP1 01CB 63 PUSH4 0x9dc29fac 01D0 14 EQ 01D1 61 PUSH2 0x0c28 01D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c28, if 0x9dc29fac == stack[-1] label_01D5: // Incoming jump from 0x01D4, if not 0x9dc29fac == stack[-1] 01D5 61 PUSH2 0x03db 01D8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_01D9: // Incoming jump from 0x01A8, if 0x95d89b41 > stack[-1] // Inputs[1] { @01DA stack[-1] } 01D9 5B JUMPDEST 01DA 80 DUP1 01DB 63 PUSH4 0x7ecebe00 01E0 14 EQ 01E1 61 PUSH2 0x0a98 01E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a98, if 0x7ecebe00 == stack[-1] label_01E5: // Incoming jump from 0x01E4, if not 0x7ecebe00 == stack[-1] // Inputs[1] { @01E5 stack[-1] } 01E5 80 DUP1 01E6 63 PUSH4 0x8140d0dc 01EB 14 EQ 01EC 61 PUSH2 0x0abe 01EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0abe, if 0x8140d0dc == stack[-1] label_01F0: // Incoming jump from 0x01EF, if not 0x8140d0dc == stack[-1] // Inputs[1] { @01F0 stack[-1] } 01F0 80 DUP1 01F1 63 PUSH4 0x8bf64cba 01F6 14 EQ 01F7 61 PUSH2 0x0b2c 01FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b2c, if 0x8bf64cba == stack[-1] label_01FB: // Incoming jump from 0x01FA, if not 0x8bf64cba == stack[-1] // Inputs[1] { @01FB stack[-1] } 01FB 80 DUP1 01FC 63 PUSH4 0x8da5cb5b 0201 14 EQ 0202 61 PUSH2 0x0bea 0205 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bea, if 0x8da5cb5b == stack[-1] label_0206: // Incoming jump from 0x0205, if not 0x8da5cb5b == stack[-1] 0206 61 PUSH2 0x03db 0209 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_020A: // Incoming jump from 0x002A, if 0x7ecebe00 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @020B stack[-1] } 020A 5B JUMPDEST 020B 80 DUP1 020C 63 PUSH4 0x3644e515 0211 11 GT 0212 61 PUSH2 0x02fa 0215 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fa, if 0x3644e515 > stack[-1] label_0216: // Incoming jump from 0x0215, if not 0x3644e515 > stack[-1] // Inputs[1] { @0216 stack[-1] } 0216 80 DUP1 0217 63 PUSH4 0x58348cf1 021C 11 GT 021D 61 PUSH2 0x028d 0220 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028d, if 0x58348cf1 > stack[-1] label_0221: // Incoming jump from 0x0220, if not 0x58348cf1 > stack[-1] // Inputs[1] { @0221 stack[-1] } 0221 80 DUP1 0222 63 PUSH4 0x6bb5d5af 0227 11 GT 0228 61 PUSH2 0x025c 022B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025c, if 0x6bb5d5af > stack[-1] label_022C: // Incoming jump from 0x022B, if not 0x6bb5d5af > stack[-1] // Inputs[1] { @022C stack[-1] } 022C 80 DUP1 022D 63 PUSH4 0x6bb5d5af 0232 14 EQ 0233 61 PUSH2 0x09ea 0236 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ea, if 0x6bb5d5af == stack[-1] label_0237: // Incoming jump from 0x0236, if not 0x6bb5d5af == stack[-1] // Inputs[1] { @0237 stack[-1] } 0237 80 DUP1 0238 63 PUSH4 0x70a08231 023D 14 EQ 023E 61 PUSH2 0x09f2 0241 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09f2, if 0x70a08231 == stack[-1] label_0242: // Incoming jump from 0x0241, if not 0x70a08231 == stack[-1] // Inputs[1] { @0242 stack[-1] } 0242 80 DUP1 0243 63 PUSH4 0x715018a6 0248 14 EQ 0249 61 PUSH2 0x0a18 024C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a18, if 0x715018a6 == stack[-1] label_024D: // Incoming jump from 0x024C, if not 0x715018a6 == stack[-1] // Inputs[1] { @024D stack[-1] } 024D 80 DUP1 024E 63 PUSH4 0x7bec9b55 0253 14 EQ 0254 61 PUSH2 0x0a20 0257 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a20, if 0x7bec9b55 == stack[-1] label_0258: // Incoming jump from 0x0257, if not 0x7bec9b55 == stack[-1] 0258 61 PUSH2 0x03db 025B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_025C: // Incoming jump from 0x022B, if 0x6bb5d5af > stack[-1] // Inputs[1] { @025D stack[-1] } 025C 5B JUMPDEST 025D 80 DUP1 025E 63 PUSH4 0x58348cf1 0263 14 EQ 0264 61 PUSH2 0x0931 0267 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0931, if 0x58348cf1 == stack[-1] label_0268: // Incoming jump from 0x0267, if not 0x58348cf1 == stack[-1] // Inputs[1] { @0268 stack[-1] } 0268 80 DUP1 0269 63 PUSH4 0x5a049a70 026E 14 EQ 026F 61 PUSH2 0x0957 0272 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0957, if 0x5a049a70 == stack[-1] label_0273: // Incoming jump from 0x0272, if not 0x5a049a70 == stack[-1] // Inputs[1] { @0273 stack[-1] } 0273 80 DUP1 0274 63 PUSH4 0x66188463 0279 14 EQ 027A 61 PUSH2 0x0998 027D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0998, if 0x66188463 == stack[-1] label_027E: // Incoming jump from 0x027D, if not 0x66188463 == stack[-1] // Inputs[1] { @027E stack[-1] } 027E 80 DUP1 027F 63 PUSH4 0x68fa8134 0284 14 EQ 0285 61 PUSH2 0x09c4 0288 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09c4, if 0x68fa8134 == stack[-1] label_0289: // Incoming jump from 0x0288, if not 0x68fa8134 == stack[-1] 0289 61 PUSH2 0x03db 028C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_028D: // Incoming jump from 0x0220, if 0x58348cf1 > stack[-1] // Inputs[1] { @028E stack[-1] } 028D 5B JUMPDEST 028E 80 DUP1 028F 63 PUSH4 0x46336542 0294 11 GT 0295 61 PUSH2 0x02c9 0298 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c9, if 0x46336542 > stack[-1] label_0299: // Incoming jump from 0x0298, if not 0x46336542 > stack[-1] // Inputs[1] { @0299 stack[-1] } 0299 80 DUP1 029A 63 PUSH4 0x46336542 029F 14 EQ 02A0 61 PUSH2 0x0816 02A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0816, if 0x46336542 == stack[-1] label_02A4: // Incoming jump from 0x02A3, if not 0x46336542 == stack[-1] // Inputs[1] { @02A4 stack[-1] } 02A4 80 DUP1 02A5 63 PUSH4 0x485cc955 02AA 14 EQ 02AB 61 PUSH2 0x083c 02AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x083c, if 0x485cc955 == stack[-1] label_02AF: // Incoming jump from 0x02AE, if not 0x485cc955 == stack[-1] // Inputs[1] { @02AF stack[-1] } 02AF 80 DUP1 02B0 63 PUSH4 0x52f6747a 02B5 14 EQ 02B6 61 PUSH2 0x086a 02B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x086a, if 0x52f6747a == stack[-1] label_02BA: // Incoming jump from 0x02B9, if not 0x52f6747a == stack[-1] // Inputs[1] { @02BA stack[-1] } 02BA 80 DUP1 02BB 63 PUSH4 0x530e784f 02C0 14 EQ 02C1 61 PUSH2 0x090b 02C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x090b, if 0x530e784f == stack[-1] label_02C5: // Incoming jump from 0x02C4, if not 0x530e784f == stack[-1] 02C5 61 PUSH2 0x03db 02C8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_02C9: // Incoming jump from 0x0298, if 0x46336542 > stack[-1] // Inputs[1] { @02CA stack[-1] } 02C9 5B JUMPDEST 02CA 80 DUP1 02CB 63 PUSH4 0x3644e515 02D0 14 EQ 02D1 61 PUSH2 0x074e 02D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x074e, if 0x3644e515 == stack[-1] label_02D5: // Incoming jump from 0x02D4, if not 0x3644e515 == stack[-1] // Inputs[1] { @02D5 stack[-1] } 02D5 80 DUP1 02D6 63 PUSH4 0x3ed04ad6 02DB 14 EQ 02DC 61 PUSH2 0x0756 02DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0756, if 0x3ed04ad6 == stack[-1] label_02E0: // Incoming jump from 0x02DF, if not 0x3ed04ad6 == stack[-1] // Inputs[1] { @02E0 stack[-1] } 02E0 80 DUP1 02E1 63 PUSH4 0x40c10f19 02E6 14 EQ 02E7 61 PUSH2 0x077c 02EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x077c, if 0x40c10f19 == stack[-1] label_02EB: // Incoming jump from 0x02EA, if not 0x40c10f19 == stack[-1] // Inputs[1] { @02EB stack[-1] } 02EB 80 DUP1 02EC 63 PUSH4 0x44b0f448 02F1 14 EQ 02F2 61 PUSH2 0x07a8 02F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a8, if 0x44b0f448 == stack[-1] label_02F6: // Incoming jump from 0x02F5, if not 0x44b0f448 == stack[-1] 02F6 61 PUSH2 0x03db 02F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_02FA: // Incoming jump from 0x0215, if 0x3644e515 > stack[-1] // Inputs[1] { @02FB stack[-1] } 02FA 5B JUMPDEST 02FB 80 DUP1 02FC 63 PUSH4 0x18160ddd 0301 11 GT 0302 61 PUSH2 0x0372 0305 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0372, if 0x18160ddd > stack[-1] label_0306: // Incoming jump from 0x0305, if not 0x18160ddd > stack[-1] // Inputs[1] { @0306 stack[-1] } 0306 80 DUP1 0307 63 PUSH4 0x2630c12f 030C 11 GT 030D 61 PUSH2 0x0341 0310 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0341, if 0x2630c12f > stack[-1] label_0311: // Incoming jump from 0x0310, if not 0x2630c12f > stack[-1] // Inputs[1] { @0311 stack[-1] } 0311 80 DUP1 0312 63 PUSH4 0x2630c12f 0317 14 EQ 0318 61 PUSH2 0x06fc 031B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fc, if 0x2630c12f == stack[-1] label_031C: // Incoming jump from 0x031B, if not 0x2630c12f == stack[-1] // Inputs[1] { @031C stack[-1] } 031C 80 DUP1 031D 63 PUSH4 0x30adf81f 0322 14 EQ 0323 61 PUSH2 0x0720 0326 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0720, if 0x30adf81f == stack[-1] label_0327: // Incoming jump from 0x0326, if not 0x30adf81f == stack[-1] // Inputs[1] { @0327 stack[-1] } 0327 80 DUP1 0328 63 PUSH4 0x313ce567 032D 14 EQ 032E 61 PUSH2 0x0728 0331 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0728, if 0x313ce567 == stack[-1] label_0332: // Incoming jump from 0x0331, if not 0x313ce567 == stack[-1] // Inputs[1] { @0332 stack[-1] } 0332 80 DUP1 0333 63 PUSH4 0x33a8c45a 0338 14 EQ 0339 61 PUSH2 0x0746 033C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0746, if 0x33a8c45a == stack[-1] label_033D: // Incoming jump from 0x033C, if not 0x33a8c45a == stack[-1] 033D 61 PUSH2 0x03db 0340 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_0341: // Incoming jump from 0x0310, if 0x2630c12f > stack[-1] // Inputs[1] { @0342 stack[-1] } 0341 5B JUMPDEST 0342 80 DUP1 0343 63 PUSH4 0x18160ddd 0348 14 EQ 0349 61 PUSH2 0x0639 034C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0639, if 0x18160ddd == stack[-1] label_034D: // Incoming jump from 0x034C, if not 0x18160ddd == stack[-1] // Inputs[1] { @034D stack[-1] } 034D 80 DUP1 034E 63 PUSH4 0x1947c5e2 0353 14 EQ 0354 61 PUSH2 0x0641 0357 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0641, if 0x1947c5e2 == stack[-1] label_0358: // Incoming jump from 0x0357, if not 0x1947c5e2 == stack[-1] // Inputs[1] { @0358 stack[-1] } 0358 80 DUP1 0359 63 PUSH4 0x1c94c2c3 035E 14 EQ 035F 61 PUSH2 0x0667 0362 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0667, if 0x1c94c2c3 == stack[-1] label_0363: // Incoming jump from 0x0362, if not 0x1c94c2c3 == stack[-1] // Inputs[1] { @0363 stack[-1] } 0363 80 DUP1 0364 63 PUSH4 0x23b872dd 0369 14 EQ 036A 61 PUSH2 0x06c6 036D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c6, if 0x23b872dd == stack[-1] label_036E: // Incoming jump from 0x036D, if not 0x23b872dd == stack[-1] 036E 61 PUSH2 0x03db 0371 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_0372: // Incoming jump from 0x0305, if 0x18160ddd > stack[-1] // Inputs[1] { @0373 stack[-1] } 0372 5B JUMPDEST 0373 80 DUP1 0374 63 PUSH4 0x103e6d8f 0379 11 GT 037A 61 PUSH2 0x03ae 037D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ae, if 0x103e6d8f > stack[-1] label_037E: // Incoming jump from 0x037D, if not 0x103e6d8f > stack[-1] // Inputs[1] { @037E stack[-1] } 037E 80 DUP1 037F 63 PUSH4 0x103e6d8f 0384 14 EQ 0385 61 PUSH2 0x04eb 0388 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04eb, if 0x103e6d8f == stack[-1] label_0389: // Incoming jump from 0x0388, if not 0x103e6d8f == stack[-1] // Inputs[1] { @0389 stack[-1] } 0389 80 DUP1 038A 63 PUSH4 0x10c8b404 038F 14 EQ 0390 61 PUSH2 0x053b 0393 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053b, if 0x10c8b404 == stack[-1] label_0394: // Incoming jump from 0x0393, if not 0x10c8b404 == stack[-1] // Inputs[1] { @0394 stack[-1] } 0394 80 DUP1 0395 63 PUSH4 0x153a1f3e 039A 14 EQ 039B 61 PUSH2 0x0555 039E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0555, if 0x153a1f3e == stack[-1] label_039F: // Incoming jump from 0x039E, if not 0x153a1f3e == stack[-1] // Inputs[1] { @039F stack[-1] } 039F 80 DUP1 03A0 63 PUSH4 0x17df4745 03A5 14 EQ 03A6 61 PUSH2 0x0613 03A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0613, if 0x17df4745 == stack[-1] label_03AA: // Incoming jump from 0x03A9, if not 0x17df4745 == stack[-1] 03AA 61 PUSH2 0x03db 03AD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03db label_03AE: // Incoming jump from 0x037D, if 0x103e6d8f > stack[-1] // Inputs[1] { @03AF stack[-1] } 03AE 5B JUMPDEST 03AF 80 DUP1 03B0 63 PUSH4 0x06fdde03 03B5 14 EQ 03B6 61 PUSH2 0x03e0 03B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e0, if 0x06fdde03 == stack[-1] label_03BA: // Incoming jump from 0x03B9, if not 0x06fdde03 == stack[-1] // Inputs[1] { @03BA stack[-1] } 03BA 80 DUP1 03BB 63 PUSH4 0x095ea7b3 03C0 14 EQ 03C1 61 PUSH2 0x045d 03C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045d, if 0x095ea7b3 == stack[-1] label_03C5: // Incoming jump from 0x03C4, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @03C5 stack[-1] } 03C5 80 DUP1 03C6 63 PUSH4 0x0a2eb301 03CB 14 EQ 03CC 61 PUSH2 0x049d 03CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049d, if 0x0a2eb301 == stack[-1] label_03D0: // Incoming jump from 0x03CF, if not 0x0a2eb301 == stack[-1] // Inputs[1] { @03D0 stack[-1] } 03D0 80 DUP1 03D1 63 PUSH4 0x0f5f817a 03D6 14 EQ 03D7 61 PUSH2 0x04c3 03DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c3, if 0x0f5f817a == stack[-1] label_03DB: // Incoming jump from 0x02F9 // Incoming jump from 0x00F3 // Incoming jump from 0x0209 // Incoming jump from 0x02C8 // Incoming jump from 0x028C // Incoming jump from 0x0340 // Incoming jump from 0x00B7 // Incoming jump from 0x016B // Incoming jump from 0x0124 // Incoming jump from 0x03AD // Incoming jump from 0x0371 // Incoming jump from 0x0086 // Incoming jump from 0x01D8 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x025B // Incoming jump from 0x019C // Incoming jump from 0x03DA, if not 0x0f5f817a == stack[-1] // Inputs[1] { @03DF memory[0x00:0x00] } 03DB 5B JUMPDEST 03DC 60 PUSH1 0x00 03DE 80 DUP1 03DF FD *REVERT // Stack delta = +0 // Outputs[1] { @03DF revert(memory[0x00:0x00]); } // Block terminates label_03E0: // Incoming jump from 0x03B9, if 0x06fdde03 == stack[-1] 03E0 5B JUMPDEST 03E1 61 PUSH2 0x03e8 03E4 61 PUSH2 0x1309 03E7 56 *JUMP // Stack delta = +1 // Outputs[1] { @03E1 stack[0] = 0x03e8 } // Block ends with call to 0x1309, returns to 0x03E8 label_03E8: // Incoming return from call to 0x1309 at 0x03E7 // Incoming return from call to 0x1D11 at 0x074D // Incoming return from call to 0x2DB9 at 0x0BF9 // Inputs[4] // { // @03EC memory[0x40:0x60] // @03F2 stack[-1] // @03F3 memory[stack[-1]:stack[-1] + 0x20] // @03F9 memory[stack[-1]:stack[-1] + 0x20] // } 03E8 5B JUMPDEST 03E9 60 PUSH1 0x40 03EB 80 DUP1 03EC 51 MLOAD 03ED 60 PUSH1 0x20 03EF 80 DUP1 03F0 82 DUP3 03F1 52 MSTORE 03F2 83 DUP4 03F3 51 MLOAD 03F4 81 DUP2 03F5 83 DUP4 03F6 01 ADD 03F7 52 MSTORE 03F8 83 DUP4 03F9 51 MLOAD 03FA 91 SWAP2 03FB 92 SWAP3 03FC 83 DUP4 03FD 92 SWAP3 03FE 90 SWAP1 03FF 83 DUP4 0400 01 ADD 0401 91 SWAP2 0402 85 DUP6 0403 01 ADD 0404 90 SWAP1 0405 80 DUP1 0406 83 DUP4 0407 83 DUP4 0408 60 PUSH1 0x00 040A 5B JUMPDEST 040B 83 DUP4 040C 81 DUP2 040D 10 LT 040E 15 ISZERO 040F 61 PUSH2 0x0422 0412 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @03F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @03F7 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @03FB stack[0] = memory[0x40:0x60] // @03FD stack[1] = memory[0x40:0x60] // @0401 stack[2] = memory[0x40:0x60] + 0x40 // @0404 stack[3] = stack[-1] + 0x20 // @0404 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0405 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0406 stack[6] = memory[0x40:0x60] + 0x40 // @0407 stack[7] = stack[-1] + 0x20 // @0408 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0422, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0413: // Incoming jump from 0x0412, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0412, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0413 stack[-2] // @0414 stack[-1] // @0416 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0417 stack[-3] // } 0413 81 DUP2 0414 81 DUP2 0415 01 ADD 0416 51 MLOAD 0417 83 DUP4 0418 82 DUP3 0419 01 ADD 041A 52 MSTORE 041B 60 PUSH1 0x20 041D 01 ADD 041E 61 PUSH2 0x040a 0421 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @041A memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @041D stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x040a label_0422: // Incoming jump from 0x0412, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0412, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0427 stack[-5] // @0427 stack[-6] // @0429 stack[-7] // } 0422 5B JUMPDEST 0423 50 POP 0424 50 POP 0425 50 POP 0426 50 POP 0427 90 SWAP1 0428 50 POP 0429 90 SWAP1 042A 81 DUP2 042B 01 ADD 042C 90 SWAP1 042D 60 PUSH1 0x1f 042F 16 AND 0430 80 DUP1 0431 15 ISZERO 0432 61 PUSH2 0x044f 0435 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @042C stack[-7] = stack[-5] + stack[-7] // @042F stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x044f, if !(0x1f & stack[-5]) label_0436: // Incoming jump from 0x0435, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0436 stack[-1] // @0437 stack[-2] // @043A memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0451 stack[-5] // @0457 memory[0x40:0x60] // @045C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0436 80 DUP1 0437 82 DUP3 0438 03 SUB 0439 80 DUP1 043A 51 MLOAD 043B 60 PUSH1 0x01 043D 83 DUP4 043E 60 PUSH1 0x20 0440 03 SUB 0441 61 PUSH2 0x0100 0444 0A EXP 0445 03 SUB 0446 19 NOT 0447 16 AND 0448 81 DUP2 0449 52 MSTORE 044A 60 PUSH1 0x20 044C 01 ADD 044D 91 SWAP2 044E 50 POP 044F 5B JUMPDEST 0450 50 POP 0451 92 SWAP3 0452 50 POP 0453 50 POP 0454 50 POP 0455 60 PUSH1 0x40 0457 51 MLOAD 0458 80 DUP1 0459 91 SWAP2 045A 03 SUB 045B 90 SWAP1 045C F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0449 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @045C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_045D: // Incoming jump from 0x03C4, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0464 msg.data.length } 045D 5B JUMPDEST 045E 61 PUSH2 0x0489 0461 60 PUSH1 0x04 0463 80 DUP1 0464 36 CALLDATASIZE 0465 03 SUB 0466 60 PUSH1 0x40 0468 81 DUP2 0469 10 LT 046A 15 ISZERO 046B 61 PUSH2 0x0473 046E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @045E stack[0] = 0x0489 // @0461 stack[1] = 0x04 // @0465 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0473, if !(msg.data.length - 0x04 < 0x40) label_046F: // Incoming jump from 0x046E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0472 memory[0x00:0x00] } 046F 60 PUSH1 0x00 0471 80 DUP1 0472 FD *REVERT // Stack delta = +0 // Outputs[1] { @0472 revert(memory[0x00:0x00]); } // Block terminates label_0473: // Incoming jump from 0x046E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @047D stack[-2] // @047E msg.data[stack[-2]:stack[-2] + 0x20] // @0484 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0473 5B JUMPDEST 0474 50 POP 0475 60 PUSH1 0x01 0477 60 PUSH1 0x01 0479 60 PUSH1 0xa0 047B 1B SHL 047C 03 SUB 047D 81 DUP2 047E 35 CALLDATALOAD 047F 16 AND 0480 90 SWAP1 0481 60 PUSH1 0x20 0483 01 ADD 0484 35 CALLDATALOAD 0485 61 PUSH2 0x1491 0488 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0480 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0484 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1491 label_0489: // Incoming return from call to 0x0CD1 at 0x0CCC // Incoming return from call to 0x06DC at 0x06D7 // Inputs[4] // { // @048D memory[0x40:0x60] // @048E stack[-1] // @0493 memory[0x40:0x60] // @049C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0489 5B JUMPDEST 048A 60 PUSH1 0x40 048C 80 DUP1 048D 51 MLOAD 048E 91 SWAP2 048F 15 ISZERO 0490 15 ISZERO 0491 82 DUP3 0492 52 MSTORE 0493 51 MLOAD 0494 90 SWAP1 0495 81 DUP2 0496 90 SWAP1 0497 03 SUB 0498 60 PUSH1 0x20 049A 01 ADD 049B 90 SWAP1 049C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0492 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @049C return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_049D: // Incoming jump from 0x03CF, if 0x0a2eb301 == stack[-1] // Inputs[1] { @04A4 msg.data.length } 049D 5B JUMPDEST 049E 61 PUSH2 0x0489 04A1 60 PUSH1 0x04 04A3 80 DUP1 04A4 36 CALLDATASIZE 04A5 03 SUB 04A6 60 PUSH1 0x20 04A8 81 DUP2 04A9 10 LT 04AA 15 ISZERO 04AB 61 PUSH2 0x04b3 04AE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @049E stack[0] = 0x0489 // @04A1 stack[1] = 0x04 // @04A5 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x04b3, if !(msg.data.length - 0x04 < 0x20) label_04AF: // Incoming jump from 0x04AE, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04B2 memory[0x00:0x00] } 04AF 60 PUSH1 0x00 04B1 80 DUP1 04B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B2 revert(memory[0x00:0x00]); } // Block terminates label_04B3: // Incoming jump from 0x04AE, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04B5 msg.data[stack[-2]:stack[-2] + 0x20] // @04B5 stack[-2] // } 04B3 5B JUMPDEST 04B4 50 POP 04B5 35 CALLDATALOAD 04B6 60 PUSH1 0x01 04B8 60 PUSH1 0x01 04BA 60 PUSH1 0xa0 04BC 1B SHL 04BD 03 SUB 04BE 16 AND 04BF 61 PUSH2 0x14f6 04C2 56 *JUMP // Stack delta = -1 // Outputs[1] { @04BE stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x14f6 label_04C3: // Incoming jump from 0x03DA, if 0x0f5f817a == stack[-1] // Inputs[1] { @04CA msg.data.length } 04C3 5B JUMPDEST 04C4 61 PUSH2 0x04e9 04C7 60 PUSH1 0x04 04C9 80 DUP1 04CA 36 CALLDATASIZE 04CB 03 SUB 04CC 60 PUSH1 0x20 04CE 81 DUP2 04CF 10 LT 04D0 15 ISZERO 04D1 61 PUSH2 0x04d9 04D4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04C4 stack[0] = 0x04e9 // @04C7 stack[1] = 0x04 // @04CB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04d9, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_04D5: // Incoming jump from 0x04D4, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04D8 memory[0x00:0x00] } 04D5 60 PUSH1 0x00 04D7 80 DUP1 04D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D8 revert(memory[0x00:0x00]); } // Block terminates label_04D9: // Incoming call from 0x04D4, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04DB stack[-2] // @04DB msg.data[stack[-2]:stack[-2] + 0x20] // } 04D9 5B JUMPDEST 04DA 50 POP 04DB 35 CALLDATALOAD 04DC 60 PUSH1 0x01 04DE 60 PUSH1 0x01 04E0 60 PUSH1 0xa0 04E2 1B SHL 04E3 03 SUB 04E4 16 AND 04E5 61 PUSH2 0x1509 04E8 56 *JUMP // Stack delta = -1 // Outputs[1] { @04E4 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1509 label_04E9: // Incoming return from call to 0x0E87 at 0x0E82 // Incoming return from call to 0x101C at 0x1017 // Incoming return from call to 0x0629 at 0x0624 // Incoming return from call to 0x0FF5 at 0x0FF0 // Incoming return from call to 0x383B at 0x0E68 // Incoming return from call to 0x0C6B at 0x0C66 // Incoming return from call to 0x0D05 at 0x0D00 // Incoming return from call to 0x0921 at 0x091C // Incoming return from call to 0x096D at 0x0968 // Incoming return from call to 0x26B1 at 0x0A1F // Incoming return from call to 0x04D9 at 0x04D4 // Incoming return from call to 0x0947 at 0x0942 // Incoming return from call to 0x067E at 0x0679 // Incoming return from call to 0x09DA at 0x09D5 // Incoming return from call to 0x10FC at 0x10F7 // Incoming return from call to 0x0F97 at 0x0F92 // Incoming return from call to 0x0D83 at 0x0D7E // Incoming return from call to 0x056B at 0x0566 // Incoming return from call to 0x0C18 at 0x0C13 // Incoming return from call to 0x076C at 0x0767 // Incoming return from call to 0x0E51 at 0x0E4C // Incoming return from call to 0x0657 at 0x0652 04E9 5B JUMPDEST 04EA 00 *STOP // Stack delta = +0 // Outputs[1] { @04EA stop(); } // Block terminates label_04EB: // Incoming jump from 0x0388, if 0x103e6d8f == stack[-1] // Inputs[1] { @04F2 msg.data.length } 04EB 5B JUMPDEST 04EC 61 PUSH2 0x0517 04EF 60 PUSH1 0x04 04F1 80 DUP1 04F2 36 CALLDATASIZE 04F3 03 SUB 04F4 60 PUSH1 0x40 04F6 81 DUP2 04F7 10 LT 04F8 15 ISZERO 04F9 61 PUSH2 0x0501 04FC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04EC stack[0] = 0x0517 // @04EF stack[1] = 0x04 // @04F3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0501, returns to 0x0517, if !(msg.data.length - 0x04 < 0x40) label_04FD: // Incoming jump from 0x04FC, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0500 memory[0x00:0x00] } 04FD 60 PUSH1 0x00 04FF 80 DUP1 0500 FD *REVERT // Stack delta = +0 // Outputs[1] { @0500 revert(memory[0x00:0x00]); } // Block terminates label_0501: // Incoming call from 0x04FC, returns to 0x0517, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @050B stack[-2] // @050C msg.data[stack[-2]:stack[-2] + 0x20] // @0512 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0501 5B JUMPDEST 0502 50 POP 0503 60 PUSH1 0x01 0505 60 PUSH1 0x01 0507 60 PUSH1 0xa0 0509 1B SHL 050A 03 SUB 050B 81 DUP2 050C 35 CALLDATALOAD 050D 16 AND 050E 90 SWAP1 050F 60 PUSH1 0x20 0511 01 ADD 0512 35 CALLDATALOAD 0513 61 PUSH2 0x15c5 0516 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @050E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0512 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x15c5 label_0517: // Incoming return from call to 0x0501 at 0x04FC // Inputs[2] // { // @051A memory[0x40:0x60] // @051C stack[-1] // } 0517 5B JUMPDEST 0518 60 PUSH1 0x40 051A 51 MLOAD 051B 80 DUP1 051C 82 DUP3 051D 60 PUSH1 0x02 051F 81 DUP2 0520 11 GT 0521 15 ISZERO 0522 61 PUSH2 0x0527 0525 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @051A stack[0] = memory[0x40:0x60] // @051B stack[1] = memory[0x40:0x60] // @051C stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0527, if !(stack[-1] > 0x02) label_0526: // Incoming jump from 0x0525, if not !(stack[-1] > 0x02) 0526 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0526 assert(); } // Block terminates label_0527: // Incoming jump from 0x0525, if !(stack[-1] > 0x02) // Inputs[5] // { // @052A stack[-1] // @052B stack[-2] // @0530 stack[-4] // @0535 memory[0x40:0x60] // @053A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-2]) - memory[0x40:0x60]] // } 0527 5B JUMPDEST 0528 60 PUSH1 0xff 052A 16 AND 052B 81 DUP2 052C 52 MSTORE 052D 60 PUSH1 0x20 052F 01 ADD 0530 91 SWAP2 0531 50 POP 0532 50 POP 0533 60 PUSH1 0x40 0535 51 MLOAD 0536 80 DUP1 0537 91 SWAP2 0538 03 SUB 0539 90 SWAP1 053A F3 *RETURN // Stack delta = -4 // Outputs[2] // { // @052C memory[stack[-2]:stack[-2] + 0x20] = 0xff & stack[-1] // @053A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-2]) - memory[0x40:0x60]]; // } // Block terminates label_053B: // Incoming jump from 0x0393, if 0x10c8b404 == stack[-1] 053B 5B JUMPDEST 053C 61 PUSH2 0x0543 053F 61 PUSH2 0x15e6 0542 56 *JUMP // Stack delta = +1 // Outputs[1] { @053C stack[0] = 0x0543 } // Block ends with call to 0x15e6, returns to 0x0543 label_0543: // Incoming return from call to 0x3A79 at 0x0EF5 // Incoming return from call to 0x2E50 at 0x0C01 // Incoming return from call to 0x0A08 at 0x0A03 // Incoming return from call to 0x1C56 at 0x0727 // Incoming return from call to 0x437B at 0x1308 // Incoming return from call to 0x0F68 at 0x0F63 // Incoming return from call to 0x15E6 at 0x0542 // Incoming return from call to 0x0AAE at 0x0AA9 // Incoming return from call to 0x0A36 at 0x0A31 // Incoming return from call to 0x25C5 at 0x09F1 // Incoming return from call to 0x1DA8 at 0x0755 // Incoming return from call to 0x31DF at 0x0CBA // Incoming return from call to 0x17A0 at 0x0640 // Inputs[4] // { // @0547 memory[0x40:0x60] // @0548 stack[-1] // @054B memory[0x40:0x60] // @0554 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0543 5B JUMPDEST 0544 60 PUSH1 0x40 0546 80 DUP1 0547 51 MLOAD 0548 91 SWAP2 0549 82 DUP3 054A 52 MSTORE 054B 51 MLOAD 054C 90 SWAP1 054D 81 DUP2 054E 90 SWAP1 054F 03 SUB 0550 60 PUSH1 0x20 0552 01 ADD 0553 90 SWAP1 0554 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @054A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0554 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0555: // Incoming jump from 0x039E, if 0x153a1f3e == stack[-1] // Inputs[1] { @055C msg.data.length } 0555 5B JUMPDEST 0556 61 PUSH2 0x04e9 0559 60 PUSH1 0x04 055B 80 DUP1 055C 36 CALLDATASIZE 055D 03 SUB 055E 60 PUSH1 0x40 0560 81 DUP2 0561 10 LT 0562 15 ISZERO 0563 61 PUSH2 0x056b 0566 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0556 stack[0] = 0x04e9 // @0559 stack[1] = 0x04 // @055D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x056b, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x40) label_0567: // Incoming jump from 0x0566, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @056A memory[0x00:0x00] } 0567 60 PUSH1 0x00 0569 80 DUP1 056A FD *REVERT // Stack delta = +0 // Outputs[1] { @056A revert(memory[0x00:0x00]); } // Block terminates label_056B: // Incoming call from 0x0566, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @056C stack[-2] // @056D stack[-1] // @0574 msg.data[stack[-2]:stack[-2] + 0x20] // } 056B 5B JUMPDEST 056C 81 DUP2 056D 01 ADD 056E 90 SWAP1 056F 60 PUSH1 0x20 0571 81 DUP2 0572 01 ADD 0573 81 DUP2 0574 35 CALLDATALOAD 0575 60 PUSH1 0x01 0577 60 PUSH1 0x20 0579 1B SHL 057A 81 DUP2 057B 11 GT 057C 15 ISZERO 057D 61 PUSH2 0x0585 0580 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @056E stack[-1] = stack[-2] // @056E stack[-2] = stack[-2] + stack[-1] // @0572 stack[0] = stack[-2] + 0x20 // @0574 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0585, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0581: // Incoming jump from 0x0580, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0584 memory[0x00:0x00] } 0581 60 PUSH1 0x00 0583 80 DUP1 0584 FD *REVERT // Stack delta = +0 // Outputs[1] { @0584 revert(memory[0x00:0x00]); } // Block terminates label_0585: // Incoming jump from 0x0580, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0586 stack[-3] // @0587 stack[-1] // @0588 stack[-4] // } 0585 5B JUMPDEST 0586 82 DUP3 0587 01 ADD 0588 83 DUP4 0589 60 PUSH1 0x20 058B 82 DUP3 058C 01 ADD 058D 11 GT 058E 15 ISZERO 058F 61 PUSH2 0x0597 0592 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0587 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0597, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0593: // Incoming jump from 0x0592, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0596 memory[0x00:0x00] } 0593 60 PUSH1 0x00 0595 80 DUP1 0596 FD *REVERT // Stack delta = +0 // Outputs[1] { @0596 revert(memory[0x00:0x00]); } // Block terminates label_0597: // Incoming jump from 0x0592, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0598 stack[-1] // @0599 msg.data[stack[-1]:stack[-1] + 0x20] // @059E stack[-2] // @059F stack[-4] // } 0597 5B JUMPDEST 0598 80 DUP1 0599 35 CALLDATALOAD 059A 90 SWAP1 059B 60 PUSH1 0x20 059D 01 ADD 059E 91 SWAP2 059F 84 DUP5 05A0 60 PUSH1 0x20 05A2 83 DUP4 05A3 02 MUL 05A4 84 DUP5 05A5 01 ADD 05A6 11 GT 05A7 60 PUSH1 0x01 05A9 60 PUSH1 0x20 05AB 1B SHL 05AC 83 DUP4 05AD 11 GT 05AE 17 OR 05AF 15 ISZERO 05B0 61 PUSH2 0x05b8 05B3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @059A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @059E stack[0] = stack[-2] // @059E stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x05b8, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_05B4: // Incoming jump from 0x05B3, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @05B7 memory[0x00:0x00] } 05B4 60 PUSH1 0x00 05B6 80 DUP1 05B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B7 revert(memory[0x00:0x00]); } // Block terminates label_05B8: // Incoming jump from 0x05B3, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[6] // { // @05B9 stack[-3] // @05B9 stack[-1] // @05BA stack[-5] // @05BB stack[-2] // @05BC stack[-4] // @05C4 msg.data[stack[-1]:stack[-1] + 0x20] // } 05B8 5B JUMPDEST 05B9 91 SWAP2 05BA 93 SWAP4 05BB 90 SWAP1 05BC 92 SWAP3 05BD 90 SWAP1 05BE 91 SWAP2 05BF 60 PUSH1 0x20 05C1 81 DUP2 05C2 01 ADD 05C3 90 SWAP1 05C4 35 CALLDATALOAD 05C5 60 PUSH1 0x01 05C7 60 PUSH1 0x20 05C9 1B SHL 05CA 81 DUP2 05CB 11 GT 05CC 15 ISZERO 05CD 61 PUSH2 0x05d5 05D0 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @05BA stack[-5] = stack[-3] // @05BC stack[-4] = stack[-2] // @05BD stack[-2] = stack[-4] // @05BE stack[-3] = stack[-5] // @05C3 stack[-1] = stack[-1] + 0x20 // @05C4 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x05d5, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_05D1: // Incoming jump from 0x05D0, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @05D4 memory[0x00:0x00] } 05D1 60 PUSH1 0x00 05D3 80 DUP1 05D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D4 revert(memory[0x00:0x00]); } // Block terminates label_05D5: // Incoming jump from 0x05D0, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @05D6 stack[-3] // @05D7 stack[-1] // @05D8 stack[-4] // } 05D5 5B JUMPDEST 05D6 82 DUP3 05D7 01 ADD 05D8 83 DUP4 05D9 60 PUSH1 0x20 05DB 82 DUP3 05DC 01 ADD 05DD 11 GT 05DE 15 ISZERO 05DF 61 PUSH2 0x05e7 05E2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05D7 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x05e7, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_05E3: // Incoming jump from 0x05E2, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @05E6 memory[0x00:0x00] } 05E3 60 PUSH1 0x00 05E5 80 DUP1 05E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E6 revert(memory[0x00:0x00]); } // Block terminates label_05E7: // Incoming jump from 0x05E2, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @05E8 stack[-1] // @05E9 msg.data[stack[-1]:stack[-1] + 0x20] // @05EE stack[-2] // @05EF stack[-4] // } 05E7 5B JUMPDEST 05E8 80 DUP1 05E9 35 CALLDATALOAD 05EA 90 SWAP1 05EB 60 PUSH1 0x20 05ED 01 ADD 05EE 91 SWAP2 05EF 84 DUP5 05F0 60 PUSH1 0x20 05F2 83 DUP4 05F3 02 MUL 05F4 84 DUP5 05F5 01 ADD 05F6 11 GT 05F7 60 PUSH1 0x01 05F9 60 PUSH1 0x20 05FB 1B SHL 05FC 83 DUP4 05FD 11 GT 05FE 17 OR 05FF 15 ISZERO 0600 61 PUSH2 0x0608 0603 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05EA stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @05EE stack[0] = stack[-2] // @05EE stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0608, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0604: // Incoming jump from 0x0603, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0607 memory[0x00:0x00] } 0604 60 PUSH1 0x00 0606 80 DUP1 0607 FD *REVERT // Stack delta = +0 // Outputs[1] { @0607 revert(memory[0x00:0x00]); } // Block terminates label_0608: // Incoming jump from 0x0603, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[4] // { // @060A stack[-3] // @060A stack[-2] // @060B stack[-5] // @060D stack[-4] // } 0608 5B JUMPDEST 0609 50 POP 060A 90 SWAP1 060B 92 SWAP3 060C 50 POP 060D 90 SWAP1 060E 50 POP 060F 61 PUSH2 0x160a 0612 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @060B stack[-5] = stack[-3] // @060D stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x160a label_0613: // Incoming jump from 0x03A9, if 0x17df4745 == stack[-1] // Inputs[1] { @061A msg.data.length } 0613 5B JUMPDEST 0614 61 PUSH2 0x04e9 0617 60 PUSH1 0x04 0619 80 DUP1 061A 36 CALLDATASIZE 061B 03 SUB 061C 60 PUSH1 0x20 061E 81 DUP2 061F 10 LT 0620 15 ISZERO 0621 61 PUSH2 0x0629 0624 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0614 stack[0] = 0x04e9 // @0617 stack[1] = 0x04 // @061B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0629, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0625: // Incoming jump from 0x0624, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0628 memory[0x00:0x00] } 0625 60 PUSH1 0x00 0627 80 DUP1 0628 FD *REVERT // Stack delta = +0 // Outputs[1] { @0628 revert(memory[0x00:0x00]); } // Block terminates label_0629: // Incoming call from 0x0624, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @062B msg.data[stack[-2]:stack[-2] + 0x20] // @062B stack[-2] // } 0629 5B JUMPDEST 062A 50 POP 062B 35 CALLDATALOAD 062C 60 PUSH1 0x01 062E 60 PUSH1 0x01 0630 60 PUSH1 0xa0 0632 1B SHL 0633 03 SUB 0634 16 AND 0635 61 PUSH2 0x16e9 0638 56 *JUMP // Stack delta = -1 // Outputs[1] { @0634 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x16e9 label_0639: // Incoming jump from 0x034C, if 0x18160ddd == stack[-1] 0639 5B JUMPDEST 063A 61 PUSH2 0x0543 063D 61 PUSH2 0x17a0 0640 56 *JUMP // Stack delta = +1 // Outputs[1] { @063A stack[0] = 0x0543 } // Block ends with call to 0x17a0, returns to 0x0543 label_0641: // Incoming jump from 0x0357, if 0x1947c5e2 == stack[-1] // Inputs[1] { @0648 msg.data.length } 0641 5B JUMPDEST 0642 61 PUSH2 0x04e9 0645 60 PUSH1 0x04 0647 80 DUP1 0648 36 CALLDATASIZE 0649 03 SUB 064A 60 PUSH1 0x20 064C 81 DUP2 064D 10 LT 064E 15 ISZERO 064F 61 PUSH2 0x0657 0652 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0642 stack[0] = 0x04e9 // @0645 stack[1] = 0x04 // @0649 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0657, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0653: // Incoming jump from 0x0652, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0656 memory[0x00:0x00] } 0653 60 PUSH1 0x00 0655 80 DUP1 0656 FD *REVERT // Stack delta = +0 // Outputs[1] { @0656 revert(memory[0x00:0x00]); } // Block terminates label_0657: // Incoming call from 0x0652, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0659 msg.data[stack[-2]:stack[-2] + 0x20] // @0659 stack[-2] // } 0657 5B JUMPDEST 0658 50 POP 0659 35 CALLDATALOAD 065A 60 PUSH1 0x01 065C 60 PUSH1 0x01 065E 60 PUSH1 0xa0 0660 1B SHL 0661 03 SUB 0662 16 AND 0663 61 PUSH2 0x1868 0666 56 *JUMP // Stack delta = -1 // Outputs[1] { @0662 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1868 label_0667: // Incoming jump from 0x0362, if 0x1c94c2c3 == stack[-1] // Inputs[1] { @066E msg.data.length } 0667 5B JUMPDEST 0668 61 PUSH2 0x04e9 066B 60 PUSH1 0x04 066D 80 DUP1 066E 36 CALLDATASIZE 066F 03 SUB 0670 61 PUSH2 0x0120 0673 81 DUP2 0674 10 LT 0675 15 ISZERO 0676 61 PUSH2 0x067e 0679 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0668 stack[0] = 0x04e9 // @066B stack[1] = 0x04 // @066F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x067e, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) label_067A: // Incoming jump from 0x0679, if not !(msg.data.length - 0x04 < 0x0120) // Inputs[1] { @067D memory[0x00:0x00] } 067A 60 PUSH1 0x00 067C 80 DUP1 067D FD *REVERT // Stack delta = +0 // Outputs[1] { @067D revert(memory[0x00:0x00]); } // Block terminates label_067E: // Incoming call from 0x0679, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) // Inputs[10] // { // @0688 stack[-2] // @0689 msg.data[stack[-2]:stack[-2] + 0x20] // @0691 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @069A msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @06A0 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @06A6 msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @06AC msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @06B4 msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] // @06BB msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @06C1 msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } 067E 5B JUMPDEST 067F 50 POP 0680 60 PUSH1 0x01 0682 60 PUSH1 0x01 0684 60 PUSH1 0xa0 0686 1B SHL 0687 03 SUB 0688 81 DUP2 0689 35 CALLDATALOAD 068A 81 DUP2 068B 16 AND 068C 91 SWAP2 068D 60 PUSH1 0x20 068F 81 DUP2 0690 01 ADD 0691 35 CALLDATALOAD 0692 90 SWAP1 0693 91 SWAP2 0694 16 AND 0695 90 SWAP1 0696 60 PUSH1 0x40 0698 81 DUP2 0699 01 ADD 069A 35 CALLDATALOAD 069B 90 SWAP1 069C 60 PUSH1 0x60 069E 81 DUP2 069F 01 ADD 06A0 35 CALLDATALOAD 06A1 90 SWAP1 06A2 60 PUSH1 0x80 06A4 81 DUP2 06A5 01 ADD 06A6 35 CALLDATALOAD 06A7 90 SWAP1 06A8 60 PUSH1 0xa0 06AA 81 DUP2 06AB 01 ADD 06AC 35 CALLDATALOAD 06AD 90 SWAP1 06AE 60 PUSH1 0xff 06B0 60 PUSH1 0xc0 06B2 82 DUP3 06B3 01 ADD 06B4 35 CALLDATALOAD 06B5 16 AND 06B6 90 SWAP1 06B7 60 PUSH1 0xe0 06B9 81 DUP2 06BA 01 ADD 06BB 35 CALLDATALOAD 06BC 90 SWAP1 06BD 61 PUSH2 0x0100 06C0 01 ADD 06C1 35 CALLDATALOAD 06C2 61 PUSH2 0x191e 06C5 56 *JUMP // Stack delta = +7 // Outputs[9] // { // @068C stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0695 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @069B stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @06A1 stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @06A7 stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @06AD stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @06B6 stack[4] = msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] & 0xff // @06BC stack[5] = msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @06C1 stack[6] = msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x191e label_06C6: // Incoming jump from 0x036D, if 0x23b872dd == stack[-1] // Inputs[1] { @06CD msg.data.length } 06C6 5B JUMPDEST 06C7 61 PUSH2 0x0489 06CA 60 PUSH1 0x04 06CC 80 DUP1 06CD 36 CALLDATASIZE 06CE 03 SUB 06CF 60 PUSH1 0x60 06D1 81 DUP2 06D2 10 LT 06D3 15 ISZERO 06D4 61 PUSH2 0x06dc 06D7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06C7 stack[0] = 0x0489 // @06CA stack[1] = 0x04 // @06CE stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06dc, returns to 0x0489, if !(msg.data.length - 0x04 < 0x60) label_06D8: // Incoming jump from 0x06D7, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @06DB memory[0x00:0x00] } 06D8 60 PUSH1 0x00 06DA 80 DUP1 06DB FD *REVERT // Stack delta = +0 // Outputs[1] { @06DB revert(memory[0x00:0x00]); } // Block terminates label_06DC: // Incoming call from 0x06D7, returns to 0x0489, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @06E6 stack[-2] // @06E7 msg.data[stack[-2]:stack[-2] + 0x20] // @06EF msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @06F7 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 06DC 5B JUMPDEST 06DD 50 POP 06DE 60 PUSH1 0x01 06E0 60 PUSH1 0x01 06E2 60 PUSH1 0xa0 06E4 1B SHL 06E5 03 SUB 06E6 81 DUP2 06E7 35 CALLDATALOAD 06E8 81 DUP2 06E9 16 AND 06EA 91 SWAP2 06EB 60 PUSH1 0x20 06ED 81 DUP2 06EE 01 ADD 06EF 35 CALLDATALOAD 06F0 90 SWAP1 06F1 91 SWAP2 06F2 16 AND 06F3 90 SWAP1 06F4 60 PUSH1 0x40 06F6 01 ADD 06F7 35 CALLDATALOAD 06F8 61 PUSH2 0x1a5c 06FB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @06EA stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @06F3 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @06F7 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1a5c label_06FC: // Incoming jump from 0x031B, if 0x2630c12f == stack[-1] 06FC 5B JUMPDEST 06FD 61 PUSH2 0x0704 0700 61 PUSH2 0x1c47 0703 56 *JUMP // Stack delta = +1 // Outputs[1] { @06FD stack[0] = 0x0704 } // Block ends with call to 0x1c47, returns to 0x0704 label_0704: // Incoming return from call to 0x389D at 0x0E70 // Incoming return from call to 0x3272 at 0x0CEE // Incoming return from call to 0x2DAA at 0x0BF1 // Incoming return from call to 0x1C47 at 0x0703 // Inputs[4] // { // @0708 memory[0x40:0x60] // @0712 stack[-1] // @0716 memory[0x40:0x60] // @071F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0704 5B JUMPDEST 0705 60 PUSH1 0x40 0707 80 DUP1 0708 51 MLOAD 0709 60 PUSH1 0x01 070B 60 PUSH1 0x01 070D 60 PUSH1 0xa0 070F 1B SHL 0710 03 SUB 0711 90 SWAP1 0712 92 SWAP3 0713 16 AND 0714 82 DUP3 0715 52 MSTORE 0716 51 MLOAD 0717 90 SWAP1 0718 81 DUP2 0719 90 SWAP1 071A 03 SUB 071B 60 PUSH1 0x20 071D 01 ADD 071E 90 SWAP1 071F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0715 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @071F return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0720: // Incoming jump from 0x0326, if 0x30adf81f == stack[-1] 0720 5B JUMPDEST 0721 61 PUSH2 0x0543 0724 61 PUSH2 0x1c56 0727 56 *JUMP // Stack delta = +1 // Outputs[1] { @0721 stack[0] = 0x0543 } // Block ends with call to 0x1c56, returns to 0x0543 label_0728: // Incoming jump from 0x0331, if 0x313ce567 == stack[-1] 0728 5B JUMPDEST 0729 61 PUSH2 0x0730 072C 61 PUSH2 0x1c7a 072F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0729 stack[0] = 0x0730 } // Block ends with call to 0x1c7a, returns to 0x0730 label_0730: // Incoming return from call to 0x1C7A at 0x072F // Inputs[4] // { // @0734 memory[0x40:0x60] // @0738 stack[-1] // @073C memory[0x40:0x60] // @0745 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0730 5B JUMPDEST 0731 60 PUSH1 0x40 0733 80 DUP1 0734 51 MLOAD 0735 60 PUSH1 0xff 0737 90 SWAP1 0738 92 SWAP3 0739 16 AND 073A 82 DUP3 073B 52 MSTORE 073C 51 MLOAD 073D 90 SWAP1 073E 81 DUP2 073F 90 SWAP1 0740 03 SUB 0741 60 PUSH1 0x20 0743 01 ADD 0744 90 SWAP1 0745 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @073B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @0745 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0746: // Incoming jump from 0x033C, if 0x33a8c45a == stack[-1] 0746 5B JUMPDEST 0747 61 PUSH2 0x03e8 074A 61 PUSH2 0x1d11 074D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0747 stack[0] = 0x03e8 } // Block ends with call to 0x1d11, returns to 0x03E8 label_074E: // Incoming jump from 0x02D4, if 0x3644e515 == stack[-1] 074E 5B JUMPDEST 074F 61 PUSH2 0x0543 0752 61 PUSH2 0x1da8 0755 56 *JUMP // Stack delta = +1 // Outputs[1] { @074F stack[0] = 0x0543 } // Block ends with call to 0x1da8, returns to 0x0543 label_0756: // Incoming jump from 0x02DF, if 0x3ed04ad6 == stack[-1] // Inputs[1] { @075D msg.data.length } 0756 5B JUMPDEST 0757 61 PUSH2 0x04e9 075A 60 PUSH1 0x04 075C 80 DUP1 075D 36 CALLDATASIZE 075E 03 SUB 075F 60 PUSH1 0x20 0761 81 DUP2 0762 10 LT 0763 15 ISZERO 0764 61 PUSH2 0x076c 0767 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0757 stack[0] = 0x04e9 // @075A stack[1] = 0x04 // @075E stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x076c, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0768: // Incoming jump from 0x0767, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @076B memory[0x00:0x00] } 0768 60 PUSH1 0x00 076A 80 DUP1 076B FD *REVERT // Stack delta = +0 // Outputs[1] { @076B revert(memory[0x00:0x00]); } // Block terminates label_076C: // Incoming call from 0x0767, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @076E stack[-2] // @076E msg.data[stack[-2]:stack[-2] + 0x20] // } 076C 5B JUMPDEST 076D 50 POP 076E 35 CALLDATALOAD 076F 60 PUSH1 0x01 0771 60 PUSH1 0x01 0773 60 PUSH1 0xa0 0775 1B SHL 0776 03 SUB 0777 16 AND 0778 61 PUSH2 0x1daf 077B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0777 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1daf label_077C: // Incoming jump from 0x02EA, if 0x40c10f19 == stack[-1] // Inputs[1] { @0783 msg.data.length } 077C 5B JUMPDEST 077D 61 PUSH2 0x04e9 0780 60 PUSH1 0x04 0782 80 DUP1 0783 36 CALLDATASIZE 0784 03 SUB 0785 60 PUSH1 0x40 0787 81 DUP2 0788 10 LT 0789 15 ISZERO 078A 61 PUSH2 0x0792 078D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @077D stack[0] = 0x04e9 // @0780 stack[1] = 0x04 // @0784 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0792, if !(msg.data.length - 0x04 < 0x40) label_078E: // Incoming jump from 0x078D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0791 memory[0x00:0x00] } 078E 60 PUSH1 0x00 0790 80 DUP1 0791 FD *REVERT // Stack delta = +0 // Outputs[1] { @0791 revert(memory[0x00:0x00]); } // Block terminates label_0792: // Incoming jump from 0x078D, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @079C stack[-2] // @079D msg.data[stack[-2]:stack[-2] + 0x20] // @07A3 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0792 5B JUMPDEST 0793 50 POP 0794 60 PUSH1 0x01 0796 60 PUSH1 0x01 0798 60 PUSH1 0xa0 079A 1B SHL 079B 03 SUB 079C 81 DUP2 079D 35 CALLDATALOAD 079E 16 AND 079F 90 SWAP1 07A0 60 PUSH1 0x20 07A2 01 ADD 07A3 35 CALLDATALOAD 07A4 61 PUSH2 0x1e65 07A7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @079F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @07A3 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1e65 label_07A8: // Incoming jump from 0x02F5, if 0x44b0f448 == stack[-1] // Inputs[1] { @07AF msg.data.length } 07A8 5B JUMPDEST 07A9 61 PUSH2 0x04e9 07AC 60 PUSH1 0x04 07AE 80 DUP1 07AF 36 CALLDATASIZE 07B0 03 SUB 07B1 60 PUSH1 0x20 07B3 81 DUP2 07B4 10 LT 07B5 15 ISZERO 07B6 61 PUSH2 0x07be 07B9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07A9 stack[0] = 0x04e9 // @07AC stack[1] = 0x04 // @07B0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x07be, if !(msg.data.length - 0x04 < 0x20) label_07BA: // Incoming jump from 0x07B9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @07BD memory[0x00:0x00] } 07BA 60 PUSH1 0x00 07BC 80 DUP1 07BD FD *REVERT // Stack delta = +0 // Outputs[1] { @07BD revert(memory[0x00:0x00]); } // Block terminates label_07BE: // Incoming jump from 0x07B9, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @07BF stack[-2] // @07C0 stack[-1] // @07C7 msg.data[stack[-2]:stack[-2] + 0x20] // } 07BE 5B JUMPDEST 07BF 81 DUP2 07C0 01 ADD 07C1 90 SWAP1 07C2 60 PUSH1 0x20 07C4 81 DUP2 07C5 01 ADD 07C6 81 DUP2 07C7 35 CALLDATALOAD 07C8 60 PUSH1 0x01 07CA 60 PUSH1 0x20 07CC 1B SHL 07CD 81 DUP2 07CE 11 GT 07CF 15 ISZERO 07D0 61 PUSH2 0x07d8 07D3 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @07C1 stack[-1] = stack[-2] // @07C1 stack[-2] = stack[-2] + stack[-1] // @07C5 stack[0] = stack[-2] + 0x20 // @07C7 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x07d8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_07D4: // Incoming jump from 0x07D3, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @07D7 memory[0x00:0x00] } 07D4 60 PUSH1 0x00 07D6 80 DUP1 07D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @07D7 revert(memory[0x00:0x00]); } // Block terminates label_07D8: // Incoming jump from 0x07D3, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @07D9 stack[-3] // @07DA stack[-1] // @07DB stack[-4] // } 07D8 5B JUMPDEST 07D9 82 DUP3 07DA 01 ADD 07DB 83 DUP4 07DC 60 PUSH1 0x20 07DE 82 DUP3 07DF 01 ADD 07E0 11 GT 07E1 15 ISZERO 07E2 61 PUSH2 0x07ea 07E5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07DA stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x07ea, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_07E6: // Incoming jump from 0x07E5, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @07E9 memory[0x00:0x00] } 07E6 60 PUSH1 0x00 07E8 80 DUP1 07E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @07E9 revert(memory[0x00:0x00]); } // Block terminates label_07EA: // Incoming jump from 0x07E5, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @07EB stack[-1] // @07EC msg.data[stack[-1]:stack[-1] + 0x20] // @07F1 stack[-2] // @07F2 stack[-4] // } 07EA 5B JUMPDEST 07EB 80 DUP1 07EC 35 CALLDATALOAD 07ED 90 SWAP1 07EE 60 PUSH1 0x20 07F0 01 ADD 07F1 91 SWAP2 07F2 84 DUP5 07F3 60 PUSH1 0x20 07F5 83 DUP4 07F6 02 MUL 07F7 84 DUP5 07F8 01 ADD 07F9 11 GT 07FA 60 PUSH1 0x01 07FC 60 PUSH1 0x20 07FE 1B SHL 07FF 83 DUP4 0800 11 GT 0801 17 OR 0802 15 ISZERO 0803 61 PUSH2 0x080b 0806 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07ED stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @07F1 stack[0] = stack[-2] // @07F1 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x080b, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0807: // Incoming jump from 0x0806, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @080A memory[0x00:0x00] } 0807 60 PUSH1 0x00 0809 80 DUP1 080A FD *REVERT // Stack delta = +0 // Outputs[1] { @080A revert(memory[0x00:0x00]); } // Block terminates label_080B: // Incoming jump from 0x0806, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[4] // { // @080D stack[-2] // @080D stack[-3] // @080E stack[-5] // @0810 stack[-4] // } 080B 5B JUMPDEST 080C 50 POP 080D 90 SWAP1 080E 92 SWAP3 080F 50 POP 0810 90 SWAP1 0811 50 POP 0812 61 PUSH2 0x1fed 0815 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @080E stack[-5] = stack[-3] // @0810 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x1fed label_0816: // Incoming jump from 0x02A3, if 0x46336542 == stack[-1] // Inputs[1] { @081D msg.data.length } 0816 5B JUMPDEST 0817 61 PUSH2 0x0489 081A 60 PUSH1 0x04 081C 80 DUP1 081D 36 CALLDATASIZE 081E 03 SUB 081F 60 PUSH1 0x20 0821 81 DUP2 0822 10 LT 0823 15 ISZERO 0824 61 PUSH2 0x082c 0827 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0817 stack[0] = 0x0489 // @081A stack[1] = 0x04 // @081E stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x082c, if !(msg.data.length - 0x04 < 0x20) label_0828: // Incoming jump from 0x0827, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @082B memory[0x00:0x00] } 0828 60 PUSH1 0x00 082A 80 DUP1 082B FD *REVERT // Stack delta = +0 // Outputs[1] { @082B revert(memory[0x00:0x00]); } // Block terminates label_082C: // Incoming jump from 0x0827, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @082E stack[-2] // @082E msg.data[stack[-2]:stack[-2] + 0x20] // } 082C 5B JUMPDEST 082D 50 POP 082E 35 CALLDATALOAD 082F 60 PUSH1 0x01 0831 60 PUSH1 0x01 0833 60 PUSH1 0xa0 0835 1B SHL 0836 03 SUB 0837 16 AND 0838 61 PUSH2 0x20cf 083B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0837 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x20cf label_083C: // Incoming jump from 0x02AE, if 0x485cc955 == stack[-1] // Inputs[1] { @0843 msg.data.length } 083C 5B JUMPDEST 083D 61 PUSH2 0x04e9 0840 60 PUSH1 0x04 0842 80 DUP1 0843 36 CALLDATASIZE 0844 03 SUB 0845 60 PUSH1 0x40 0847 81 DUP2 0848 10 LT 0849 15 ISZERO 084A 61 PUSH2 0x0852 084D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @083D stack[0] = 0x04e9 // @0840 stack[1] = 0x04 // @0844 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0852, if !(msg.data.length - 0x04 < 0x40) label_084E: // Incoming jump from 0x084D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0851 memory[0x00:0x00] } 084E 60 PUSH1 0x00 0850 80 DUP1 0851 FD *REVERT // Stack delta = +0 // Outputs[1] { @0851 revert(memory[0x00:0x00]); } // Block terminates label_0852: // Incoming jump from 0x084D, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @085C stack[-2] // @085D msg.data[stack[-2]:stack[-2] + 0x20] // @0864 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0852 5B JUMPDEST 0853 50 POP 0854 60 PUSH1 0x01 0856 60 PUSH1 0x01 0858 60 PUSH1 0xa0 085A 1B SHL 085B 03 SUB 085C 81 DUP2 085D 35 CALLDATALOAD 085E 81 DUP2 085F 16 AND 0860 91 SWAP2 0861 60 PUSH1 0x20 0863 01 ADD 0864 35 CALLDATALOAD 0865 16 AND 0866 61 PUSH2 0x20e3 0869 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0860 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0865 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x20e3 label_086A: // Incoming jump from 0x02B9, if 0x52f6747a == stack[-1] 086A 5B JUMPDEST 086B 61 PUSH2 0x0872 086E 61 PUSH2 0x2191 0871 56 *JUMP // Stack delta = +1 // Outputs[1] { @086B stack[0] = 0x0872 } // Block ends with call to 0x2191, returns to 0x0872 label_0872: // Incoming return from call to 0x2191 at 0x0871 // Inputs[4] // { // @0875 memory[0x40:0x60] // @0884 stack[-2] // @0887 memory[stack[-2]:stack[-2] + 0x20] // @0890 memory[stack[-2]:stack[-2] + 0x20] // } 0872 5B JUMPDEST 0873 60 PUSH1 0x40 0875 51 MLOAD 0876 80 DUP1 0877 80 DUP1 0878 60 PUSH1 0x20 087A 01 ADD 087B 80 DUP1 087C 60 PUSH1 0x20 087E 01 ADD 087F 83 DUP4 0880 81 DUP2 0881 03 SUB 0882 83 DUP4 0883 52 MSTORE 0884 85 DUP6 0885 81 DUP2 0886 81 DUP2 0887 51 MLOAD 0888 81 DUP2 0889 52 MSTORE 088A 60 PUSH1 0x20 088C 01 ADD 088D 91 SWAP2 088E 50 POP 088F 80 DUP1 0890 51 MLOAD 0891 90 SWAP1 0892 60 PUSH1 0x20 0894 01 ADD 0895 90 SWAP1 0896 60 PUSH1 0x20 0898 02 MUL 0899 80 DUP1 089A 83 DUP4 089B 83 DUP4 089C 60 PUSH1 0x00 089E 5B JUMPDEST 089F 83 DUP4 08A0 81 DUP2 08A1 10 LT 08A2 15 ISZERO 08A3 61 PUSH2 0x08b6 08A6 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0875 stack[0] = memory[0x40:0x60] // @0876 stack[1] = memory[0x40:0x60] // @087A stack[2] = 0x20 + memory[0x40:0x60] // @0883 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0889 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @088D stack[3] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0895 stack[4] = 0x20 + stack[-2] // @0898 stack[5] = 0x20 * memory[stack[-2]:stack[-2] + 0x20] // @0899 stack[6] = 0x20 * memory[stack[-2]:stack[-2] + 0x20] // @089A stack[7] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @089B stack[8] = 0x20 + stack[-2] // @089C stack[9] = 0x00 // } // Block ends with conditional jump to 0x08b6, if !(0x00 < 0x20 * memory[stack[-2]:stack[-2] + 0x20]) label_08A7: // Incoming jump from 0x08A6, if not !(0x00 < 0x20 * memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x08A6, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @08A7 stack[-2] // @08A8 stack[-1] // @08AA memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @08AB stack[-3] // } 08A7 81 DUP2 08A8 81 DUP2 08A9 01 ADD 08AA 51 MLOAD 08AB 83 DUP4 08AC 82 DUP3 08AD 01 ADD 08AE 52 MSTORE 08AF 60 PUSH1 0x20 08B1 01 ADD 08B2 61 PUSH2 0x089e 08B5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08AE memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @08B1 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x089e label_08B6: // Incoming jump from 0x08A6, if !(0x00 < 0x20 * memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x08A6, if !(stack[-1] < stack[-4]) // Inputs[8] // { // @08BB stack[-5] // @08BB stack[-6] // @08BD stack[-7] // @08BE stack[-10] // @08C1 stack[-8] // @08C3 stack[-11] // @08C6 memory[stack[-11]:stack[-11] + 0x20] // @08CF memory[stack[-11]:stack[-11] + 0x20] // } 08B6 5B JUMPDEST 08B7 50 POP 08B8 50 POP 08B9 50 POP 08BA 50 POP 08BB 90 SWAP1 08BC 50 POP 08BD 01 ADD 08BE 83 DUP4 08BF 81 DUP2 08C0 03 SUB 08C1 82 DUP3 08C2 52 MSTORE 08C3 84 DUP5 08C4 81 DUP2 08C5 81 DUP2 08C6 51 MLOAD 08C7 81 DUP2 08C8 52 MSTORE 08C9 60 PUSH1 0x20 08CB 01 ADD 08CC 91 SWAP2 08CD 50 POP 08CE 80 DUP1 08CF 51 MLOAD 08D0 90 SWAP1 08D1 60 PUSH1 0x20 08D3 01 ADD 08D4 90 SWAP1 08D5 60 PUSH1 0x20 08D7 02 MUL 08D8 80 DUP1 08D9 83 DUP4 08DA 83 DUP4 08DB 60 PUSH1 0x00 08DD 5B JUMPDEST 08DE 83 DUP4 08DF 81 DUP2 08E0 10 LT 08E1 15 ISZERO 08E2 61 PUSH2 0x08f5 08E5 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @08C2 memory[stack[-8]:stack[-8] + 0x20] = (stack[-5] + stack[-7]) - stack[-10] // @08C8 memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-11]:stack[-11] + 0x20] // @08CC stack[-7] = 0x20 + stack[-5] + stack[-7] // @08D4 stack[-6] = 0x20 + stack[-11] // @08D7 stack[-5] = 0x20 * memory[stack[-11]:stack[-11] + 0x20] // @08D8 stack[-4] = 0x20 * memory[stack[-11]:stack[-11] + 0x20] // @08D9 stack[-3] = 0x20 + stack[-5] + stack[-7] // @08DA stack[-2] = 0x20 + stack[-11] // @08DB stack[-1] = 0x00 // } // Block ends with conditional jump to 0x08f5, if !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) label_08E6: // Incoming jump from 0x08E5, if not !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) // Incoming jump from 0x08E5, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @08E6 stack[-2] // @08E7 stack[-1] // @08E9 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @08EA stack[-3] // } 08E6 81 DUP2 08E7 81 DUP2 08E8 01 ADD 08E9 51 MLOAD 08EA 83 DUP4 08EB 82 DUP3 08EC 01 ADD 08ED 52 MSTORE 08EE 60 PUSH1 0x20 08F0 01 ADD 08F1 61 PUSH2 0x08dd 08F4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08ED memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @08F0 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x08dd label_08F5: // Incoming jump from 0x08E5, if !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) // Incoming jump from 0x08E5, if !(stack[-1] < stack[-4]) // Inputs[6] // { // @08FA stack[-6] // @08FA stack[-5] // @08FC stack[-7] // @08FD stack[-12] // @0905 memory[0x40:0x60] // @090A memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 08F5 5B JUMPDEST 08F6 50 POP 08F7 50 POP 08F8 50 POP 08F9 50 POP 08FA 90 SWAP1 08FB 50 POP 08FC 01 ADD 08FD 94 SWAP5 08FE 50 POP 08FF 50 POP 0900 50 POP 0901 50 POP 0902 50 POP 0903 60 PUSH1 0x40 0905 51 MLOAD 0906 80 DUP1 0907 91 SWAP2 0908 03 SUB 0909 90 SWAP1 090A F3 *RETURN // Stack delta = -12 // Outputs[1] { @090A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_090B: // Incoming jump from 0x02C4, if 0x530e784f == stack[-1] // Inputs[1] { @0912 msg.data.length } 090B 5B JUMPDEST 090C 61 PUSH2 0x04e9 090F 60 PUSH1 0x04 0911 80 DUP1 0912 36 CALLDATASIZE 0913 03 SUB 0914 60 PUSH1 0x20 0916 81 DUP2 0917 10 LT 0918 15 ISZERO 0919 61 PUSH2 0x0921 091C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @090C stack[0] = 0x04e9 // @090F stack[1] = 0x04 // @0913 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0921, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_091D: // Incoming jump from 0x091C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0920 memory[0x00:0x00] } 091D 60 PUSH1 0x00 091F 80 DUP1 0920 FD *REVERT // Stack delta = +0 // Outputs[1] { @0920 revert(memory[0x00:0x00]); } // Block terminates label_0921: // Incoming call from 0x091C, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0923 stack[-2] // @0923 msg.data[stack[-2]:stack[-2] + 0x20] // } 0921 5B JUMPDEST 0922 50 POP 0923 35 CALLDATALOAD 0924 60 PUSH1 0x01 0926 60 PUSH1 0x01 0928 60 PUSH1 0xa0 092A 1B SHL 092B 03 SUB 092C 16 AND 092D 61 PUSH2 0x2246 0930 56 *JUMP // Stack delta = -1 // Outputs[1] { @092C stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2246 label_0931: // Incoming jump from 0x0267, if 0x58348cf1 == stack[-1] // Inputs[1] { @0938 msg.data.length } 0931 5B JUMPDEST 0932 61 PUSH2 0x04e9 0935 60 PUSH1 0x04 0937 80 DUP1 0938 36 CALLDATASIZE 0939 03 SUB 093A 60 PUSH1 0x20 093C 81 DUP2 093D 10 LT 093E 15 ISZERO 093F 61 PUSH2 0x0947 0942 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0932 stack[0] = 0x04e9 // @0935 stack[1] = 0x04 // @0939 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0947, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0943: // Incoming jump from 0x0942, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0946 memory[0x00:0x00] } 0943 60 PUSH1 0x00 0945 80 DUP1 0946 FD *REVERT // Stack delta = +0 // Outputs[1] { @0946 revert(memory[0x00:0x00]); } // Block terminates label_0947: // Incoming call from 0x0942, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0949 stack[-2] // @0949 msg.data[stack[-2]:stack[-2] + 0x20] // } 0947 5B JUMPDEST 0948 50 POP 0949 35 CALLDATALOAD 094A 60 PUSH1 0x01 094C 60 PUSH1 0x01 094E 60 PUSH1 0xa0 0950 1B SHL 0951 03 SUB 0952 16 AND 0953 61 PUSH2 0x22fe 0956 56 *JUMP // Stack delta = -1 // Outputs[1] { @0952 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x22fe label_0957: // Incoming jump from 0x0272, if 0x5a049a70 == stack[-1] // Inputs[1] { @095E msg.data.length } 0957 5B JUMPDEST 0958 61 PUSH2 0x04e9 095B 60 PUSH1 0x04 095D 80 DUP1 095E 36 CALLDATASIZE 095F 03 SUB 0960 60 PUSH1 0xa0 0962 81 DUP2 0963 10 LT 0964 15 ISZERO 0965 61 PUSH2 0x096d 0968 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0958 stack[0] = 0x04e9 // @095B stack[1] = 0x04 // @095F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x096d, returns to 0x04E9, if !(msg.data.length - 0x04 < 0xa0) label_0969: // Incoming jump from 0x0968, if not !(msg.data.length - 0x04 < 0xa0) // Inputs[1] { @096C memory[0x00:0x00] } 0969 60 PUSH1 0x00 096B 80 DUP1 096C FD *REVERT // Stack delta = +0 // Outputs[1] { @096C revert(memory[0x00:0x00]); } // Block terminates label_096D: // Incoming call from 0x0968, returns to 0x04E9, if !(msg.data.length - 0x04 < 0xa0) // Inputs[6] // { // @0977 stack[-2] // @0978 msg.data[stack[-2]:stack[-2] + 0x20] // @097F msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0987 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @098E msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0993 msg.data[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // } 096D 5B JUMPDEST 096E 50 POP 096F 60 PUSH1 0x01 0971 60 PUSH1 0x01 0973 60 PUSH1 0xa0 0975 1B SHL 0976 03 SUB 0977 81 DUP2 0978 35 CALLDATALOAD 0979 16 AND 097A 90 SWAP1 097B 60 PUSH1 0x20 097D 81 DUP2 097E 01 ADD 097F 35 CALLDATALOAD 0980 90 SWAP1 0981 60 PUSH1 0xff 0983 60 PUSH1 0x40 0985 82 DUP3 0986 01 ADD 0987 35 CALLDATALOAD 0988 16 AND 0989 90 SWAP1 098A 60 PUSH1 0x60 098C 81 DUP2 098D 01 ADD 098E 35 CALLDATALOAD 098F 90 SWAP1 0990 60 PUSH1 0x80 0992 01 ADD 0993 35 CALLDATALOAD 0994 61 PUSH2 0x23b4 0997 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @097A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0980 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0989 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] & 0xff // @098F stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0993 stack[2] = msg.data[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x23b4 label_0998: // Incoming jump from 0x027D, if 0x66188463 == stack[-1] // Inputs[1] { @099F msg.data.length } 0998 5B JUMPDEST 0999 61 PUSH2 0x04e9 099C 60 PUSH1 0x04 099E 80 DUP1 099F 36 CALLDATASIZE 09A0 03 SUB 09A1 60 PUSH1 0x40 09A3 81 DUP2 09A4 10 LT 09A5 15 ISZERO 09A6 61 PUSH2 0x09ae 09A9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0999 stack[0] = 0x04e9 // @099C stack[1] = 0x04 // @09A0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x09ae, if !(msg.data.length - 0x04 < 0x40) label_09AA: // Incoming jump from 0x09A9, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @09AD memory[0x00:0x00] } 09AA 60 PUSH1 0x00 09AC 80 DUP1 09AD FD *REVERT // Stack delta = +0 // Outputs[1] { @09AD revert(memory[0x00:0x00]); } // Block terminates label_09AE: // Incoming jump from 0x09A9, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @09B8 stack[-2] // @09B9 msg.data[stack[-2]:stack[-2] + 0x20] // @09BF msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 09AE 5B JUMPDEST 09AF 50 POP 09B0 60 PUSH1 0x01 09B2 60 PUSH1 0x01 09B4 60 PUSH1 0xa0 09B6 1B SHL 09B7 03 SUB 09B8 81 DUP2 09B9 35 CALLDATALOAD 09BA 16 AND 09BB 90 SWAP1 09BC 60 PUSH1 0x20 09BE 01 ADD 09BF 35 CALLDATALOAD 09C0 61 PUSH2 0x24c9 09C3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @09BB stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @09BF stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x24c9 label_09C4: // Incoming jump from 0x0288, if 0x68fa8134 == stack[-1] // Inputs[1] { @09CB msg.data.length } 09C4 5B JUMPDEST 09C5 61 PUSH2 0x04e9 09C8 60 PUSH1 0x04 09CA 80 DUP1 09CB 36 CALLDATASIZE 09CC 03 SUB 09CD 60 PUSH1 0x20 09CF 81 DUP2 09D0 10 LT 09D1 15 ISZERO 09D2 61 PUSH2 0x09da 09D5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09C5 stack[0] = 0x04e9 // @09C8 stack[1] = 0x04 // @09CC stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09da, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_09D6: // Incoming jump from 0x09D5, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @09D9 memory[0x00:0x00] } 09D6 60 PUSH1 0x00 09D8 80 DUP1 09D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @09D9 revert(memory[0x00:0x00]); } // Block terminates label_09DA: // Incoming call from 0x09D5, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @09DC msg.data[stack[-2]:stack[-2] + 0x20] // @09DC stack[-2] // } 09DA 5B JUMPDEST 09DB 50 POP 09DC 35 CALLDATALOAD 09DD 60 PUSH1 0x01 09DF 60 PUSH1 0x01 09E1 60 PUSH1 0xa0 09E3 1B SHL 09E4 03 SUB 09E5 16 AND 09E6 61 PUSH2 0x2525 09E9 56 *JUMP // Stack delta = -1 // Outputs[1] { @09E5 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2525 label_09EA: // Incoming jump from 0x0236, if 0x6bb5d5af == stack[-1] 09EA 5B JUMPDEST 09EB 61 PUSH2 0x0543 09EE 61 PUSH2 0x25c5 09F1 56 *JUMP // Stack delta = +1 // Outputs[1] { @09EB stack[0] = 0x0543 } // Block ends with call to 0x25c5, returns to 0x0543 label_09F2: // Incoming jump from 0x0241, if 0x70a08231 == stack[-1] // Inputs[1] { @09F9 msg.data.length } 09F2 5B JUMPDEST 09F3 61 PUSH2 0x0543 09F6 60 PUSH1 0x04 09F8 80 DUP1 09F9 36 CALLDATASIZE 09FA 03 SUB 09FB 60 PUSH1 0x20 09FD 81 DUP2 09FE 10 LT 09FF 15 ISZERO 0A00 61 PUSH2 0x0a08 0A03 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09F3 stack[0] = 0x0543 // @09F6 stack[1] = 0x04 // @09FA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a08, returns to 0x0543, if !(msg.data.length - 0x04 < 0x20) label_0A04: // Incoming jump from 0x0A03, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0A07 memory[0x00:0x00] } 0A04 60 PUSH1 0x00 0A06 80 DUP1 0A07 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A07 revert(memory[0x00:0x00]); } // Block terminates label_0A08: // Incoming call from 0x0A03, returns to 0x0543, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0A0A stack[-2] // @0A0A msg.data[stack[-2]:stack[-2] + 0x20] // } 0A08 5B JUMPDEST 0A09 50 POP 0A0A 35 CALLDATALOAD 0A0B 60 PUSH1 0x01 0A0D 60 PUSH1 0x01 0A0F 60 PUSH1 0xa0 0A11 1B SHL 0A12 03 SUB 0A13 16 AND 0A14 61 PUSH2 0x25e9 0A17 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A13 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x25e9 label_0A18: // Incoming jump from 0x024C, if 0x715018a6 == stack[-1] 0A18 5B JUMPDEST 0A19 61 PUSH2 0x04e9 0A1C 61 PUSH2 0x26b1 0A1F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A19 stack[0] = 0x04e9 } // Block ends with call to 0x26b1, returns to 0x04E9 label_0A20: // Incoming jump from 0x0257, if 0x7bec9b55 == stack[-1] // Inputs[1] { @0A27 msg.data.length } 0A20 5B JUMPDEST 0A21 61 PUSH2 0x0543 0A24 60 PUSH1 0x04 0A26 80 DUP1 0A27 36 CALLDATASIZE 0A28 03 SUB 0A29 60 PUSH1 0x60 0A2B 81 DUP2 0A2C 10 LT 0A2D 15 ISZERO 0A2E 61 PUSH2 0x0a36 0A31 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A21 stack[0] = 0x0543 // @0A24 stack[1] = 0x04 // @0A28 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a36, returns to 0x0543, if !(msg.data.length - 0x04 < 0x60) label_0A32: // Incoming jump from 0x0A31, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0A35 memory[0x00:0x00] } 0A32 60 PUSH1 0x00 0A34 80 DUP1 0A35 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A35 revert(memory[0x00:0x00]); } // Block terminates label_0A36: // Incoming call from 0x0A31, returns to 0x0543, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0A37 stack[-2] // @0A38 msg.data[stack[-2]:stack[-2] + 0x20] // @0A3A stack[-1] // @0A46 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 0A36 5B JUMPDEST 0A37 81 DUP2 0A38 35 CALLDATALOAD 0A39 91 SWAP2 0A3A 90 SWAP1 0A3B 81 DUP2 0A3C 01 ADD 0A3D 90 SWAP1 0A3E 60 PUSH1 0x40 0A40 81 DUP2 0A41 01 ADD 0A42 60 PUSH1 0x20 0A44 82 DUP3 0A45 01 ADD 0A46 35 CALLDATALOAD 0A47 60 PUSH1 0x01 0A49 60 PUSH1 0x20 0A4B 1B SHL 0A4C 81 DUP2 0A4D 11 GT 0A4E 15 ISZERO 0A4F 61 PUSH2 0x0a57 0A52 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0A39 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0A3D stack[0] = stack[-2] // @0A3D stack[-1] = stack[-2] + stack[-1] // @0A41 stack[1] = stack[-2] + 0x40 // @0A46 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x0a57, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_0A53: // Incoming jump from 0x0A52, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0A56 memory[0x00:0x00] } 0A53 60 PUSH1 0x00 0A55 80 DUP1 0A56 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A56 revert(memory[0x00:0x00]); } // Block terminates label_0A57: // Incoming jump from 0x0A52, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0A58 stack[-3] // @0A59 stack[-1] // @0A5A stack[-4] // } 0A57 5B JUMPDEST 0A58 82 DUP3 0A59 01 ADD 0A5A 83 DUP4 0A5B 60 PUSH1 0x20 0A5D 82 DUP3 0A5E 01 ADD 0A5F 11 GT 0A60 15 ISZERO 0A61 61 PUSH2 0x0a69 0A64 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A59 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0a69, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0A65: // Incoming jump from 0x0A64, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0A68 memory[0x00:0x00] } 0A65 60 PUSH1 0x00 0A67 80 DUP1 0A68 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A68 revert(memory[0x00:0x00]); } // Block terminates label_0A69: // Incoming jump from 0x0A64, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0A6A stack[-1] // @0A6B msg.data[stack[-1]:stack[-1] + 0x20] // @0A70 stack[-2] // @0A71 stack[-4] // } 0A69 5B JUMPDEST 0A6A 80 DUP1 0A6B 35 CALLDATALOAD 0A6C 90 SWAP1 0A6D 60 PUSH1 0x20 0A6F 01 ADD 0A70 91 SWAP2 0A71 84 DUP5 0A72 60 PUSH1 0x01 0A74 83 DUP4 0A75 02 MUL 0A76 84 DUP5 0A77 01 ADD 0A78 11 GT 0A79 60 PUSH1 0x01 0A7B 60 PUSH1 0x20 0A7D 1B SHL 0A7E 83 DUP4 0A7F 11 GT 0A80 17 OR 0A81 15 ISZERO 0A82 61 PUSH2 0x0a8a 0A85 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A6C stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0A70 stack[0] = stack[-2] // @0A70 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0a8a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0A86: // Incoming jump from 0x0A85, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0A89 memory[0x00:0x00] } 0A86 60 PUSH1 0x00 0A88 80 DUP1 0A89 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A89 revert(memory[0x00:0x00]); } // Block terminates label_0A8A: // Incoming jump from 0x0A85, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[6] // { // @0A8B stack[-3] // @0A8B stack[-1] // @0A8C stack[-5] // @0A8E stack[-2] // @0A8E stack[-4] // @0A90 msg.data[stack[-1]:stack[-1] + 0x20] // } 0A8A 5B JUMPDEST 0A8B 91 SWAP2 0A8C 93 SWAP4 0A8D 50 POP 0A8E 91 SWAP2 0A8F 50 POP 0A90 35 CALLDATALOAD 0A91 60 PUSH1 0xff 0A93 16 AND 0A94 61 PUSH2 0x2753 0A97 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0A8C stack[-5] = stack[-3] // @0A8E stack[-4] = stack[-2] // @0A93 stack[-3] = 0xff & msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2753 label_0A98: // Incoming jump from 0x01E4, if 0x7ecebe00 == stack[-1] // Inputs[1] { @0A9F msg.data.length } 0A98 5B JUMPDEST 0A99 61 PUSH2 0x0543 0A9C 60 PUSH1 0x04 0A9E 80 DUP1 0A9F 36 CALLDATASIZE 0AA0 03 SUB 0AA1 60 PUSH1 0x20 0AA3 81 DUP2 0AA4 10 LT 0AA5 15 ISZERO 0AA6 61 PUSH2 0x0aae 0AA9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A99 stack[0] = 0x0543 // @0A9C stack[1] = 0x04 // @0AA0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0aae, returns to 0x0543, if !(msg.data.length - 0x04 < 0x20) label_0AAA: // Incoming jump from 0x0AA9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0AAD memory[0x00:0x00] } 0AAA 60 PUSH1 0x00 0AAC 80 DUP1 0AAD FD *REVERT // Stack delta = +0 // Outputs[1] { @0AAD revert(memory[0x00:0x00]); } // Block terminates label_0AAE: // Incoming call from 0x0AA9, returns to 0x0543, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0AB0 msg.data[stack[-2]:stack[-2] + 0x20] // @0AB0 stack[-2] // } 0AAE 5B JUMPDEST 0AAF 50 POP 0AB0 35 CALLDATALOAD 0AB1 60 PUSH1 0x01 0AB3 60 PUSH1 0x01 0AB5 60 PUSH1 0xa0 0AB7 1B SHL 0AB8 03 SUB 0AB9 16 AND 0ABA 61 PUSH2 0x2b2b 0ABD 56 *JUMP // Stack delta = -1 // Outputs[1] { @0AB9 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2b2b label_0ABE: // Incoming jump from 0x01EF, if 0x8140d0dc == stack[-1] // Inputs[1] { @0AC5 msg.data.length } 0ABE 5B JUMPDEST 0ABF 61 PUSH2 0x04e9 0AC2 60 PUSH1 0x04 0AC4 80 DUP1 0AC5 36 CALLDATASIZE 0AC6 03 SUB 0AC7 60 PUSH1 0x20 0AC9 81 DUP2 0ACA 10 LT 0ACB 15 ISZERO 0ACC 61 PUSH2 0x0ad4 0ACF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0ABF stack[0] = 0x04e9 // @0AC2 stack[1] = 0x04 // @0AC6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0ad4, if !(msg.data.length - 0x04 < 0x20) label_0AD0: // Incoming jump from 0x0ACF, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0AD3 memory[0x00:0x00] } 0AD0 60 PUSH1 0x00 0AD2 80 DUP1 0AD3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AD3 revert(memory[0x00:0x00]); } // Block terminates label_0AD4: // Incoming jump from 0x0ACF, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0AD5 stack[-2] // @0AD6 stack[-1] // @0ADD msg.data[stack[-2]:stack[-2] + 0x20] // } 0AD4 5B JUMPDEST 0AD5 81 DUP2 0AD6 01 ADD 0AD7 90 SWAP1 0AD8 60 PUSH1 0x20 0ADA 81 DUP2 0ADB 01 ADD 0ADC 81 DUP2 0ADD 35 CALLDATALOAD 0ADE 60 PUSH1 0x01 0AE0 60 PUSH1 0x20 0AE2 1B SHL 0AE3 81 DUP2 0AE4 11 GT 0AE5 15 ISZERO 0AE6 61 PUSH2 0x0aee 0AE9 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0AD7 stack[-1] = stack[-2] // @0AD7 stack[-2] = stack[-2] + stack[-1] // @0ADB stack[0] = stack[-2] + 0x20 // @0ADD stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0aee, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0AEA: // Incoming jump from 0x0AE9, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0AED memory[0x00:0x00] } 0AEA 60 PUSH1 0x00 0AEC 80 DUP1 0AED FD *REVERT // Stack delta = +0 // Outputs[1] { @0AED revert(memory[0x00:0x00]); } // Block terminates label_0AEE: // Incoming jump from 0x0AE9, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0AEF stack[-3] // @0AF0 stack[-1] // @0AF1 stack[-4] // } 0AEE 5B JUMPDEST 0AEF 82 DUP3 0AF0 01 ADD 0AF1 83 DUP4 0AF2 60 PUSH1 0x20 0AF4 82 DUP3 0AF5 01 ADD 0AF6 11 GT 0AF7 15 ISZERO 0AF8 61 PUSH2 0x0b00 0AFB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0AF0 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0b00, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0AFC: // Incoming jump from 0x0AFB, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0AFF memory[0x00:0x00] } 0AFC 60 PUSH1 0x00 0AFE 80 DUP1 0AFF FD *REVERT // Stack delta = +0 // Outputs[1] { @0AFF revert(memory[0x00:0x00]); } // Block terminates label_0B00: // Incoming jump from 0x0AFB, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0B01 stack[-1] // @0B02 msg.data[stack[-1]:stack[-1] + 0x20] // @0B07 stack[-2] // @0B08 stack[-4] // } 0B00 5B JUMPDEST 0B01 80 DUP1 0B02 35 CALLDATALOAD 0B03 90 SWAP1 0B04 60 PUSH1 0x20 0B06 01 ADD 0B07 91 SWAP2 0B08 84 DUP5 0B09 60 PUSH1 0x01 0B0B 83 DUP4 0B0C 02 MUL 0B0D 84 DUP5 0B0E 01 ADD 0B0F 11 GT 0B10 60 PUSH1 0x01 0B12 60 PUSH1 0x20 0B14 1B SHL 0B15 83 DUP4 0B16 11 GT 0B17 17 OR 0B18 15 ISZERO 0B19 61 PUSH2 0x0b21 0B1C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0B03 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0B07 stack[0] = stack[-2] // @0B07 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0b21, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0B1D: // Incoming jump from 0x0B1C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0B20 memory[0x00:0x00] } 0B1D 60 PUSH1 0x00 0B1F 80 DUP1 0B20 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B20 revert(memory[0x00:0x00]); } // Block terminates label_0B21: // Incoming jump from 0x0B1C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0B23 stack[-3] // @0B23 stack[-2] // @0B24 stack[-5] // @0B26 stack[-4] // } 0B21 5B JUMPDEST 0B22 50 POP 0B23 90 SWAP1 0B24 92 SWAP3 0B25 50 POP 0B26 90 SWAP1 0B27 50 POP 0B28 61 PUSH2 0x2b3e 0B2B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0B24 stack[-5] = stack[-3] // @0B26 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x2b3e label_0B2C: // Incoming jump from 0x01FA, if 0x8bf64cba == stack[-1] // Inputs[1] { @0B33 msg.data.length } 0B2C 5B JUMPDEST 0B2D 61 PUSH2 0x04e9 0B30 60 PUSH1 0x04 0B32 80 DUP1 0B33 36 CALLDATASIZE 0B34 03 SUB 0B35 60 PUSH1 0x40 0B37 81 DUP2 0B38 10 LT 0B39 15 ISZERO 0B3A 61 PUSH2 0x0b42 0B3D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0B2D stack[0] = 0x04e9 // @0B30 stack[1] = 0x04 // @0B34 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0b42, if !(msg.data.length - 0x04 < 0x40) label_0B3E: // Incoming jump from 0x0B3D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0B41 memory[0x00:0x00] } 0B3E 60 PUSH1 0x00 0B40 80 DUP1 0B41 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B41 revert(memory[0x00:0x00]); } // Block terminates label_0B42: // Incoming jump from 0x0B3D, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0B43 stack[-2] // @0B44 stack[-1] // @0B4B msg.data[stack[-2]:stack[-2] + 0x20] // } 0B42 5B JUMPDEST 0B43 81 DUP2 0B44 01 ADD 0B45 90 SWAP1 0B46 60 PUSH1 0x20 0B48 81 DUP2 0B49 01 ADD 0B4A 81 DUP2 0B4B 35 CALLDATALOAD 0B4C 60 PUSH1 0x01 0B4E 60 PUSH1 0x20 0B50 1B SHL 0B51 81 DUP2 0B52 11 GT 0B53 15 ISZERO 0B54 61 PUSH2 0x0b5c 0B57 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0B45 stack[-1] = stack[-2] // @0B45 stack[-2] = stack[-2] + stack[-1] // @0B49 stack[0] = stack[-2] + 0x20 // @0B4B stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0b5c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0B58: // Incoming jump from 0x0B57, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0B5B memory[0x00:0x00] } 0B58 60 PUSH1 0x00 0B5A 80 DUP1 0B5B FD *REVERT // Stack delta = +0 // Outputs[1] { @0B5B revert(memory[0x00:0x00]); } // Block terminates label_0B5C: // Incoming jump from 0x0B57, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0B5D stack[-3] // @0B5E stack[-1] // @0B5F stack[-4] // } 0B5C 5B JUMPDEST 0B5D 82 DUP3 0B5E 01 ADD 0B5F 83 DUP4 0B60 60 PUSH1 0x20 0B62 82 DUP3 0B63 01 ADD 0B64 11 GT 0B65 15 ISZERO 0B66 61 PUSH2 0x0b6e 0B69 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0B5E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0b6e, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0B6A: // Incoming jump from 0x0B69, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0B6D memory[0x00:0x00] } 0B6A 60 PUSH1 0x00 0B6C 80 DUP1 0B6D FD *REVERT // Stack delta = +0 // Outputs[1] { @0B6D revert(memory[0x00:0x00]); } // Block terminates label_0B6E: // Incoming jump from 0x0B69, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0B6F stack[-1] // @0B70 msg.data[stack[-1]:stack[-1] + 0x20] // @0B75 stack[-2] // @0B76 stack[-4] // } 0B6E 5B JUMPDEST 0B6F 80 DUP1 0B70 35 CALLDATALOAD 0B71 90 SWAP1 0B72 60 PUSH1 0x20 0B74 01 ADD 0B75 91 SWAP2 0B76 84 DUP5 0B77 60 PUSH1 0x20 0B79 83 DUP4 0B7A 02 MUL 0B7B 84 DUP5 0B7C 01 ADD 0B7D 11 GT 0B7E 60 PUSH1 0x01 0B80 60 PUSH1 0x20 0B82 1B SHL 0B83 83 DUP4 0B84 11 GT 0B85 17 OR 0B86 15 ISZERO 0B87 61 PUSH2 0x0b8f 0B8A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0B71 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0B75 stack[0] = stack[-2] // @0B75 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0b8f, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0B8B: // Incoming jump from 0x0B8A, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0B8E memory[0x00:0x00] } 0B8B 60 PUSH1 0x00 0B8D 80 DUP1 0B8E FD *REVERT // Stack delta = +0 // Outputs[1] { @0B8E revert(memory[0x00:0x00]); } // Block terminates label_0B8F: // Incoming jump from 0x0B8A, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[6] // { // @0B90 stack[-1] // @0B90 stack[-3] // @0B91 stack[-5] // @0B92 stack[-2] // @0B93 stack[-4] // @0B9B msg.data[stack[-1]:stack[-1] + 0x20] // } 0B8F 5B JUMPDEST 0B90 91 SWAP2 0B91 93 SWAP4 0B92 90 SWAP1 0B93 92 SWAP3 0B94 90 SWAP1 0B95 91 SWAP2 0B96 60 PUSH1 0x20 0B98 81 DUP2 0B99 01 ADD 0B9A 90 SWAP1 0B9B 35 CALLDATALOAD 0B9C 60 PUSH1 0x01 0B9E 60 PUSH1 0x20 0BA0 1B SHL 0BA1 81 DUP2 0BA2 11 GT 0BA3 15 ISZERO 0BA4 61 PUSH2 0x0bac 0BA7 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0B91 stack[-5] = stack[-3] // @0B93 stack[-4] = stack[-2] // @0B94 stack[-2] = stack[-4] // @0B95 stack[-3] = stack[-5] // @0B9A stack[-1] = stack[-1] + 0x20 // @0B9B stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0bac, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0BA8: // Incoming jump from 0x0BA7, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0BAB memory[0x00:0x00] } 0BA8 60 PUSH1 0x00 0BAA 80 DUP1 0BAB FD *REVERT // Stack delta = +0 // Outputs[1] { @0BAB revert(memory[0x00:0x00]); } // Block terminates label_0BAC: // Incoming jump from 0x0BA7, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0BAD stack[-3] // @0BAE stack[-1] // @0BAF stack[-4] // } 0BAC 5B JUMPDEST 0BAD 82 DUP3 0BAE 01 ADD 0BAF 83 DUP4 0BB0 60 PUSH1 0x20 0BB2 82 DUP3 0BB3 01 ADD 0BB4 11 GT 0BB5 15 ISZERO 0BB6 61 PUSH2 0x0bbe 0BB9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0BAE stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0bbe, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0BBA: // Incoming jump from 0x0BB9, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0BBD memory[0x00:0x00] } 0BBA 60 PUSH1 0x00 0BBC 80 DUP1 0BBD FD *REVERT // Stack delta = +0 // Outputs[1] { @0BBD revert(memory[0x00:0x00]); } // Block terminates label_0BBE: // Incoming jump from 0x0BB9, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0BBF stack[-1] // @0BC0 msg.data[stack[-1]:stack[-1] + 0x20] // @0BC5 stack[-2] // @0BC6 stack[-4] // } 0BBE 5B JUMPDEST 0BBF 80 DUP1 0BC0 35 CALLDATALOAD 0BC1 90 SWAP1 0BC2 60 PUSH1 0x20 0BC4 01 ADD 0BC5 91 SWAP2 0BC6 84 DUP5 0BC7 60 PUSH1 0x20 0BC9 83 DUP4 0BCA 02 MUL 0BCB 84 DUP5 0BCC 01 ADD 0BCD 11 GT 0BCE 60 PUSH1 0x01 0BD0 60 PUSH1 0x20 0BD2 1B SHL 0BD3 83 DUP4 0BD4 11 GT 0BD5 17 OR 0BD6 15 ISZERO 0BD7 61 PUSH2 0x0bdf 0BDA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0BC1 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0BC5 stack[0] = stack[-2] // @0BC5 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0bdf, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0BDB: // Incoming jump from 0x0BDA, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0BDE memory[0x00:0x00] } 0BDB 60 PUSH1 0x00 0BDD 80 DUP1 0BDE FD *REVERT // Stack delta = +0 // Outputs[1] { @0BDE revert(memory[0x00:0x00]); } // Block terminates label_0BDF: // Incoming jump from 0x0BDA, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[4] // { // @0BE1 stack[-3] // @0BE1 stack[-2] // @0BE2 stack[-5] // @0BE4 stack[-4] // } 0BDF 5B JUMPDEST 0BE0 50 POP 0BE1 90 SWAP1 0BE2 92 SWAP3 0BE3 50 POP 0BE4 90 SWAP1 0BE5 50 POP 0BE6 61 PUSH2 0x2c1e 0BE9 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0BE2 stack[-5] = stack[-3] // @0BE4 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x2c1e label_0BEA: // Incoming jump from 0x0205, if 0x8da5cb5b == stack[-1] 0BEA 5B JUMPDEST 0BEB 61 PUSH2 0x0704 0BEE 61 PUSH2 0x2daa 0BF1 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BEB stack[0] = 0x0704 } // Block ends with call to 0x2daa, returns to 0x0704 label_0BF2: // Incoming jump from 0x01B3, if 0x95d89b41 == stack[-1] 0BF2 5B JUMPDEST 0BF3 61 PUSH2 0x03e8 0BF6 61 PUSH2 0x2db9 0BF9 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BF3 stack[0] = 0x03e8 } // Block ends with call to 0x2db9, returns to 0x03E8 label_0BFA: // Incoming jump from 0x01BE, if 0x97ecb37f == stack[-1] 0BFA 5B JUMPDEST 0BFB 61 PUSH2 0x0543 0BFE 61 PUSH2 0x2e50 0C01 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BFB stack[0] = 0x0543 } // Block ends with call to 0x2e50, returns to 0x0543 label_0C02: // Incoming jump from 0x01C9, if 0x9af38fbe == stack[-1] // Inputs[1] { @0C09 msg.data.length } 0C02 5B JUMPDEST 0C03 61 PUSH2 0x04e9 0C06 60 PUSH1 0x04 0C08 80 DUP1 0C09 36 CALLDATASIZE 0C0A 03 SUB 0C0B 60 PUSH1 0x20 0C0D 81 DUP2 0C0E 10 LT 0C0F 15 ISZERO 0C10 61 PUSH2 0x0c18 0C13 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C03 stack[0] = 0x04e9 // @0C06 stack[1] = 0x04 // @0C0A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0c18, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0C14: // Incoming jump from 0x0C13, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0C17 memory[0x00:0x00] } 0C14 60 PUSH1 0x00 0C16 80 DUP1 0C17 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C17 revert(memory[0x00:0x00]); } // Block terminates label_0C18: // Incoming call from 0x0C13, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0C1A msg.data[stack[-2]:stack[-2] + 0x20] // @0C1A stack[-2] // } 0C18 5B JUMPDEST 0C19 50 POP 0C1A 35 CALLDATALOAD 0C1B 60 PUSH1 0x01 0C1D 60 PUSH1 0x01 0C1F 60 PUSH1 0xa0 0C21 1B SHL 0C22 03 SUB 0C23 16 AND 0C24 61 PUSH2 0x2e74 0C27 56 *JUMP // Stack delta = -1 // Outputs[1] { @0C23 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2e74 label_0C28: // Incoming jump from 0x01D4, if 0x9dc29fac == stack[-1] // Inputs[1] { @0C2F msg.data.length } 0C28 5B JUMPDEST 0C29 61 PUSH2 0x04e9 0C2C 60 PUSH1 0x04 0C2E 80 DUP1 0C2F 36 CALLDATASIZE 0C30 03 SUB 0C31 60 PUSH1 0x40 0C33 81 DUP2 0C34 10 LT 0C35 15 ISZERO 0C36 61 PUSH2 0x0c3e 0C39 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C29 stack[0] = 0x04e9 // @0C2C stack[1] = 0x04 // @0C30 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0c3e, if !(msg.data.length - 0x04 < 0x40) label_0C3A: // Incoming jump from 0x0C39, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0C3D memory[0x00:0x00] } 0C3A 60 PUSH1 0x00 0C3C 80 DUP1 0C3D FD *REVERT // Stack delta = +0 // Outputs[1] { @0C3D revert(memory[0x00:0x00]); } // Block terminates label_0C3E: // Incoming jump from 0x0C39, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0C48 stack[-2] // @0C49 msg.data[stack[-2]:stack[-2] + 0x20] // @0C4F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0C3E 5B JUMPDEST 0C3F 50 POP 0C40 60 PUSH1 0x01 0C42 60 PUSH1 0x01 0C44 60 PUSH1 0xa0 0C46 1B SHL 0C47 03 SUB 0C48 81 DUP2 0C49 35 CALLDATALOAD 0C4A 16 AND 0C4B 90 SWAP1 0C4C 60 PUSH1 0x20 0C4E 01 ADD 0C4F 35 CALLDATALOAD 0C50 61 PUSH2 0x2f2a 0C53 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C4B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0C4F stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2f2a label_0C54: // Incoming jump from 0x0177, if 0x9ddc1184 == stack[-1] // Inputs[1] { @0C5B msg.data.length } 0C54 5B JUMPDEST 0C55 61 PUSH2 0x04e9 0C58 60 PUSH1 0x04 0C5A 80 DUP1 0C5B 36 CALLDATASIZE 0C5C 03 SUB 0C5D 61 PUSH2 0x0120 0C60 81 DUP2 0C61 10 LT 0C62 15 ISZERO 0C63 61 PUSH2 0x0c6b 0C66 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C55 stack[0] = 0x04e9 // @0C58 stack[1] = 0x04 // @0C5C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0c6b, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) label_0C67: // Incoming jump from 0x0C66, if not !(msg.data.length - 0x04 < 0x0120) // Inputs[1] { @0C6A memory[0x00:0x00] } 0C67 60 PUSH1 0x00 0C69 80 DUP1 0C6A FD *REVERT // Stack delta = +0 // Outputs[1] { @0C6A revert(memory[0x00:0x00]); } // Block terminates label_0C6B: // Incoming call from 0x0C66, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) // Inputs[10] // { // @0C75 stack[-2] // @0C76 msg.data[stack[-2]:stack[-2] + 0x20] // @0C7E msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0C87 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0C8D msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0C93 msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0C99 msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @0CA1 msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] // @0CA8 msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @0CAE msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } 0C6B 5B JUMPDEST 0C6C 50 POP 0C6D 60 PUSH1 0x01 0C6F 60 PUSH1 0x01 0C71 60 PUSH1 0xa0 0C73 1B SHL 0C74 03 SUB 0C75 81 DUP2 0C76 35 CALLDATALOAD 0C77 81 DUP2 0C78 16 AND 0C79 91 SWAP2 0C7A 60 PUSH1 0x20 0C7C 81 DUP2 0C7D 01 ADD 0C7E 35 CALLDATALOAD 0C7F 90 SWAP1 0C80 91 SWAP2 0C81 16 AND 0C82 90 SWAP1 0C83 60 PUSH1 0x40 0C85 81 DUP2 0C86 01 ADD 0C87 35 CALLDATALOAD 0C88 90 SWAP1 0C89 60 PUSH1 0x60 0C8B 81 DUP2 0C8C 01 ADD 0C8D 35 CALLDATALOAD 0C8E 90 SWAP1 0C8F 60 PUSH1 0x80 0C91 81 DUP2 0C92 01 ADD 0C93 35 CALLDATALOAD 0C94 90 SWAP1 0C95 60 PUSH1 0xa0 0C97 81 DUP2 0C98 01 ADD 0C99 35 CALLDATALOAD 0C9A 90 SWAP1 0C9B 60 PUSH1 0xff 0C9D 60 PUSH1 0xc0 0C9F 82 DUP3 0CA0 01 ADD 0CA1 35 CALLDATALOAD 0CA2 16 AND 0CA3 90 SWAP1 0CA4 60 PUSH1 0xe0 0CA6 81 DUP2 0CA7 01 ADD 0CA8 35 CALLDATALOAD 0CA9 90 SWAP1 0CAA 61 PUSH2 0x0100 0CAD 01 ADD 0CAE 35 CALLDATALOAD 0CAF 61 PUSH2 0x30ad 0CB2 56 *JUMP // Stack delta = +7 // Outputs[9] // { // @0C79 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0C82 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0C88 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0C8E stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0C94 stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0C9A stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @0CA3 stack[4] = msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] & 0xff // @0CA9 stack[5] = msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @0CAE stack[6] = msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x30ad label_0CB3: // Incoming jump from 0x0182, if 0xa0cc6a68 == stack[-1] 0CB3 5B JUMPDEST 0CB4 61 PUSH2 0x0543 0CB7 61 PUSH2 0x31df 0CBA 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CB4 stack[0] = 0x0543 } // Block ends with call to 0x31df, returns to 0x0543 label_0CBB: // Incoming jump from 0x018D, if 0xa9059cbb == stack[-1] // Inputs[1] { @0CC2 msg.data.length } 0CBB 5B JUMPDEST 0CBC 61 PUSH2 0x0489 0CBF 60 PUSH1 0x04 0CC1 80 DUP1 0CC2 36 CALLDATASIZE 0CC3 03 SUB 0CC4 60 PUSH1 0x40 0CC6 81 DUP2 0CC7 10 LT 0CC8 15 ISZERO 0CC9 61 PUSH2 0x0cd1 0CCC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0CBC stack[0] = 0x0489 // @0CBF stack[1] = 0x04 // @0CC3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0cd1, returns to 0x0489, if !(msg.data.length - 0x04 < 0x40) label_0CCD: // Incoming jump from 0x0CCC, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0CD0 memory[0x00:0x00] } 0CCD 60 PUSH1 0x00 0CCF 80 DUP1 0CD0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CD0 revert(memory[0x00:0x00]); } // Block terminates label_0CD1: // Incoming call from 0x0CCC, returns to 0x0489, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0CDB stack[-2] // @0CDC msg.data[stack[-2]:stack[-2] + 0x20] // @0CE2 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0CD1 5B JUMPDEST 0CD2 50 POP 0CD3 60 PUSH1 0x01 0CD5 60 PUSH1 0x01 0CD7 60 PUSH1 0xa0 0CD9 1B SHL 0CDA 03 SUB 0CDB 81 DUP2 0CDC 35 CALLDATALOAD 0CDD 16 AND 0CDE 90 SWAP1 0CDF 60 PUSH1 0x20 0CE1 01 ADD 0CE2 35 CALLDATALOAD 0CE3 61 PUSH2 0x3203 0CE6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0CDE stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0CE2 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x3203 label_0CE7: // Incoming jump from 0x0198, if 0xac3e6742 == stack[-1] 0CE7 5B JUMPDEST 0CE8 61 PUSH2 0x0704 0CEB 61 PUSH2 0x3272 0CEE 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CE8 stack[0] = 0x0704 } // Block ends with call to 0x3272, returns to 0x0704 label_0CEF: // Incoming jump from 0x0146, if 0xb500329b == stack[-1] // Inputs[1] { @0CF6 msg.data.length } 0CEF 5B JUMPDEST 0CF0 61 PUSH2 0x04e9 0CF3 60 PUSH1 0x04 0CF5 80 DUP1 0CF6 36 CALLDATASIZE 0CF7 03 SUB 0CF8 60 PUSH1 0x20 0CFA 81 DUP2 0CFB 10 LT 0CFC 15 ISZERO 0CFD 61 PUSH2 0x0d05 0D00 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0CF0 stack[0] = 0x04e9 // @0CF3 stack[1] = 0x04 // @0CF7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0d05, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0D01: // Incoming jump from 0x0D00, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0D04 memory[0x00:0x00] } 0D01 60 PUSH1 0x00 0D03 80 DUP1 0D04 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D04 revert(memory[0x00:0x00]); } // Block terminates label_0D05: // Incoming call from 0x0D00, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0D07 msg.data[stack[-2]:stack[-2] + 0x20] // @0D07 stack[-2] // } 0D05 5B JUMPDEST 0D06 50 POP 0D07 35 CALLDATALOAD 0D08 60 PUSH1 0x01 0D0A 60 PUSH1 0x01 0D0C 60 PUSH1 0xa0 0D0E 1B SHL 0D0F 03 SUB 0D10 16 AND 0D11 61 PUSH2 0x3281 0D14 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D10 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x3281 label_0D15: // Incoming jump from 0x0151, if 0xb9be0ed3 == stack[-1] 0D15 5B JUMPDEST 0D16 61 PUSH2 0x0d1d 0D19 61 PUSH2 0x348f 0D1C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D16 stack[0] = 0x0d1d } // Block ends with call to 0x348f, returns to 0x0D1D label_0D1D: // Incoming return from call to 0x348F at 0x0D1C // Inputs[4] // { // @0D21 memory[0x40:0x60] // @0D27 stack[-1] // @0D28 memory[stack[-1]:stack[-1] + 0x20] // @0D2E memory[stack[-1]:stack[-1] + 0x20] // } 0D1D 5B JUMPDEST 0D1E 60 PUSH1 0x40 0D20 80 DUP1 0D21 51 MLOAD 0D22 60 PUSH1 0x20 0D24 80 DUP1 0D25 82 DUP3 0D26 52 MSTORE 0D27 83 DUP4 0D28 51 MLOAD 0D29 81 DUP2 0D2A 83 DUP4 0D2B 01 ADD 0D2C 52 MSTORE 0D2D 83 DUP4 0D2E 51 MLOAD 0D2F 91 SWAP2 0D30 92 SWAP3 0D31 83 DUP4 0D32 92 SWAP3 0D33 90 SWAP1 0D34 83 DUP4 0D35 01 ADD 0D36 91 SWAP2 0D37 85 DUP6 0D38 81 DUP2 0D39 01 ADD 0D3A 91 SWAP2 0D3B 02 MUL 0D3C 80 DUP1 0D3D 83 DUP4 0D3E 83 DUP4 0D3F 60 PUSH1 0x00 0D41 5B JUMPDEST 0D42 83 DUP4 0D43 81 DUP2 0D44 10 LT 0D45 15 ISZERO 0D46 61 PUSH2 0x0d59 0D49 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0D26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @0D2C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0D30 stack[0] = memory[0x40:0x60] // @0D32 stack[1] = memory[0x40:0x60] // @0D36 stack[2] = memory[0x40:0x60] + 0x40 // @0D3A stack[3] = 0x20 + stack[-1] // @0D3B stack[4] = memory[stack[-1]:stack[-1] + 0x20] * 0x20 // @0D3C stack[5] = memory[stack[-1]:stack[-1] + 0x20] * 0x20 // @0D3D stack[6] = memory[0x40:0x60] + 0x40 // @0D3E stack[7] = 0x20 + stack[-1] // @0D3F stack[8] = 0x00 // } // Block ends with conditional jump to 0x0d59, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) label_0D4A: // Incoming jump from 0x0D49, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0D49, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) // Inputs[4] // { // @0D4A stack[-2] // @0D4B stack[-1] // @0D4D memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0D4E stack[-3] // } 0D4A 81 DUP2 0D4B 81 DUP2 0D4C 01 ADD 0D4D 51 MLOAD 0D4E 83 DUP4 0D4F 82 DUP3 0D50 01 ADD 0D51 52 MSTORE 0D52 60 PUSH1 0x20 0D54 01 ADD 0D55 61 PUSH2 0x0d41 0D58 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0D51 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0D54 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0d41 label_0D59: // Incoming jump from 0x0D49, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0D49, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) // Inputs[6] // { // @0D5E stack[-6] // @0D5E stack[-5] // @0D60 stack[-7] // @0D61 stack[-10] // @0D67 memory[0x40:0x60] // @0D6C memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 0D59 5B JUMPDEST 0D5A 50 POP 0D5B 50 POP 0D5C 50 POP 0D5D 50 POP 0D5E 90 SWAP1 0D5F 50 POP 0D60 01 ADD 0D61 92 SWAP3 0D62 50 POP 0D63 50 POP 0D64 50 POP 0D65 60 PUSH1 0x40 0D67 51 MLOAD 0D68 80 DUP1 0D69 91 SWAP2 0D6A 03 SUB 0D6B 90 SWAP1 0D6C F3 *RETURN // Stack delta = -10 // Outputs[1] { @0D6C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_0D6D: // Incoming jump from 0x015C, if 0xba7b52e0 == stack[-1] // Inputs[1] { @0D74 msg.data.length } 0D6D 5B JUMPDEST 0D6E 61 PUSH2 0x04e9 0D71 60 PUSH1 0x04 0D73 80 DUP1 0D74 36 CALLDATASIZE 0D75 03 SUB 0D76 60 PUSH1 0x60 0D78 81 DUP2 0D79 10 LT 0D7A 15 ISZERO 0D7B 61 PUSH2 0x0d83 0D7E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0D6E stack[0] = 0x04e9 // @0D71 stack[1] = 0x04 // @0D75 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0d83, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x60) label_0D7F: // Incoming jump from 0x0D7E, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0D82 memory[0x00:0x00] } 0D7F 60 PUSH1 0x00 0D81 80 DUP1 0D82 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D82 revert(memory[0x00:0x00]); } // Block terminates label_0D83: // Incoming call from 0x0D7E, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0D8C stack[-2] // @0D8D msg.data[stack[-2]:stack[-2] + 0x20] // @0D90 stack[-1] // @0D9C msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 0D83 5B JUMPDEST 0D84 60 PUSH1 0x01 0D86 60 PUSH1 0x01 0D88 60 PUSH1 0xa0 0D8A 1B SHL 0D8B 03 SUB 0D8C 82 DUP3 0D8D 35 CALLDATALOAD 0D8E 16 AND 0D8F 91 SWAP2 0D90 90 SWAP1 0D91 81 DUP2 0D92 01 ADD 0D93 90 SWAP1 0D94 60 PUSH1 0x40 0D96 81 DUP2 0D97 01 ADD 0D98 60 PUSH1 0x20 0D9A 82 DUP3 0D9B 01 ADD 0D9C 35 CALLDATALOAD 0D9D 60 PUSH1 0x01 0D9F 60 PUSH1 0x20 0DA1 1B SHL 0DA2 81 DUP2 0DA3 11 GT 0DA4 15 ISZERO 0DA5 61 PUSH2 0x0dad 0DA8 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0D8F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0D93 stack[0] = stack[-2] // @0D93 stack[-1] = stack[-2] + stack[-1] // @0D97 stack[1] = stack[-2] + 0x40 // @0D9C stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x0dad, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_0DA9: // Incoming jump from 0x0DA8, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0DAC memory[0x00:0x00] } 0DA9 60 PUSH1 0x00 0DAB 80 DUP1 0DAC FD *REVERT // Stack delta = +0 // Outputs[1] { @0DAC revert(memory[0x00:0x00]); } // Block terminates label_0DAD: // Incoming jump from 0x0DA8, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0DAE stack[-3] // @0DAF stack[-1] // @0DB0 stack[-4] // } 0DAD 5B JUMPDEST 0DAE 82 DUP3 0DAF 01 ADD 0DB0 83 DUP4 0DB1 60 PUSH1 0x20 0DB3 82 DUP3 0DB4 01 ADD 0DB5 11 GT 0DB6 15 ISZERO 0DB7 61 PUSH2 0x0dbf 0DBA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0DAF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0dbf, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0DBB: // Incoming jump from 0x0DBA, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0DBE memory[0x00:0x00] } 0DBB 60 PUSH1 0x00 0DBD 80 DUP1 0DBE FD *REVERT // Stack delta = +0 // Outputs[1] { @0DBE revert(memory[0x00:0x00]); } // Block terminates label_0DBF: // Incoming jump from 0x0DBA, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0DC0 stack[-1] // @0DC1 msg.data[stack[-1]:stack[-1] + 0x20] // @0DC6 stack[-2] // @0DC7 stack[-4] // } 0DBF 5B JUMPDEST 0DC0 80 DUP1 0DC1 35 CALLDATALOAD 0DC2 90 SWAP1 0DC3 60 PUSH1 0x20 0DC5 01 ADD 0DC6 91 SWAP2 0DC7 84 DUP5 0DC8 60 PUSH1 0x20 0DCA 83 DUP4 0DCB 02 MUL 0DCC 84 DUP5 0DCD 01 ADD 0DCE 11 GT 0DCF 60 PUSH1 0x01 0DD1 60 PUSH1 0x20 0DD3 1B SHL 0DD4 83 DUP4 0DD5 11 GT 0DD6 17 OR 0DD7 15 ISZERO 0DD8 61 PUSH2 0x0de0 0DDB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0DC2 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0DC6 stack[0] = stack[-2] // @0DC6 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0de0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0DDC: // Incoming jump from 0x0DDB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0DDF memory[0x00:0x00] } 0DDC 60 PUSH1 0x00 0DDE 80 DUP1 0DDF FD *REVERT // Stack delta = +0 // Outputs[1] { @0DDF revert(memory[0x00:0x00]); } // Block terminates label_0DE0: // Incoming jump from 0x0DDB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[6] // { // @0DE1 stack[-1] // @0DE1 stack[-3] // @0DE2 stack[-5] // @0DE3 stack[-2] // @0DE4 stack[-4] // @0DEC msg.data[stack[-1]:stack[-1] + 0x20] // } 0DE0 5B JUMPDEST 0DE1 91 SWAP2 0DE2 93 SWAP4 0DE3 90 SWAP1 0DE4 92 SWAP3 0DE5 90 SWAP1 0DE6 91 SWAP2 0DE7 60 PUSH1 0x20 0DE9 81 DUP2 0DEA 01 ADD 0DEB 90 SWAP1 0DEC 35 CALLDATALOAD 0DED 60 PUSH1 0x01 0DEF 60 PUSH1 0x20 0DF1 1B SHL 0DF2 81 DUP2 0DF3 11 GT 0DF4 15 ISZERO 0DF5 61 PUSH2 0x0dfd 0DF8 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0DE2 stack[-5] = stack[-3] // @0DE4 stack[-4] = stack[-2] // @0DE5 stack[-2] = stack[-4] // @0DE6 stack[-3] = stack[-5] // @0DEB stack[-1] = stack[-1] + 0x20 // @0DEC stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0dfd, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0DF9: // Incoming jump from 0x0DF8, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0DFC memory[0x00:0x00] } 0DF9 60 PUSH1 0x00 0DFB 80 DUP1 0DFC FD *REVERT // Stack delta = +0 // Outputs[1] { @0DFC revert(memory[0x00:0x00]); } // Block terminates label_0DFD: // Incoming jump from 0x0DF8, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0DFE stack[-3] // @0DFF stack[-1] // @0E00 stack[-4] // } 0DFD 5B JUMPDEST 0DFE 82 DUP3 0DFF 01 ADD 0E00 83 DUP4 0E01 60 PUSH1 0x20 0E03 82 DUP3 0E04 01 ADD 0E05 11 GT 0E06 15 ISZERO 0E07 61 PUSH2 0x0e0f 0E0A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0DFF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0e0f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0E0B: // Incoming jump from 0x0E0A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0E0E memory[0x00:0x00] } 0E0B 60 PUSH1 0x00 0E0D 80 DUP1 0E0E FD *REVERT // Stack delta = +0 // Outputs[1] { @0E0E revert(memory[0x00:0x00]); } // Block terminates label_0E0F: // Incoming jump from 0x0E0A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0E10 stack[-1] // @0E11 msg.data[stack[-1]:stack[-1] + 0x20] // @0E16 stack[-2] // @0E17 stack[-4] // } 0E0F 5B JUMPDEST 0E10 80 DUP1 0E11 35 CALLDATALOAD 0E12 90 SWAP1 0E13 60 PUSH1 0x20 0E15 01 ADD 0E16 91 SWAP2 0E17 84 DUP5 0E18 60 PUSH1 0x20 0E1A 83 DUP4 0E1B 02 MUL 0E1C 84 DUP5 0E1D 01 ADD 0E1E 11 GT 0E1F 60 PUSH1 0x01 0E21 60 PUSH1 0x20 0E23 1B SHL 0E24 83 DUP4 0E25 11 GT 0E26 17 OR 0E27 15 ISZERO 0E28 61 PUSH2 0x0e30 0E2B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E12 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0E16 stack[0] = stack[-2] // @0E16 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0e30, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0E2C: // Incoming jump from 0x0E2B, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0E2F memory[0x00:0x00] } 0E2C 60 PUSH1 0x00 0E2E 80 DUP1 0E2F FD *REVERT // Stack delta = +0 // Outputs[1] { @0E2F revert(memory[0x00:0x00]); } // Block terminates label_0E30: // Incoming jump from 0x0E2B, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[4] // { // @0E32 stack[-3] // @0E32 stack[-2] // @0E33 stack[-5] // @0E35 stack[-4] // } 0E30 5B JUMPDEST 0E31 50 POP 0E32 90 SWAP1 0E33 92 SWAP3 0E34 50 POP 0E35 90 SWAP1 0E36 50 POP 0E37 61 PUSH2 0x34f0 0E3A 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0E33 stack[-5] = stack[-3] // @0E35 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x34f0 label_0E3B: // Incoming jump from 0x0167, if 0xc9991176 == stack[-1] // Inputs[1] { @0E42 msg.data.length } 0E3B 5B JUMPDEST 0E3C 61 PUSH2 0x04e9 0E3F 60 PUSH1 0x04 0E41 80 DUP1 0E42 36 CALLDATASIZE 0E43 03 SUB 0E44 60 PUSH1 0x20 0E46 81 DUP2 0E47 10 LT 0E48 15 ISZERO 0E49 61 PUSH2 0x0e51 0E4C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E3C stack[0] = 0x04e9 // @0E3F stack[1] = 0x04 // @0E43 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0e51, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0E4D: // Incoming jump from 0x0E4C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0E50 memory[0x00:0x00] } 0E4D 60 PUSH1 0x00 0E4F 80 DUP1 0E50 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E50 revert(memory[0x00:0x00]); } // Block terminates label_0E51: // Incoming call from 0x0E4C, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0E53 stack[-2] // @0E53 msg.data[stack[-2]:stack[-2] + 0x20] // } 0E51 5B JUMPDEST 0E52 50 POP 0E53 35 CALLDATALOAD 0E54 60 PUSH1 0x01 0E56 60 PUSH1 0x01 0E58 60 PUSH1 0xa0 0E5A 1B SHL 0E5B 03 SUB 0E5C 16 AND 0E5D 61 PUSH2 0x379b 0E60 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E5C stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x379b label_0E61: // Incoming jump from 0x00FF, if 0xcc01053e == stack[-1] 0E61 5B JUMPDEST 0E62 61 PUSH2 0x04e9 0E65 61 PUSH2 0x383b 0E68 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E62 stack[0] = 0x04e9 } // Block ends with call to 0x383b, returns to 0x04E9 label_0E69: // Incoming jump from 0x010A, if 0xce1b1d43 == stack[-1] 0E69 5B JUMPDEST 0E6A 61 PUSH2 0x0704 0E6D 61 PUSH2 0x389d 0E70 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E6A stack[0] = 0x0704 } // Block ends with call to 0x389d, returns to 0x0704 label_0E71: // Incoming jump from 0x0115, if 0xd505accf == stack[-1] // Inputs[1] { @0E78 msg.data.length } 0E71 5B JUMPDEST 0E72 61 PUSH2 0x04e9 0E75 60 PUSH1 0x04 0E77 80 DUP1 0E78 36 CALLDATASIZE 0E79 03 SUB 0E7A 60 PUSH1 0xe0 0E7C 81 DUP2 0E7D 10 LT 0E7E 15 ISZERO 0E7F 61 PUSH2 0x0e87 0E82 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E72 stack[0] = 0x04e9 // @0E75 stack[1] = 0x04 // @0E79 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0e87, returns to 0x04E9, if !(msg.data.length - 0x04 < 0xe0) label_0E83: // Incoming jump from 0x0E82, if not !(msg.data.length - 0x04 < 0xe0) // Inputs[1] { @0E86 memory[0x00:0x00] } 0E83 60 PUSH1 0x00 0E85 80 DUP1 0E86 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E86 revert(memory[0x00:0x00]); } // Block terminates label_0E87: // Incoming call from 0x0E82, returns to 0x04E9, if !(msg.data.length - 0x04 < 0xe0) // Inputs[8] // { // @0E91 stack[-2] // @0E92 msg.data[stack[-2]:stack[-2] + 0x20] // @0E9A msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0EA3 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0EA9 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0EB1 msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0EB8 msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @0EBD msg.data[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } 0E87 5B JUMPDEST 0E88 50 POP 0E89 60 PUSH1 0x01 0E8B 60 PUSH1 0x01 0E8D 60 PUSH1 0xa0 0E8F 1B SHL 0E90 03 SUB 0E91 81 DUP2 0E92 35 CALLDATALOAD 0E93 81 DUP2 0E94 16 AND 0E95 91 SWAP2 0E96 60 PUSH1 0x20 0E98 81 DUP2 0E99 01 ADD 0E9A 35 CALLDATALOAD 0E9B 90 SWAP1 0E9C 91 SWAP2 0E9D 16 AND 0E9E 90 SWAP1 0E9F 60 PUSH1 0x40 0EA1 81 DUP2 0EA2 01 ADD 0EA3 35 CALLDATALOAD 0EA4 90 SWAP1 0EA5 60 PUSH1 0x60 0EA7 81 DUP2 0EA8 01 ADD 0EA9 35 CALLDATALOAD 0EAA 90 SWAP1 0EAB 60 PUSH1 0xff 0EAD 60 PUSH1 0x80 0EAF 82 DUP3 0EB0 01 ADD 0EB1 35 CALLDATALOAD 0EB2 16 AND 0EB3 90 SWAP1 0EB4 60 PUSH1 0xa0 0EB6 81 DUP2 0EB7 01 ADD 0EB8 35 CALLDATALOAD 0EB9 90 SWAP1 0EBA 60 PUSH1 0xc0 0EBC 01 ADD 0EBD 35 CALLDATALOAD 0EBE 61 PUSH2 0x38ac 0EC1 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0E95 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0E9E stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0EA4 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0EAA stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0EB3 stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] & 0xff // @0EB9 stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @0EBD stack[4] = msg.data[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x38ac label_0EC2: // Incoming jump from 0x0120, if 0xd73dd623 == stack[-1] // Inputs[1] { @0EC9 msg.data.length } 0EC2 5B JUMPDEST 0EC3 61 PUSH2 0x04e9 0EC6 60 PUSH1 0x04 0EC8 80 DUP1 0EC9 36 CALLDATASIZE 0ECA 03 SUB 0ECB 60 PUSH1 0x40 0ECD 81 DUP2 0ECE 10 LT 0ECF 15 ISZERO 0ED0 61 PUSH2 0x0ed8 0ED3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0EC3 stack[0] = 0x04e9 // @0EC6 stack[1] = 0x04 // @0ECA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0ed8, if !(msg.data.length - 0x04 < 0x40) label_0ED4: // Incoming jump from 0x0ED3, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0ED7 memory[0x00:0x00] } 0ED4 60 PUSH1 0x00 0ED6 80 DUP1 0ED7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0ED7 revert(memory[0x00:0x00]); } // Block terminates label_0ED8: // Incoming jump from 0x0ED3, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0EE2 stack[-2] // @0EE3 msg.data[stack[-2]:stack[-2] + 0x20] // @0EE9 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0ED8 5B JUMPDEST 0ED9 50 POP 0EDA 60 PUSH1 0x01 0EDC 60 PUSH1 0x01 0EDE 60 PUSH1 0xa0 0EE0 1B SHL 0EE1 03 SUB 0EE2 81 DUP2 0EE3 35 CALLDATALOAD 0EE4 16 AND 0EE5 90 SWAP1 0EE6 60 PUSH1 0x20 0EE8 01 ADD 0EE9 35 CALLDATALOAD 0EEA 61 PUSH2 0x3a21 0EED 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0EE5 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0EE9 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x3a21 label_0EEE: // Incoming jump from 0x00CE, if 0xd9169487 == stack[-1] 0EEE 5B JUMPDEST 0EEF 61 PUSH2 0x0543 0EF2 61 PUSH2 0x3a79 0EF5 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EEF stack[0] = 0x0543 } // Block ends with call to 0x3a79, returns to 0x0543 label_0EF6: // Incoming jump from 0x00D9, if 0xda2f030f == stack[-1] // Inputs[1] { @0EFD msg.data.length } 0EF6 5B JUMPDEST 0EF7 61 PUSH2 0x0489 0EFA 60 PUSH1 0x04 0EFC 80 DUP1 0EFD 36 CALLDATASIZE 0EFE 03 SUB 0EFF 60 PUSH1 0x20 0F01 81 DUP2 0F02 10 LT 0F03 15 ISZERO 0F04 61 PUSH2 0x0f0c 0F07 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0EF7 stack[0] = 0x0489 // @0EFA stack[1] = 0x04 // @0EFE stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0f0c, if !(msg.data.length - 0x04 < 0x20) label_0F08: // Incoming jump from 0x0F07, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0F0B memory[0x00:0x00] } 0F08 60 PUSH1 0x00 0F0A 80 DUP1 0F0B FD *REVERT // Stack delta = +0 // Outputs[1] { @0F0B revert(memory[0x00:0x00]); } // Block terminates label_0F0C: // Incoming jump from 0x0F07, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0F0E stack[-2] // @0F0E msg.data[stack[-2]:stack[-2] + 0x20] // } 0F0C 5B JUMPDEST 0F0D 50 POP 0F0E 35 CALLDATALOAD 0F0F 60 PUSH1 0x01 0F11 60 PUSH1 0x01 0F13 60 PUSH1 0xa0 0F15 1B SHL 0F16 03 SUB 0F17 16 AND 0F18 61 PUSH2 0x3a9d 0F1B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0F17 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x3a9d label_0F1C: // Incoming jump from 0x00E4, if 0xdb18af6c == stack[-1] // Inputs[1] { @0F23 msg.data.length } 0F1C 5B JUMPDEST 0F1D 61 PUSH2 0x0f39 0F20 60 PUSH1 0x04 0F22 80 DUP1 0F23 36 CALLDATASIZE 0F24 03 SUB 0F25 60 PUSH1 0x20 0F27 81 DUP2 0F28 10 LT 0F29 15 ISZERO 0F2A 61 PUSH2 0x0f32 0F2D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0F1D stack[0] = 0x0f39 // @0F20 stack[1] = 0x04 // @0F24 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0f32, returns to 0x0F39, if !(msg.data.length - 0x04 < 0x20) label_0F2E: // Incoming jump from 0x0F2D, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0F31 memory[0x00:0x00] } 0F2E 60 PUSH1 0x00 0F30 80 DUP1 0F31 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F31 revert(memory[0x00:0x00]); } // Block terminates label_0F32: // Incoming call from 0x0F2D, returns to 0x0F39, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0F34 stack[-2] // @0F34 msg.data[stack[-2]:stack[-2] + 0x20] // } 0F32 5B JUMPDEST 0F33 50 POP 0F34 35 CALLDATALOAD 0F35 61 PUSH2 0x3ab0 0F38 56 *JUMP // Stack delta = -1 // Outputs[1] { @0F34 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x3ab0 label_0F39: // Incoming return from call to 0x0F32 at 0x0F2D // Inputs[5] // { // @0F3D memory[0x40:0x60] // @0F3E stack[-2] // @0F45 stack[-1] // @0F4A memory[0x40:0x60] // @0F51 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40] // } 0F39 5B JUMPDEST 0F3A 60 PUSH1 0x40 0F3C 80 DUP1 0F3D 51 MLOAD 0F3E 92 SWAP3 0F3F 83 DUP4 0F40 52 MSTORE 0F41 60 PUSH1 0x20 0F43 83 DUP4 0F44 01 ADD 0F45 91 SWAP2 0F46 90 SWAP1 0F47 91 SWAP2 0F48 52 MSTORE 0F49 80 DUP1 0F4A 51 MLOAD 0F4B 91 SWAP2 0F4C 82 DUP3 0F4D 90 SWAP1 0F4E 03 SUB 0F4F 01 ADD 0F50 90 SWAP1 0F51 F3 *RETURN // Stack delta = -2 // Outputs[3] // { // @0F40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0F48 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0F51 return memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40]; // } // Block terminates label_0F52: // Incoming jump from 0x00EF, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0F59 msg.data.length } 0F52 5B JUMPDEST 0F53 61 PUSH2 0x0543 0F56 60 PUSH1 0x04 0F58 80 DUP1 0F59 36 CALLDATASIZE 0F5A 03 SUB 0F5B 60 PUSH1 0x40 0F5D 81 DUP2 0F5E 10 LT 0F5F 15 ISZERO 0F60 61 PUSH2 0x0f68 0F63 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0F53 stack[0] = 0x0543 // @0F56 stack[1] = 0x04 // @0F5A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0f68, returns to 0x0543, if !(msg.data.length - 0x04 < 0x40) label_0F64: // Incoming jump from 0x0F63, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0F67 memory[0x00:0x00] } 0F64 60 PUSH1 0x00 0F66 80 DUP1 0F67 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F67 revert(memory[0x00:0x00]); } // Block terminates label_0F68: // Incoming call from 0x0F63, returns to 0x0543, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0F72 stack[-2] // @0F73 msg.data[stack[-2]:stack[-2] + 0x20] // @0F7A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0F68 5B JUMPDEST 0F69 50 POP 0F6A 60 PUSH1 0x01 0F6C 60 PUSH1 0x01 0F6E 60 PUSH1 0xa0 0F70 1B SHL 0F71 03 SUB 0F72 81 DUP2 0F73 35 CALLDATALOAD 0F74 81 DUP2 0F75 16 AND 0F76 91 SWAP2 0F77 60 PUSH1 0x20 0F79 01 ADD 0F7A 35 CALLDATALOAD 0F7B 16 AND 0F7C 61 PUSH2 0x3b30 0F7F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0F76 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0F7B stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x3b30 label_0F80: // Incoming jump from 0x0092, if 0xe1560fd3 == stack[-1] // Inputs[1] { @0F87 msg.data.length } 0F80 5B JUMPDEST 0F81 61 PUSH2 0x04e9 0F84 60 PUSH1 0x04 0F86 80 DUP1 0F87 36 CALLDATASIZE 0F88 03 SUB 0F89 61 PUSH2 0x0120 0F8C 81 DUP2 0F8D 10 LT 0F8E 15 ISZERO 0F8F 61 PUSH2 0x0f97 0F92 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0F81 stack[0] = 0x04e9 // @0F84 stack[1] = 0x04 // @0F88 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0f97, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) label_0F93: // Incoming jump from 0x0F92, if not !(msg.data.length - 0x04 < 0x0120) // Inputs[1] { @0F96 memory[0x00:0x00] } 0F93 60 PUSH1 0x00 0F95 80 DUP1 0F96 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F96 revert(memory[0x00:0x00]); } // Block terminates label_0F97: // Incoming call from 0x0F92, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) // Inputs[10] // { // @0FA1 stack[-2] // @0FA2 msg.data[stack[-2]:stack[-2] + 0x20] // @0FAA msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0FB3 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0FB9 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0FBF msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0FC5 msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @0FCD msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] // @0FD4 msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @0FDA msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } 0F97 5B JUMPDEST 0F98 50 POP 0F99 60 PUSH1 0x01 0F9B 60 PUSH1 0x01 0F9D 60 PUSH1 0xa0 0F9F 1B SHL 0FA0 03 SUB 0FA1 81 DUP2 0FA2 35 CALLDATALOAD 0FA3 81 DUP2 0FA4 16 AND 0FA5 91 SWAP2 0FA6 60 PUSH1 0x20 0FA8 81 DUP2 0FA9 01 ADD 0FAA 35 CALLDATALOAD 0FAB 90 SWAP1 0FAC 91 SWAP2 0FAD 16 AND 0FAE 90 SWAP1 0FAF 60 PUSH1 0x40 0FB1 81 DUP2 0FB2 01 ADD 0FB3 35 CALLDATALOAD 0FB4 90 SWAP1 0FB5 60 PUSH1 0x60 0FB7 81 DUP2 0FB8 01 ADD 0FB9 35 CALLDATALOAD 0FBA 90 SWAP1 0FBB 60 PUSH1 0x80 0FBD 81 DUP2 0FBE 01 ADD 0FBF 35 CALLDATALOAD 0FC0 90 SWAP1 0FC1 60 PUSH1 0xa0 0FC3 81 DUP2 0FC4 01 ADD 0FC5 35 CALLDATALOAD 0FC6 90 SWAP1 0FC7 60 PUSH1 0xff 0FC9 60 PUSH1 0xc0 0FCB 82 DUP3 0FCC 01 ADD 0FCD 35 CALLDATALOAD 0FCE 16 AND 0FCF 90 SWAP1 0FD0 60 PUSH1 0xe0 0FD2 81 DUP2 0FD3 01 ADD 0FD4 35 CALLDATALOAD 0FD5 90 SWAP1 0FD6 61 PUSH2 0x0100 0FD9 01 ADD 0FDA 35 CALLDATALOAD 0FDB 61 PUSH2 0x3c01 0FDE 56 *JUMP // Stack delta = +7 // Outputs[9] // { // @0FA5 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0FAE stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0FB4 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0FBA stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0FC0 stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0FC6 stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @0FCF stack[4] = msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] & 0xff // @0FD5 stack[5] = msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @0FDA stack[6] = msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x3c01 label_0FDF: // Incoming jump from 0x009D, if 0xe1a8eafd == stack[-1] // Inputs[1] { @0FE6 msg.data.length } 0FDF 5B JUMPDEST 0FE0 61 PUSH2 0x04e9 0FE3 60 PUSH1 0x04 0FE5 80 DUP1 0FE6 36 CALLDATASIZE 0FE7 03 SUB 0FE8 60 PUSH1 0x20 0FEA 81 DUP2 0FEB 10 LT 0FEC 15 ISZERO 0FED 61 PUSH2 0x0ff5 0FF0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0FE0 stack[0] = 0x04e9 // @0FE3 stack[1] = 0x04 // @0FE7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0ff5, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_0FF1: // Incoming jump from 0x0FF0, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0FF4 memory[0x00:0x00] } 0FF1 60 PUSH1 0x00 0FF3 80 DUP1 0FF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FF4 revert(memory[0x00:0x00]); } // Block terminates label_0FF5: // Incoming call from 0x0FF0, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0FF7 stack[-2] // @0FF7 msg.data[stack[-2]:stack[-2] + 0x20] // } 0FF5 5B JUMPDEST 0FF6 50 POP 0FF7 35 CALLDATALOAD 0FF8 60 PUSH1 0x01 0FFA 60 PUSH1 0x01 0FFC 60 PUSH1 0xa0 0FFE 1B SHL 0FFF 03 SUB 1000 16 AND 1001 61 PUSH2 0x3d33 1004 56 *JUMP // Stack delta = -1 // Outputs[1] { @1000 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x3d33 label_1005: // Incoming jump from 0x00A8, if 0xe3ee160e == stack[-1] // Inputs[1] { @100C msg.data.length } 1005 5B JUMPDEST 1006 61 PUSH2 0x04e9 1009 60 PUSH1 0x04 100B 80 DUP1 100C 36 CALLDATASIZE 100D 03 SUB 100E 61 PUSH2 0x0120 1011 81 DUP2 1012 10 LT 1013 15 ISZERO 1014 61 PUSH2 0x101c 1017 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1006 stack[0] = 0x04e9 // @1009 stack[1] = 0x04 // @100D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x101c, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) label_1018: // Incoming jump from 0x1017, if not !(msg.data.length - 0x04 < 0x0120) // Inputs[1] { @101B memory[0x00:0x00] } 1018 60 PUSH1 0x00 101A 80 DUP1 101B FD *REVERT // Stack delta = +0 // Outputs[1] { @101B revert(memory[0x00:0x00]); } // Block terminates label_101C: // Incoming call from 0x1017, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x0120) // Inputs[10] // { // @1026 stack[-2] // @1027 msg.data[stack[-2]:stack[-2] + 0x20] // @102F msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1038 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @103E msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @1044 msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @104A msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @1052 msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] // @1059 msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @105F msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } 101C 5B JUMPDEST 101D 50 POP 101E 60 PUSH1 0x01 1020 60 PUSH1 0x01 1022 60 PUSH1 0xa0 1024 1B SHL 1025 03 SUB 1026 81 DUP2 1027 35 CALLDATALOAD 1028 81 DUP2 1029 16 AND 102A 91 SWAP2 102B 60 PUSH1 0x20 102D 81 DUP2 102E 01 ADD 102F 35 CALLDATALOAD 1030 90 SWAP1 1031 91 SWAP2 1032 16 AND 1033 90 SWAP1 1034 60 PUSH1 0x40 1036 81 DUP2 1037 01 ADD 1038 35 CALLDATALOAD 1039 90 SWAP1 103A 60 PUSH1 0x60 103C 81 DUP2 103D 01 ADD 103E 35 CALLDATALOAD 103F 90 SWAP1 1040 60 PUSH1 0x80 1042 81 DUP2 1043 01 ADD 1044 35 CALLDATALOAD 1045 90 SWAP1 1046 60 PUSH1 0xa0 1048 81 DUP2 1049 01 ADD 104A 35 CALLDATALOAD 104B 90 SWAP1 104C 60 PUSH1 0xff 104E 60 PUSH1 0xc0 1050 82 DUP3 1051 01 ADD 1052 35 CALLDATALOAD 1053 16 AND 1054 90 SWAP1 1055 60 PUSH1 0xe0 1057 81 DUP2 1058 01 ADD 1059 35 CALLDATALOAD 105A 90 SWAP1 105B 61 PUSH2 0x0100 105E 01 ADD 105F 35 CALLDATALOAD 1060 61 PUSH2 0x3deb 1063 56 *JUMP // Stack delta = +7 // Outputs[9] // { // @102A stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @1033 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1039 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @103F stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @1045 stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @104B stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @1054 stack[4] = msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] & 0xff // @105A stack[5] = msg.data[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] // @105F stack[6] = msg.data[0x0100 + stack[-2]:0x0100 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x3deb label_1064: // Incoming jump from 0x00B3, if 0xe46638e6 == stack[-1] // Inputs[1] { @106B msg.data.length } 1064 5B JUMPDEST 1065 61 PUSH2 0x109a 1068 60 PUSH1 0x04 106A 80 DUP1 106B 36 CALLDATASIZE 106C 03 SUB 106D 60 PUSH1 0x60 106F 81 DUP2 1070 10 LT 1071 15 ISZERO 1072 61 PUSH2 0x107a 1075 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1065 stack[0] = 0x109a // @1068 stack[1] = 0x04 // @106C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x107a, returns to 0x109A, if !(msg.data.length - 0x04 < 0x60) label_1076: // Incoming jump from 0x1075, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @1079 memory[0x00:0x00] } 1076 60 PUSH1 0x00 1078 80 DUP1 1079 FD *REVERT // Stack delta = +0 // Outputs[1] { @1079 revert(memory[0x00:0x00]); } // Block terminates label_107A: // Incoming call from 0x1075, returns to 0x109A, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @1084 stack[-2] // @1085 msg.data[stack[-2]:stack[-2] + 0x20] // @108D msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1095 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 107A 5B JUMPDEST 107B 50 POP 107C 60 PUSH1 0x01 107E 60 PUSH1 0x01 1080 60 PUSH1 0xa0 1082 1B SHL 1083 03 SUB 1084 81 DUP2 1085 35 CALLDATALOAD 1086 81 DUP2 1087 16 AND 1088 91 SWAP2 1089 60 PUSH1 0x20 108B 81 DUP2 108C 01 ADD 108D 35 CALLDATALOAD 108E 90 SWAP1 108F 91 SWAP2 1090 16 AND 1091 90 SWAP1 1092 60 PUSH1 0x40 1094 01 ADD 1095 35 CALLDATALOAD 1096 61 PUSH2 0x3f2c 1099 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1088 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @1091 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1095 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x3f2c label_109A: // Incoming return from call to 0x107A at 0x1075 // Inputs[6] // { // @109E memory[0x40:0x60] // @109F stack[-3] // @10A8 stack[-2] // @10AF stack[-1] // @10B0 memory[0x40:0x60] // @10B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 109A 5B JUMPDEST 109B 60 PUSH1 0x40 109D 80 DUP1 109E 51 MLOAD 109F 93 SWAP4 10A0 15 ISZERO 10A1 15 ISZERO 10A2 84 DUP5 10A3 52 MSTORE 10A4 60 PUSH1 0x20 10A6 84 DUP5 10A7 01 ADD 10A8 92 SWAP3 10A9 90 SWAP1 10AA 92 SWAP3 10AB 52 MSTORE 10AC 82 DUP3 10AD 82 DUP3 10AE 01 ADD 10AF 52 MSTORE 10B0 51 MLOAD 10B1 90 SWAP1 10B2 81 DUP2 10B3 90 SWAP1 10B4 03 SUB 10B5 60 PUSH1 0x60 10B7 01 ADD 10B8 90 SWAP1 10B9 F3 *RETURN // Stack delta = -3 // Outputs[4] // { // @10A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-3] // @10AB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-2] // @10AF memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-1] // @10B9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_10BA: // Incoming jump from 0x0056, if 0xeb9253c0 == stack[-1] // Inputs[1] { @10C1 msg.data.length } 10BA 5B JUMPDEST 10BB 61 PUSH2 0x04e9 10BE 60 PUSH1 0x04 10C0 80 DUP1 10C1 36 CALLDATASIZE 10C2 03 SUB 10C3 60 PUSH1 0x40 10C5 81 DUP2 10C6 10 LT 10C7 15 ISZERO 10C8 61 PUSH2 0x10d0 10CB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @10BB stack[0] = 0x04e9 // @10BE stack[1] = 0x04 // @10C2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x10d0, if !(msg.data.length - 0x04 < 0x40) label_10CC: // Incoming jump from 0x10CB, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @10CF memory[0x00:0x00] } 10CC 60 PUSH1 0x00 10CE 80 DUP1 10CF FD *REVERT // Stack delta = +0 // Outputs[1] { @10CF revert(memory[0x00:0x00]); } // Block terminates label_10D0: // Incoming jump from 0x10CB, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @10DA stack[-2] // @10DB msg.data[stack[-2]:stack[-2] + 0x20] // @10E1 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 10D0 5B JUMPDEST 10D1 50 POP 10D2 60 PUSH1 0x01 10D4 60 PUSH1 0x01 10D6 60 PUSH1 0xa0 10D8 1B SHL 10D9 03 SUB 10DA 81 DUP2 10DB 35 CALLDATALOAD 10DC 16 AND 10DD 90 SWAP1 10DE 60 PUSH1 0x20 10E0 01 ADD 10E1 35 CALLDATALOAD 10E2 61 PUSH2 0x401b 10E5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @10DD stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @10E1 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x401b label_10E6: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @10ED msg.data.length } 10E6 5B JUMPDEST 10E7 61 PUSH2 0x04e9 10EA 60 PUSH1 0x04 10EC 80 DUP1 10ED 36 CALLDATASIZE 10EE 03 SUB 10EF 60 PUSH1 0x20 10F1 81 DUP2 10F2 10 LT 10F3 15 ISZERO 10F4 61 PUSH2 0x10fc 10F7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @10E7 stack[0] = 0x04e9 // @10EA stack[1] = 0x04 // @10EE stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x10fc, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) label_10F8: // Incoming jump from 0x10F7, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @10FB memory[0x00:0x00] } 10F8 60 PUSH1 0x00 10FA 80 DUP1 10FB FD *REVERT // Stack delta = +0 // Outputs[1] { @10FB revert(memory[0x00:0x00]); } // Block terminates label_10FC: // Incoming call from 0x10F7, returns to 0x04E9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @10FE msg.data[stack[-2]:stack[-2] + 0x20] // @10FE stack[-2] // } 10FC 5B JUMPDEST 10FD 50 POP 10FE 35 CALLDATALOAD 10FF 60 PUSH1 0x01 1101 60 PUSH1 0x01 1103 60 PUSH1 0xa0 1105 1B SHL 1106 03 SUB 1107 16 AND 1108 61 PUSH2 0x41b9 110B 56 *JUMP // Stack delta = -1 // Outputs[1] { @1107 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x41b9 label_110C: // Incoming jump from 0x006C, if 0xf65d6638 == stack[-1] // Inputs[1] { @1113 msg.data.length } 110C 5B JUMPDEST 110D 61 PUSH2 0x04e9 1110 60 PUSH1 0x04 1112 80 DUP1 1113 36 CALLDATASIZE 1114 03 SUB 1115 60 PUSH1 0xc0 1117 81 DUP2 1118 10 LT 1119 15 ISZERO 111A 61 PUSH2 0x1122 111D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @110D stack[0] = 0x04e9 // @1110 stack[1] = 0x04 // @1114 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x1122, if !(msg.data.length - 0x04 < 0xc0) label_111E: // Incoming jump from 0x111D, if not !(msg.data.length - 0x04 < 0xc0) // Inputs[1] { @1121 memory[0x00:0x00] } 111E 60 PUSH1 0x00 1120 80 DUP1 1121 FD *REVERT // Stack delta = +0 // Outputs[1] { @1121 revert(memory[0x00:0x00]); } // Block terminates label_1122: // Incoming jump from 0x111D, if !(msg.data.length - 0x04 < 0xc0) // Inputs[5] // { // @112B stack[-2] // @112C msg.data[stack[-2]:stack[-2] + 0x20] // @1134 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1138 stack[-1] // @1144 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 1122 5B JUMPDEST 1123 60 PUSH1 0x01 1125 60 PUSH1 0x01 1127 60 PUSH1 0xa0 1129 1B SHL 112A 03 SUB 112B 82 DUP3 112C 35 CALLDATALOAD 112D 81 DUP2 112E 16 AND 112F 92 SWAP3 1130 60 PUSH1 0x20 1132 81 DUP2 1133 01 ADD 1134 35 CALLDATALOAD 1135 90 SWAP1 1136 91 SWAP2 1137 16 AND 1138 91 SWAP2 1139 81 DUP2 113A 01 ADD 113B 90 SWAP1 113C 60 PUSH1 0x60 113E 81 DUP2 113F 01 ADD 1140 60 PUSH1 0x40 1142 82 DUP3 1143 01 ADD 1144 35 CALLDATALOAD 1145 60 PUSH1 0x01 1147 60 PUSH1 0x20 1149 1B SHL 114A 81 DUP2 114B 11 GT 114C 15 ISZERO 114D 61 PUSH2 0x1155 1150 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @112F stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @1138 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @113B stack[0] = stack[-2] + stack[-1] // @113B stack[1] = stack[-2] // @113F stack[2] = stack[-2] + 0x60 // @1144 stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x1155, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_1151: // Incoming jump from 0x1150, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @1154 memory[0x00:0x00] } 1151 60 PUSH1 0x00 1153 80 DUP1 1154 FD *REVERT // Stack delta = +0 // Outputs[1] { @1154 revert(memory[0x00:0x00]); } // Block terminates label_1155: // Incoming jump from 0x1150, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @1156 stack[-3] // @1157 stack[-1] // @1158 stack[-4] // } 1155 5B JUMPDEST 1156 82 DUP3 1157 01 ADD 1158 83 DUP4 1159 60 PUSH1 0x20 115B 82 DUP3 115C 01 ADD 115D 11 GT 115E 15 ISZERO 115F 61 PUSH2 0x1167 1162 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1157 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1167, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1163: // Incoming jump from 0x1162, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @1166 memory[0x00:0x00] } 1163 60 PUSH1 0x00 1165 80 DUP1 1166 FD *REVERT // Stack delta = +0 // Outputs[1] { @1166 revert(memory[0x00:0x00]); } // Block terminates label_1167: // Incoming jump from 0x1162, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @1168 stack[-1] // @1169 msg.data[stack[-1]:stack[-1] + 0x20] // @116E stack[-2] // @116F stack[-4] // } 1167 5B JUMPDEST 1168 80 DUP1 1169 35 CALLDATALOAD 116A 90 SWAP1 116B 60 PUSH1 0x20 116D 01 ADD 116E 91 SWAP2 116F 84 DUP5 1170 60 PUSH1 0x01 1172 83 DUP4 1173 02 MUL 1174 84 DUP5 1175 01 ADD 1176 11 GT 1177 60 PUSH1 0x01 1179 60 PUSH1 0x20 117B 1B SHL 117C 83 DUP4 117D 11 GT 117E 17 OR 117F 15 ISZERO 1180 61 PUSH2 0x1188 1183 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @116A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @116E stack[0] = stack[-2] // @116E stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x1188, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_1184: // Incoming jump from 0x1183, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @1187 memory[0x00:0x00] } 1184 60 PUSH1 0x00 1186 80 DUP1 1187 FD *REVERT // Stack delta = +0 // Outputs[1] { @1187 revert(memory[0x00:0x00]); } // Block terminates label_1188: // Incoming jump from 0x1183, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @1189 stack[-1] // @1189 stack[-3] // @118A stack[-2] // @119B memory[0x40:0x60] // @11B2 msg.data[stack[-3]:stack[-3] + stack[-2]] // @11BD stack[-5] // @11BE stack[-4] // @11C6 msg.data[stack[-1]:stack[-1] + 0x20] // } 1188 5B JUMPDEST 1189 91 SWAP2 118A 90 SWAP1 118B 80 DUP1 118C 80 DUP1 118D 60 PUSH1 0x1f 118F 01 ADD 1190 60 PUSH1 0x20 1192 80 DUP1 1193 91 SWAP2 1194 04 DIV 1195 02 MUL 1196 60 PUSH1 0x20 1198 01 ADD 1199 60 PUSH1 0x40 119B 51 MLOAD 119C 90 SWAP1 119D 81 DUP2 119E 01 ADD 119F 60 PUSH1 0x40 11A1 52 MSTORE 11A2 80 DUP1 11A3 93 SWAP4 11A4 92 SWAP3 11A5 91 SWAP2 11A6 90 SWAP1 11A7 81 DUP2 11A8 81 DUP2 11A9 52 MSTORE 11AA 60 PUSH1 0x20 11AC 01 ADD 11AD 83 DUP4 11AE 83 DUP4 11AF 80 DUP1 11B0 82 DUP3 11B1 84 DUP5 11B2 37 CALLDATACOPY 11B3 60 PUSH1 0x00 11B5 92 SWAP3 11B6 01 ADD 11B7 91 SWAP2 11B8 90 SWAP1 11B9 91 SWAP2 11BA 52 MSTORE 11BB 50 POP 11BC 92 SWAP3 11BD 95 SWAP6 11BE 94 SWAP5 11BF 93 SWAP4 11C0 60 PUSH1 0x20 11C2 81 DUP2 11C3 01 ADD 11C4 93 SWAP4 11C5 50 POP 11C6 35 CALLDATALOAD 11C7 91 SWAP2 11C8 50 POP 11C9 50 POP 11CA 60 PUSH1 0x01 11CC 60 PUSH1 0x20 11CE 1B SHL 11CF 81 DUP2 11D0 11 GT 11D1 15 ISZERO 11D2 61 PUSH2 0x11da 11D5 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @11A1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @11A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @11B2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @11BA memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @11BD stack[-5] = memory[0x40:0x60] // @11BE stack[-4] = stack[-5] // @11BF stack[-3] = stack[-4] // @11C4 stack[-2] = stack[-1] + 0x20 // @11C7 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x11da, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_11D6: // Incoming jump from 0x11D5, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @11D9 memory[0x00:0x00] } 11D6 60 PUSH1 0x00 11D8 80 DUP1 11D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @11D9 revert(memory[0x00:0x00]); } // Block terminates label_11DA: // Incoming jump from 0x11D5, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @11DB stack[-3] // @11DC stack[-1] // @11DD stack[-4] // } 11DA 5B JUMPDEST 11DB 82 DUP3 11DC 01 ADD 11DD 83 DUP4 11DE 60 PUSH1 0x20 11E0 82 DUP3 11E1 01 ADD 11E2 11 GT 11E3 15 ISZERO 11E4 61 PUSH2 0x11ec 11E7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @11DC stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x11ec, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_11E8: // Incoming jump from 0x11E7, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @11EB memory[0x00:0x00] } 11E8 60 PUSH1 0x00 11EA 80 DUP1 11EB FD *REVERT // Stack delta = +0 // Outputs[1] { @11EB revert(memory[0x00:0x00]); } // Block terminates label_11EC: // Incoming jump from 0x11E7, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @11ED stack[-1] // @11EE msg.data[stack[-1]:stack[-1] + 0x20] // @11F3 stack[-2] // @11F4 stack[-4] // } 11EC 5B JUMPDEST 11ED 80 DUP1 11EE 35 CALLDATALOAD 11EF 90 SWAP1 11F0 60 PUSH1 0x20 11F2 01 ADD 11F3 91 SWAP2 11F4 84 DUP5 11F5 60 PUSH1 0x01 11F7 83 DUP4 11F8 02 MUL 11F9 84 DUP5 11FA 01 ADD 11FB 11 GT 11FC 60 PUSH1 0x01 11FE 60 PUSH1 0x20 1200 1B SHL 1201 83 DUP4 1202 11 GT 1203 17 OR 1204 15 ISZERO 1205 61 PUSH2 0x120d 1208 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @11EF stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @11F3 stack[0] = stack[-2] // @11F3 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x120d, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_1209: // Incoming jump from 0x1208, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @120C memory[0x00:0x00] } 1209 60 PUSH1 0x00 120B 80 DUP1 120C FD *REVERT // Stack delta = +0 // Outputs[1] { @120C revert(memory[0x00:0x00]); } // Block terminates label_120D: // Incoming jump from 0x1208, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[9] // { // @120E stack[-3] // @120E stack[-1] // @120F stack[-2] // @1220 memory[0x40:0x60] // @1237 msg.data[stack[-3]:stack[-3] + stack[-2]] // @1242 stack[-5] // @1246 msg.data[stack[-1]:stack[-1] + 0x20] // @1248 stack[-4] // @1257 msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } 120D 5B JUMPDEST 120E 91 SWAP2 120F 90 SWAP1 1210 80 DUP1 1211 80 DUP1 1212 60 PUSH1 0x1f 1214 01 ADD 1215 60 PUSH1 0x20 1217 80 DUP1 1218 91 SWAP2 1219 04 DIV 121A 02 MUL 121B 60 PUSH1 0x20 121D 01 ADD 121E 60 PUSH1 0x40 1220 51 MLOAD 1221 90 SWAP1 1222 81 DUP2 1223 01 ADD 1224 60 PUSH1 0x40 1226 52 MSTORE 1227 80 DUP1 1228 93 SWAP4 1229 92 SWAP3 122A 91 SWAP2 122B 90 SWAP1 122C 81 DUP2 122D 81 DUP2 122E 52 MSTORE 122F 60 PUSH1 0x20 1231 01 ADD 1232 83 DUP4 1233 83 DUP4 1234 80 DUP1 1235 82 DUP3 1236 84 DUP5 1237 37 CALLDATACOPY 1238 60 PUSH1 0x00 123A 92 SWAP3 123B 01 ADD 123C 91 SWAP2 123D 90 SWAP1 123E 91 SWAP2 123F 52 MSTORE 1240 50 POP 1241 92 SWAP3 1242 95 SWAP6 1243 60 PUSH1 0xff 1245 85 DUP6 1246 35 CALLDATALOAD 1247 16 AND 1248 95 SWAP6 1249 90 SWAP1 124A 94 SWAP5 124B 90 SWAP1 124C 93 SWAP4 124D 50 POP 124E 60 PUSH1 0x40 1250 81 DUP2 1251 01 ADD 1252 92 SWAP3 1253 50 POP 1254 60 PUSH1 0x20 1256 01 ADD 1257 35 CALLDATALOAD 1258 90 SWAP1 1259 50 POP 125A 60 PUSH1 0x01 125C 60 PUSH1 0x20 125E 1B SHL 125F 81 DUP2 1260 11 GT 1261 15 ISZERO 1262 61 PUSH2 0x126a 1265 57 *JUMPI // Stack delta = +1 // Outputs[10] // { // @1226 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @122E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1237 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @123F memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @1242 stack[-5] = memory[0x40:0x60] // @1248 stack[-4] = msg.data[stack[-1]:stack[-1] + 0x20] & 0xff // @124A stack[-3] = stack[-5] // @124C stack[-2] = stack[-4] // @1252 stack[-1] = stack[-1] + 0x40 // @1258 stack[0] = msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } // Block ends with conditional jump to 0x126a, if !(msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] > 0x01 << 0x20) label_1266: // Incoming jump from 0x1265, if not !(msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @1269 memory[0x00:0x00] } 1266 60 PUSH1 0x00 1268 80 DUP1 1269 FD *REVERT // Stack delta = +0 // Outputs[1] { @1269 revert(memory[0x00:0x00]); } // Block terminates label_126A: // Incoming jump from 0x1265, if !(msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @126B stack[-3] // @126C stack[-1] // @126D stack[-4] // } 126A 5B JUMPDEST 126B 82 DUP3 126C 01 ADD 126D 83 DUP4 126E 60 PUSH1 0x20 1270 82 DUP3 1271 01 ADD 1272 11 GT 1273 15 ISZERO 1274 61 PUSH2 0x127c 1277 57 *JUMPI // Stack delta = +0 // Outputs[1] { @126C stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x127c, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1278: // Incoming jump from 0x1277, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @127B memory[0x00:0x00] } 1278 60 PUSH1 0x00 127A 80 DUP1 127B FD *REVERT // Stack delta = +0 // Outputs[1] { @127B revert(memory[0x00:0x00]); } // Block terminates label_127C: // Incoming jump from 0x1277, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @127D stack[-1] // @127E msg.data[stack[-1]:stack[-1] + 0x20] // @1283 stack[-2] // @1284 stack[-4] // } 127C 5B JUMPDEST 127D 80 DUP1 127E 35 CALLDATALOAD 127F 90 SWAP1 1280 60 PUSH1 0x20 1282 01 ADD 1283 91 SWAP2 1284 84 DUP5 1285 60 PUSH1 0x20 1287 83 DUP4 1288 02 MUL 1289 84 DUP5 128A 01 ADD 128B 11 GT 128C 60 PUSH1 0x01 128E 60 PUSH1 0x20 1290 1B SHL 1291 83 DUP4 1292 11 GT 1293 17 OR 1294 15 ISZERO 1295 61 PUSH2 0x129d 1298 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @127F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @1283 stack[0] = stack[-2] // @1283 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x129d, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_1299: // Incoming jump from 0x1298, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @129C memory[0x00:0x00] } 1299 60 PUSH1 0x00 129B 80 DUP1 129C FD *REVERT // Stack delta = +0 // Outputs[1] { @129C revert(memory[0x00:0x00]); } // Block terminates label_129D: // Incoming jump from 0x1298, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @129E stack[-3] // @129E stack[-1] // @129F stack[-2] // @12AA memory[0x40:0x60] // @12C4 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @12CF stack[-5] // @12D4 stack[-4] // } 129D 5B JUMPDEST 129E 91 SWAP2 129F 90 SWAP1 12A0 80 DUP1 12A1 80 DUP1 12A2 60 PUSH1 0x20 12A4 02 MUL 12A5 60 PUSH1 0x20 12A7 01 ADD 12A8 60 PUSH1 0x40 12AA 51 MLOAD 12AB 90 SWAP1 12AC 81 DUP2 12AD 01 ADD 12AE 60 PUSH1 0x40 12B0 52 MSTORE 12B1 80 DUP1 12B2 93 SWAP4 12B3 92 SWAP3 12B4 91 SWAP2 12B5 90 SWAP1 12B6 81 DUP2 12B7 81 DUP2 12B8 52 MSTORE 12B9 60 PUSH1 0x20 12BB 01 ADD 12BC 83 DUP4 12BD 83 DUP4 12BE 60 PUSH1 0x20 12C0 02 MUL 12C1 80 DUP1 12C2 82 DUP3 12C3 84 DUP5 12C4 37 CALLDATACOPY 12C5 60 PUSH1 0x00 12C7 92 SWAP3 12C8 01 ADD 12C9 91 SWAP2 12CA 90 SWAP1 12CB 91 SWAP2 12CC 52 MSTORE 12CD 50 POP 12CE 92 SWAP3 12CF 95 SWAP6 12D0 50 POP 12D1 61 PUSH2 0x42b2 12D4 94 SWAP5 12D5 50 POP 12D6 50 POP 12D7 50 POP 12D8 50 POP 12D9 50 POP 12DA 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @12B0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @12B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @12C4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @12CC memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @12CF stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x42b2 label_12DB: // Incoming jump from 0x0077, if 0xfc700bd1 == stack[-1] // Inputs[1] { @12E2 msg.data.length } 12DB 5B JUMPDEST 12DC 61 PUSH2 0x0489 12DF 60 PUSH1 0x04 12E1 80 DUP1 12E2 36 CALLDATASIZE 12E3 03 SUB 12E4 60 PUSH1 0x20 12E6 81 DUP2 12E7 10 LT 12E8 15 ISZERO 12E9 61 PUSH2 0x12f1 12EC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @12DC stack[0] = 0x0489 // @12DF stack[1] = 0x04 // @12E3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x12f1, if !(msg.data.length - 0x04 < 0x20) label_12ED: // Incoming jump from 0x12EC, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @12F0 memory[0x00:0x00] } 12ED 60 PUSH1 0x00 12EF 80 DUP1 12F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @12F0 revert(memory[0x00:0x00]); } // Block terminates label_12F1: // Incoming jump from 0x12EC, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @12F3 stack[-2] // @12F3 msg.data[stack[-2]:stack[-2] + 0x20] // } 12F1 5B JUMPDEST 12F2 50 POP 12F3 35 CALLDATALOAD 12F4 60 PUSH1 0x01 12F6 60 PUSH1 0x01 12F8 60 PUSH1 0xa0 12FA 1B SHL 12FB 03 SUB 12FC 16 AND 12FD 61 PUSH2 0x4368 1300 56 *JUMP // Stack delta = -1 // Outputs[1] { @12FC stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x4368 label_1301: // Incoming jump from 0x0082, if 0xffa1ad74 == stack[-1] 1301 5B JUMPDEST 1302 61 PUSH2 0x0543 1305 61 PUSH2 0x437b 1308 56 *JUMP // Stack delta = +1 // Outputs[1] { @1302 stack[0] = 0x0543 } // Block ends with call to 0x437b, returns to 0x0543 label_1309: // Incoming call from 0x03E7, returns to 0x03E8 // Inputs[1] { @130C storage[0x97] } 1309 5B JUMPDEST 130A 60 PUSH1 0x97 130C 54 SLOAD 130D 60 PUSH1 0x60 130F 90 SWAP1 1310 60 PUSH1 0x01 1312 60 PUSH1 0x01 1314 60 PUSH1 0xa0 1316 1B SHL 1317 03 SUB 1318 16 AND 1319 61 PUSH2 0x1352 131C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @130F stack[0] = 0x60 } // Block ends with conditional jump to 0x1352, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_131D: // Incoming jump from 0x131C, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @1320 memory[0x40:0x60] // @1348 memory[0x40:0x60] // @1351 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 131D 60 PUSH1 0x40 131F 80 DUP1 1320 51 MLOAD 1321 62 PUSH3 0x461bcd 1325 60 PUSH1 0xe5 1327 1B SHL 1328 81 DUP2 1329 52 MSTORE 132A 60 PUSH1 0x20 132C 60 PUSH1 0x04 132E 80 DUP1 132F 83 DUP4 1330 01 ADD 1331 91 SWAP2 1332 90 SWAP1 1333 91 SWAP2 1334 52 MSTORE 1335 60 PUSH1 0x24 1337 82 DUP3 1338 01 ADD 1339 52 MSTORE 133A 63 PUSH4 0x50523031 133F 60 PUSH1 0xe0 1341 1B SHL 1342 60 PUSH1 0x44 1344 82 DUP3 1345 01 ADD 1346 52 MSTORE 1347 90 SWAP1 1348 51 MLOAD 1349 90 SWAP1 134A 81 DUP2 134B 90 SWAP1 134C 03 SUB 134D 60 PUSH1 0x64 134F 01 ADD 1350 90 SWAP1 1351 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1329 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1334 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1339 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1346 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @1351 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1352: // Incoming jump from 0x131C, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @1358 storage[0x97] // @1379 memory[0x40:0x60] // @138D memory[0x40:0x60] // @1394 address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } 1352 5B JUMPDEST 1353 60 PUSH1 0x97 1355 60 PUSH1 0x00 1357 90 SWAP1 1358 54 SLOAD 1359 90 SWAP1 135A 61 PUSH2 0x0100 135D 0A EXP 135E 90 SWAP1 135F 04 DIV 1360 60 PUSH1 0x01 1362 60 PUSH1 0x01 1364 60 PUSH1 0xa0 1366 1B SHL 1367 03 SUB 1368 16 AND 1369 60 PUSH1 0x01 136B 60 PUSH1 0x01 136D 60 PUSH1 0xa0 136F 1B SHL 1370 03 SUB 1371 16 AND 1372 63 PUSH4 0x06fdde03 1377 60 PUSH1 0x40 1379 51 MLOAD 137A 81 DUP2 137B 63 PUSH4 0xffffffff 1380 16 AND 1381 60 PUSH1 0xe0 1383 1B SHL 1384 81 DUP2 1385 52 MSTORE 1386 60 PUSH1 0x04 1388 01 ADD 1389 60 PUSH1 0x00 138B 60 PUSH1 0x40 138D 51 MLOAD 138E 80 DUP1 138F 83 DUP4 1390 03 SUB 1391 81 DUP2 1392 86 DUP7 1393 80 DUP1 1394 3B EXTCODESIZE 1395 15 ISZERO 1396 80 DUP1 1397 15 ISZERO 1398 61 PUSH2 0x13a0 139B 57 *JUMPI // Stack delta = +9 // Outputs[10] // { // @1371 stack[0] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @1372 stack[1] = 0x06fdde03 // @1385 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x06fdde03) << 0xe0 // @1388 stack[2] = 0x04 + memory[0x40:0x60] // @1389 stack[3] = 0x00 // @138D stack[4] = memory[0x40:0x60] // @1390 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1391 stack[6] = memory[0x40:0x60] // @1392 stack[7] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @1395 stack[8] = !address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x13a0, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length label_139C: // Incoming jump from 0x139B, if not !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Inputs[1] { @139F memory[0x00:0x00] } 139C 60 PUSH1 0x00 139E 80 DUP1 139F FD *REVERT // Stack delta = +0 // Outputs[1] { @139F revert(memory[0x00:0x00]); } // Block terminates label_13A0: // Incoming jump from 0x2E4B, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Incoming jump from 0x139B, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @13A2 msg.gas // @13A3 stack[-2] // @13A3 stack[-6] // @13A3 stack[-5] // @13A3 memory[stack[-3]:stack[-3] + stack[-4]] // @13A3 stack[-3] // @13A3 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @13A3 stack[-4] // } 13A0 5B JUMPDEST 13A1 50 POP 13A2 5A GAS 13A3 FA STATICCALL 13A4 15 ISZERO 13A5 80 DUP1 13A6 15 ISZERO 13A7 61 PUSH2 0x13b4 13AA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @13A3 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @13A4 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x13b4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_13AB: // Incoming jump from 0x13AA, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @13AB returndata.length // @13AF returndata[0x00:0x00 + returndata.length] // @13B0 returndata.length // @13B3 memory[0x00:0x00 + returndata.length] // } 13AB 3D RETURNDATASIZE 13AC 60 PUSH1 0x00 13AE 80 DUP1 13AF 3E RETURNDATACOPY 13B0 3D RETURNDATASIZE 13B1 60 PUSH1 0x00 13B3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @13AF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @13B3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_13B4: // Incoming jump from 0x13AA, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @13BB memory[0x40:0x60] // @13BC returndata.length // @13C0 returndata[0x00:0x00 + returndata.length] // @13C3 returndata.length // } 13B4 5B JUMPDEST 13B5 50 POP 13B6 50 POP 13B7 50 POP 13B8 50 POP 13B9 60 PUSH1 0x40 13BB 51 MLOAD 13BC 3D RETURNDATASIZE 13BD 60 PUSH1 0x00 13BF 82 DUP3 13C0 3E RETURNDATACOPY 13C1 60 PUSH1 0x1f 13C3 3D RETURNDATASIZE 13C4 90 SWAP1 13C5 81 DUP2 13C6 01 ADD 13C7 60 PUSH1 0x1f 13C9 19 NOT 13CA 16 AND 13CB 82 DUP3 13CC 01 ADD 13CD 60 PUSH1 0x40 13CF 52 MSTORE 13D0 60 PUSH1 0x20 13D2 81 DUP2 13D3 10 LT 13D4 15 ISZERO 13D5 61 PUSH2 0x13dd 13D8 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @13BB stack[-4] = memory[0x40:0x60] // @13C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @13C4 stack[-3] = returndata.length // @13CF memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // } // Block ends with conditional jump to 0x13dd, if !(returndata.length < 0x20) label_13D9: // Incoming jump from 0x13D8, if not !(returndata.length < 0x20) // Inputs[1] { @13DC memory[0x00:0x00] } 13D9 60 PUSH1 0x00 13DB 80 DUP1 13DC FD *REVERT // Stack delta = +0 // Outputs[1] { @13DC revert(memory[0x00:0x00]); } // Block terminates label_13DD: // Incoming jump from 0x13D8, if !(returndata.length < 0x20) // Inputs[4] // { // @13DE stack[-2] // @13DF stack[-1] // @13E3 memory[stack[-2]:stack[-2] + 0x20] // @13E6 memory[0x40:0x60] // } 13DD 5B JUMPDEST 13DE 81 DUP2 13DF 01 ADD 13E0 90 SWAP1 13E1 80 DUP1 13E2 80 DUP1 13E3 51 MLOAD 13E4 60 PUSH1 0x40 13E6 51 MLOAD 13E7 93 SWAP4 13E8 92 SWAP3 13E9 91 SWAP2 13EA 90 SWAP1 13EB 84 DUP5 13EC 60 PUSH1 0x01 13EE 60 PUSH1 0x20 13F0 1B SHL 13F1 82 DUP3 13F2 11 GT 13F3 15 ISZERO 13F4 61 PUSH2 0x13fc 13F7 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @13E7 stack[-2] = memory[0x40:0x60] // @13E8 stack[-1] = stack[-2] + stack[-1] // @13E9 stack[0] = stack[-2] // @13EA stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @13EA stack[1] = stack[-2] // @13EB stack[3] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x13fc, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_13F8: // Incoming jump from 0x13F7, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @13FB memory[0x00:0x00] } 13F8 60 PUSH1 0x00 13FA 80 DUP1 13FB FD *REVERT // Stack delta = +0 // Outputs[1] { @13FB revert(memory[0x00:0x00]); } // Block terminates label_13FC: // Incoming jump from 0x13F7, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[4] // { // @13FD stack[-1] // @13FD stack[-2] // @13FE stack[-4] // @1405 stack[-5] // } 13FC 5B JUMPDEST 13FD 90 SWAP1 13FE 83 DUP4 13FF 01 ADD 1400 90 SWAP1 1401 60 PUSH1 0x20 1403 82 DUP3 1404 01 ADD 1405 85 DUP6 1406 81 DUP2 1407 11 GT 1408 15 ISZERO 1409 61 PUSH2 0x1411 140C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1400 stack[-2] = stack[-4] + stack[-2] // @1400 stack[-1] = stack[-1] // @1404 stack[0] = stack[-4] + stack[-2] + 0x20 // } // Block ends with conditional jump to 0x1411, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_140D: // Incoming jump from 0x140C, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @1410 memory[0x00:0x00] } 140D 60 PUSH1 0x00 140F 80 DUP1 1410 FD *REVERT // Stack delta = +0 // Outputs[1] { @1410 revert(memory[0x00:0x00]); } // Block terminates label_1411: // Incoming jump from 0x140C, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[4] // { // @1412 stack[-3] // @1413 memory[stack[-3]:stack[-3] + 0x20] // @141B stack[-1] // @141E stack[-6] // } 1411 5B JUMPDEST 1412 82 DUP3 1413 51 MLOAD 1414 60 PUSH1 0x01 1416 60 PUSH1 0x20 1418 1B SHL 1419 81 DUP2 141A 11 GT 141B 82 DUP3 141C 82 DUP3 141D 01 ADD 141E 88 DUP9 141F 10 LT 1420 17 OR 1421 15 ISZERO 1422 61 PUSH2 0x142a 1425 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1413 stack[0] = memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x142a, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) label_1426: // Incoming jump from 0x1425, if not !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[1] { @1429 memory[0x00:0x00] } 1426 60 PUSH1 0x00 1428 80 DUP1 1429 FD *REVERT // Stack delta = +0 // Outputs[1] { @1429 revert(memory[0x00:0x00]); } // Block terminates label_142A: // Incoming jump from 0x1425, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[4] // { // @142B stack[-3] // @142C stack[-1] // @142E stack[-4] // @142F memory[stack[-4]:stack[-4] + 0x20] // } 142A 5B JUMPDEST 142B 82 DUP3 142C 52 MSTORE 142D 50 POP 142E 81 DUP2 142F 51 MLOAD 1430 60 PUSH1 0x20 1432 91 SWAP2 1433 82 DUP3 1434 01 ADD 1435 92 SWAP3 1436 90 SWAP1 1437 91 SWAP2 1438 01 ADD 1439 90 SWAP1 143A 80 DUP1 143B 83 DUP4 143C 83 DUP4 143D 60 PUSH1 0x00 143F 5B JUMPDEST 1440 83 DUP4 1441 81 DUP2 1442 10 LT 1443 15 ISZERO 1444 61 PUSH2 0x1457 1447 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @142C memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @1435 stack[-4] = 0x20 + stack[-3] // @1439 stack[-2] = memory[stack[-4]:stack[-4] + 0x20] // @1439 stack[-3] = 0x20 + stack[-4] // @143A stack[-1] = memory[stack[-4]:stack[-4] + 0x20] // @143B stack[0] = 0x20 + stack[-3] // @143C stack[1] = 0x20 + stack[-4] // @143D stack[2] = 0x00 // } // Block ends with conditional jump to 0x1457, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_1448: // Incoming jump from 0x1447, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1447, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @1448 stack[-2] // @1449 stack[-1] // @144B memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @144C stack[-3] // } 1448 81 DUP2 1449 81 DUP2 144A 01 ADD 144B 51 MLOAD 144C 83 DUP4 144D 82 DUP3 144E 01 ADD 144F 52 MSTORE 1450 60 PUSH1 0x20 1452 01 ADD 1453 61 PUSH2 0x143f 1456 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @144F memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1452 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x143f label_1457: // Incoming jump from 0x1447, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1447, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @145C stack[-6] // @145C stack[-5] // @145E stack[-7] // } 1457 5B JUMPDEST 1458 50 POP 1459 50 POP 145A 50 POP 145B 50 POP 145C 90 SWAP1 145D 50 POP 145E 90 SWAP1 145F 81 DUP2 1460 01 ADD 1461 90 SWAP1 1462 60 PUSH1 0x1f 1464 16 AND 1465 80 DUP1 1466 15 ISZERO 1467 61 PUSH2 0x1484 146A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1461 stack[-7] = stack[-5] + stack[-7] // @1464 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1484, if !(0x1f & stack[-5]) label_146B: // Incoming jump from 0x146A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @146B stack[-1] // @146C stack[-2] // @146F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @148C stack[-6] // @148C stack[-7] // @148F stack[-8] // } 146B 80 DUP1 146C 82 DUP3 146D 03 SUB 146E 80 DUP1 146F 51 MLOAD 1470 60 PUSH1 0x01 1472 83 DUP4 1473 60 PUSH1 0x20 1475 03 SUB 1476 61 PUSH2 0x0100 1479 0A EXP 147A 03 SUB 147B 19 NOT 147C 16 AND 147D 81 DUP2 147E 52 MSTORE 147F 60 PUSH1 0x20 1481 01 ADD 1482 91 SWAP2 1483 50 POP 1484 5B JUMPDEST 1485 50 POP 1486 60 PUSH1 0x40 1488 52 MSTORE 1489 50 POP 148A 50 POP 148B 50 POP 148C 90 SWAP1 148D 50 POP 148E 5B JUMPDEST 148F 90 SWAP1 1490 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @147E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1488 memory[0x40:0x60] = 0x20 + (stack[-2] - stack[-1]) // @148F stack[-8] = stack[-6] // } // Block ends with unconditional jump to stack[-8] label_1491: // Incoming jump from 0x0488 // Inputs[1] { @1494 storage[0x97] } 1491 5B JUMPDEST 1492 60 PUSH1 0x97 1494 54 SLOAD 1495 60 PUSH1 0x00 1497 90 SWAP1 1498 60 PUSH1 0x01 149A 60 PUSH1 0x01 149C 60 PUSH1 0xa0 149E 1B SHL 149F 03 SUB 14A0 16 AND 14A1 61 PUSH2 0x14da 14A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1497 stack[0] = 0x00 } // Block ends with conditional jump to 0x14da, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_14A5: // Incoming jump from 0x14A4, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @14A8 memory[0x40:0x60] // @14D0 memory[0x40:0x60] // @14D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 14A5 60 PUSH1 0x40 14A7 80 DUP1 14A8 51 MLOAD 14A9 62 PUSH3 0x461bcd 14AD 60 PUSH1 0xe5 14AF 1B SHL 14B0 81 DUP2 14B1 52 MSTORE 14B2 60 PUSH1 0x20 14B4 60 PUSH1 0x04 14B6 80 DUP1 14B7 83 DUP4 14B8 01 ADD 14B9 91 SWAP2 14BA 90 SWAP1 14BB 91 SWAP2 14BC 52 MSTORE 14BD 60 PUSH1 0x24 14BF 82 DUP3 14C0 01 ADD 14C1 52 MSTORE 14C2 63 PUSH4 0x50523031 14C7 60 PUSH1 0xe0 14C9 1B SHL 14CA 60 PUSH1 0x44 14CC 82 DUP3 14CD 01 ADD 14CE 52 MSTORE 14CF 90 SWAP1 14D0 51 MLOAD 14D1 90 SWAP1 14D2 81 DUP2 14D3 90 SWAP1 14D4 03 SUB 14D5 60 PUSH1 0x64 14D7 01 ADD 14D8 90 SWAP1 14D9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @14B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14BC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14C1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @14CE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @14D9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_14DA: // Incoming jump from 0x14A4, if (0x01 << 0xa0) - 0x01 & storage[0x97] 14DA 5B JUMPDEST 14DB 61 PUSH2 0x14ec 14DE 61 PUSH2 0x14e5 14E1 61 PUSH2 0x4380 14E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14DB stack[0] = 0x14ec // @14DE stack[1] = 0x14e5 // } // Block ends with call to 0x4380, returns to 0x14E5 label_14E5: // Incoming return from call to 0x4380 at 0x14E4 // Inputs[2] // { // @14E6 stack[-5] // @14E7 stack[-4] // } 14E5 5B JUMPDEST 14E6 84 DUP5 14E7 84 DUP5 14E8 61 PUSH2 0x4384 14EB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14E6 stack[0] = stack[-5] // @14E7 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x4384 label_14EC: // Incoming return from call to 0x14E5 at 0x14E4 14EC 5B JUMPDEST 14ED 50 POP 14EE 60 PUSH1 0x01 // Stack delta = +0 // Outputs[1] { @14EE stack[-1] = 0x01 } // Block continues label_14F0: // Incoming return from call to 0x4440 at 0x437A // Incoming jump from 0x4AF4 // Incoming return from call to 0x4440 at 0x20E2 // Incoming return from call to 0x4440 at 0x1508 // Incoming jump from 0x14EE // Incoming return from call to 0x4440 at 0x3AAF // Inputs[3] // { // @14F1 stack[-4] // @14F1 stack[-1] // @14F2 stack[-3] // } 14F0 5B JUMPDEST 14F1 92 SWAP3 14F2 91 SWAP2 14F3 50 POP 14F4 50 POP 14F5 56 *JUMP // Stack delta = -3 // Outputs[1] { @14F1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_14F6: // Incoming jump from 0x04C2 // Incoming jump from 0x1541 // Inputs[1] { @14FE stack[-1] } 14F6 5B JUMPDEST 14F7 60 PUSH1 0x00 14F9 61 PUSH2 0x14f0 14FC 60 PUSH1 0x98 14FE 83 DUP4 14FF 63 PUSH4 0xffffffff 1504 61 PUSH2 0x4440 1507 16 AND 1508 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @14F7 stack[0] = 0x00 // @14F9 stack[1] = 0x14f0 // @14FC stack[2] = 0x98 // @14FE stack[3] = stack[-1] // } // Block ends with call to 0x4440 & 0xffffffff, returns to 0x14F0 label_1509: // Incoming jump from 0x04E8 1509 5B JUMPDEST 150A 61 PUSH2 0x1511 150D 61 PUSH2 0x4380 1510 56 *JUMP // Stack delta = +1 // Outputs[1] { @150A stack[0] = 0x1511 } // Block ends with call to 0x4380, returns to 0x1511 label_1511: // Incoming return from call to 0x4380 at 0x1510 // Inputs[1] { @151A stack[-1] } 1511 5B JUMPDEST 1512 60 PUSH1 0x01 1514 60 PUSH1 0x01 1516 60 PUSH1 0xa0 1518 1B SHL 1519 03 SUB 151A 16 AND 151B 61 PUSH2 0x1522 151E 61 PUSH2 0x2daa 1521 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @151A stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @151B stack[0] = 0x1522 // } // Block ends with call to 0x2daa, returns to 0x1522 label_1522: // Incoming return from call to 0x2DAA at 0x1521 // Inputs[2] // { // @152B stack[-1] // @152C stack[-2] // } 1522 5B JUMPDEST 1523 60 PUSH1 0x01 1525 60 PUSH1 0x01 1527 60 PUSH1 0xa0 1529 1B SHL 152A 03 SUB 152B 16 AND 152C 14 EQ 152D 80 DUP1 152E 61 PUSH2 0x1542 1531 57 *JUMPI // Stack delta = -1 // Outputs[1] { @152C stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x1542, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1532: // Incoming jump from 0x1531, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 1532 50 POP 1533 61 PUSH2 0x1542 1536 61 PUSH2 0x153d 1539 61 PUSH2 0x4380 153C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1533 stack[-1] = 0x1542 // @1536 stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_153D: // Incoming return from call to 0x4380 at 0x153C // Incoming return from call to 0x4380 at 0x189B // Incoming return from call to 0x4380 at 0x2331 // Incoming return from call to 0x4380 at 0x2020 // Incoming return from call to 0x4380 at 0x32B4 // Incoming return from call to 0x4380 at 0x2C51 // Incoming return from call to 0x4380 at 0x2EA7 // Incoming return from call to 0x4380 at 0x2279 // Incoming return from call to 0x4380 at 0x171C // Incoming return from call to 0x4380 at 0x2B71 // Incoming return from call to 0x4380 at 0x3D66 // Incoming return from call to 0x4380 at 0x1DE2 153D 5B JUMPDEST 153E 61 PUSH2 0x14f6 1541 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14f6 label_1542: // Incoming jump from 0x1531, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1546 stack[-1] } 1542 5B JUMPDEST 1543 61 PUSH2 0x157c 1546 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x157c, if stack[-1] label_1547: // Incoming jump from 0x1546, if not stack[-1] // Inputs[3] // { // @154A memory[0x40:0x60] // @1572 memory[0x40:0x60] // @157B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1547 60 PUSH1 0x40 1549 80 DUP1 154A 51 MLOAD 154B 62 PUSH3 0x461bcd 154F 60 PUSH1 0xe5 1551 1B SHL 1552 81 DUP2 1553 52 MSTORE 1554 60 PUSH1 0x20 1556 60 PUSH1 0x04 1558 80 DUP1 1559 83 DUP4 155A 01 ADD 155B 91 SWAP2 155C 90 SWAP1 155D 91 SWAP2 155E 52 MSTORE 155F 60 PUSH1 0x24 1561 82 DUP3 1562 01 ADD 1563 52 MSTORE 1564 63 PUSH4 0x41443031 1569 60 PUSH1 0xe0 156B 1B SHL 156C 60 PUSH1 0x44 156E 82 DUP3 156F 01 ADD 1570 52 MSTORE 1571 90 SWAP1 1572 51 MLOAD 1573 90 SWAP1 1574 81 DUP2 1575 90 SWAP1 1576 03 SUB 1577 60 PUSH1 0x64 1579 01 ADD 157A 90 SWAP1 157B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1553 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @155E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1563 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1570 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @157B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_157C: // Incoming jump from 0x1546, if stack[-1] // Inputs[1] { @1583 stack[-1] } 157C 5B JUMPDEST 157D 61 PUSH2 0x158e 1580 61 PUSH2 0x0101 1583 82 DUP3 1584 63 PUSH4 0xffffffff 1589 61 PUSH2 0x44a7 158C 16 AND 158D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @157D stack[0] = 0x158e // @1580 stack[1] = 0x0101 // @1583 stack[2] = stack[-1] // } // Block ends with call to 0x44a7 & 0xffffffff, returns to 0x158E label_158E: // Incoming return from call to 0x44A7 at 0x158D // Inputs[4] // { // @1591 memory[0x40:0x60] // @159A stack[-1] // @15C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @15C4 stack[-2] // } 158E 5B JUMPDEST 158F 60 PUSH1 0x40 1591 51 MLOAD 1592 60 PUSH1 0x01 1594 60 PUSH1 0x01 1596 60 PUSH1 0xa0 1598 1B SHL 1599 03 SUB 159A 82 DUP3 159B 16 AND 159C 90 SWAP1 159D 7F PUSH32 0x278a641d7aa9abcb166cd13a30fc6d7f21034d4c003ce509a84214e11faa77c0 15BE 90 SWAP1 15BF 60 PUSH1 0x00 15C1 90 SWAP1 15C2 A2 LOG2 15C3 50 POP 15C4 56 *JUMP // Stack delta = -2 // Outputs[1] { @15C2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x278a641d7aa9abcb166cd13a30fc6d7f21034d4c003ce509a84214e11faa77c0, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_15C5: // Incoming jump from 0x0516 // Inputs[6] // { // @15D0 stack[-2] // @15D7 memory[0x00:0x40] // @15DB stack[-1] // @15DF memory[0x00:0x40] // @15E0 storage[keccak256(memory[0x00:0x40])] // @15E4 stack[-3] // } 15C5 5B JUMPDEST 15C6 61 PUSH2 0x0107 15C9 60 PUSH1 0x20 15CB 90 SWAP1 15CC 81 DUP2 15CD 52 MSTORE 15CE 60 PUSH1 0x00 15D0 92 SWAP3 15D1 83 DUP4 15D2 52 MSTORE 15D3 60 PUSH1 0x40 15D5 80 DUP1 15D6 84 DUP5 15D7 20 SHA3 15D8 90 SWAP1 15D9 91 SWAP2 15DA 52 MSTORE 15DB 90 SWAP1 15DC 82 DUP3 15DD 52 MSTORE 15DE 90 SWAP1 15DF 20 SHA3 15E0 54 SLOAD 15E1 60 PUSH1 0xff 15E3 16 AND 15E4 81 DUP2 15E5 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @15CD memory[0x20:0x40] = 0x0107 // @15D2 memory[0x00:0x20] = stack[-2] // @15DA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @15DD memory[0x00:0x20] = stack[-1] // @15E3 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_15E6: // Incoming call from 0x0542, returns to 0x0543 // Inputs[1] { @1608 stack[-1] } 15E6 5B JUMPDEST 15E7 7F PUSH32 0x808c10407a796f3ef2c7ea38c0638ea9d2b8a1c63e3ca9e1f56ce84ae59df73c 1608 81 DUP2 1609 56 *JUMP // Stack delta = +1 // Outputs[1] { @15E7 stack[0] = 0x808c10407a796f3ef2c7ea38c0638ea9d2b8a1c63e3ca9e1f56ce84ae59df73c } // Block ends with unconditional jump to stack[-1] label_160A: // Incoming jump from 0x0612 // Inputs[1] { @160D storage[0x97] } 160A 5B JUMPDEST 160B 60 PUSH1 0x97 160D 54 SLOAD 160E 60 PUSH1 0x01 1610 60 PUSH1 0x01 1612 60 PUSH1 0xa0 1614 1B SHL 1615 03 SUB 1616 16 AND 1617 61 PUSH2 0x1650 161A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1650, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_161B: // Incoming jump from 0x161A, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @161E memory[0x40:0x60] // @1646 memory[0x40:0x60] // @164F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 161B 60 PUSH1 0x40 161D 80 DUP1 161E 51 MLOAD 161F 62 PUSH3 0x461bcd 1623 60 PUSH1 0xe5 1625 1B SHL 1626 81 DUP2 1627 52 MSTORE 1628 60 PUSH1 0x20 162A 60 PUSH1 0x04 162C 80 DUP1 162D 83 DUP4 162E 01 ADD 162F 91 SWAP2 1630 90 SWAP1 1631 91 SWAP2 1632 52 MSTORE 1633 60 PUSH1 0x24 1635 82 DUP3 1636 01 ADD 1637 52 MSTORE 1638 63 PUSH4 0x50523031 163D 60 PUSH1 0xe0 163F 1B SHL 1640 60 PUSH1 0x44 1642 82 DUP3 1643 01 ADD 1644 52 MSTORE 1645 90 SWAP1 1646 51 MLOAD 1647 90 SWAP1 1648 81 DUP2 1649 90 SWAP1 164A 03 SUB 164B 60 PUSH1 0x64 164D 01 ADD 164E 90 SWAP1 164F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1627 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1632 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1637 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1644 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @164F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1650: // Incoming jump from 0x161A, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[2] // { // @1651 stack[-3] // @1652 stack[-1] // } 1650 5B JUMPDEST 1651 82 DUP3 1652 81 DUP2 1653 14 EQ 1654 61 PUSH2 0x168d 1657 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x168d, if stack[-1] == stack[-3] label_1658: // Incoming jump from 0x1657, if not stack[-1] == stack[-3] // Inputs[3] // { // @165B memory[0x40:0x60] // @1683 memory[0x40:0x60] // @168C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1658 60 PUSH1 0x40 165A 80 DUP1 165B 51 MLOAD 165C 62 PUSH3 0x461bcd 1660 60 PUSH1 0xe5 1662 1B SHL 1663 81 DUP2 1664 52 MSTORE 1665 60 PUSH1 0x20 1667 60 PUSH1 0x04 1669 80 DUP1 166A 83 DUP4 166B 01 ADD 166C 91 SWAP2 166D 90 SWAP1 166E 91 SWAP2 166F 52 MSTORE 1670 60 PUSH1 0x24 1672 82 DUP3 1673 01 ADD 1674 52 MSTORE 1675 63 PUSH4 0x424b3031 167A 60 PUSH1 0xe0 167C 1B SHL 167D 60 PUSH1 0x44 167F 82 DUP3 1680 01 ADD 1681 52 MSTORE 1682 90 SWAP1 1683 51 MLOAD 1684 90 SWAP1 1685 81 DUP2 1686 90 SWAP1 1687 03 SUB 1688 60 PUSH1 0x64 168A 01 ADD 168B 90 SWAP1 168C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1664 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @166F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1674 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1681 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x424b3031 << 0xe0 // @168C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_168D: // Incoming jump from 0x1657, if stack[-1] == stack[-3] // Inputs[1] { @1691 stack[-3] } 168D 5B JUMPDEST 168E 60 PUSH1 0x00 1690 5B JUMPDEST 1691 83 DUP4 1692 81 DUP2 1693 10 LT 1694 15 ISZERO 1695 61 PUSH2 0x16e2 1698 57 *JUMPI // Stack delta = +1 // Outputs[1] { @168E stack[0] = 0x00 } // Block ends with conditional jump to 0x16e2, if !(0x00 < stack[-3]) label_1699: // Incoming jump from 0x1698, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1698, if not !(0x00 < stack[-3]) 1699 61 PUSH2 0x16d7 169C 61 PUSH2 0x16a3 169F 61 PUSH2 0x4380 16A2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1699 stack[0] = 0x16d7 // @169C stack[1] = 0x16a3 // } // Block ends with call to 0x4380, returns to 0x16A3 label_16A3: // Incoming return from call to 0x4380 at 0x16A2 // Inputs[3] // { // @16A4 stack[-7] // @16A5 stack[-6] // @16A6 stack[-3] // } 16A3 5B JUMPDEST 16A4 86 DUP7 16A5 86 DUP7 16A6 84 DUP5 16A7 81 DUP2 16A8 81 DUP2 16A9 10 LT 16AA 61 PUSH2 0x16af 16AD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @16A4 stack[0] = stack[-7] // @16A5 stack[1] = stack[-6] // @16A6 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x16af, if stack[-3] < stack[-6] label_16AE: // Incoming jump from 0x16AD, if not stack[-3] < stack[-6] 16AE FE *ASSERT // Stack delta = +0 // Outputs[1] { @16AE assert(); } // Block terminates label_16AF: // Incoming jump from 0x16AD, if stack[-3] < stack[-6] // Inputs[7] // { // @16B0 stack[-2] // @16B0 stack[-1] // @16B5 stack[-3] // @16B6 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @16C0 stack[-8] // @16C1 stack[-7] // @16C2 stack[-6] // } 16AF 5B JUMPDEST 16B0 90 SWAP1 16B1 50 POP 16B2 60 PUSH1 0x20 16B4 02 MUL 16B5 01 ADD 16B6 35 CALLDATALOAD 16B7 60 PUSH1 0x01 16B9 60 PUSH1 0x01 16BB 60 PUSH1 0xa0 16BD 1B SHL 16BE 03 SUB 16BF 16 AND 16C0 85 DUP6 16C1 85 DUP6 16C2 85 DUP6 16C3 81 DUP2 16C4 81 DUP2 16C5 10 LT 16C6 61 PUSH2 0x16cb 16C9 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @16BF stack[-3] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @16C0 stack[-2] = stack[-8] // @16C1 stack[-1] = stack[-7] // @16C2 stack[0] = stack[-6] // } // Block ends with conditional jump to 0x16cb, if stack[-6] < stack[-7] label_16CA: // Incoming jump from 0x16C9, if not stack[-6] < stack[-7] 16CA FE *ASSERT // Stack delta = +0 // Outputs[1] { @16CA assert(); } // Block terminates label_16CB: // Incoming jump from 0x16C9, if stack[-6] < stack[-7] // Incoming jump from 0x36CC, if stack[-9] < stack[-12] // Inputs[4] // { // @16CC stack[-2] // @16CC stack[-1] // @16D1 stack[-3] // @16D2 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 16CB 5B JUMPDEST 16CC 90 SWAP1 16CD 50 POP 16CE 60 PUSH1 0x20 16D0 02 MUL 16D1 01 ADD 16D2 35 CALLDATALOAD 16D3 61 PUSH2 0x450e 16D6 56 *JUMP // Stack delta = -2 // Outputs[1] { @16D2 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x450e label_16D7: // Incoming return from call to 0x16A3 at 0x16A2 // Inputs[1] { @16DD stack[-4] } 16D7 5B JUMPDEST 16D8 50 POP 16D9 50 POP 16DA 50 POP 16DB 60 PUSH1 0x01 16DD 01 ADD 16DE 61 PUSH2 0x1690 16E1 56 *JUMP // Stack delta = -3 // Outputs[1] { @16DD stack[-4] = 0x01 + stack[-4] } // Block ends with unconditional jump to 0x1690 label_16E2: // Incoming jump from 0x1698, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1698, if !(0x00 < stack[-3]) // Inputs[1] { @16E8 stack[-6] } 16E2 5B JUMPDEST 16E3 50 POP 16E4 50 POP 16E5 50 POP 16E6 50 POP 16E7 50 POP 16E8 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_16E9: // Incoming jump from 0x0638 16E9 5B JUMPDEST 16EA 61 PUSH2 0x16f1 16ED 61 PUSH2 0x4380 16F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @16EA stack[0] = 0x16f1 } // Block ends with call to 0x4380, returns to 0x16F1 label_16F1: // Incoming return from call to 0x4380 at 0x16F0 // Inputs[1] { @16FA stack[-1] } 16F1 5B JUMPDEST 16F2 60 PUSH1 0x01 16F4 60 PUSH1 0x01 16F6 60 PUSH1 0xa0 16F8 1B SHL 16F9 03 SUB 16FA 16 AND 16FB 61 PUSH2 0x1702 16FE 61 PUSH2 0x2daa 1701 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @16FA stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @16FB stack[0] = 0x1702 // } // Block ends with call to 0x2daa, returns to 0x1702 label_1702: // Incoming return from call to 0x2DAA at 0x1701 // Inputs[2] // { // @170B stack[-1] // @170C stack[-2] // } 1702 5B JUMPDEST 1703 60 PUSH1 0x01 1705 60 PUSH1 0x01 1707 60 PUSH1 0xa0 1709 1B SHL 170A 03 SUB 170B 16 AND 170C 14 EQ 170D 80 DUP1 170E 61 PUSH2 0x171d 1711 57 *JUMPI // Stack delta = -1 // Outputs[1] { @170C stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x171d, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1712: // Incoming jump from 0x1711, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 1712 50 POP 1713 61 PUSH2 0x171d 1716 61 PUSH2 0x153d 1719 61 PUSH2 0x4380 171C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1713 stack[-1] = 0x171d // @1716 stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_171D: // Incoming jump from 0x1711, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1721 stack[-1] } 171D 5B JUMPDEST 171E 61 PUSH2 0x1757 1721 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1757, if stack[-1] label_1722: // Incoming jump from 0x1721, if not stack[-1] // Inputs[3] // { // @1725 memory[0x40:0x60] // @174D memory[0x40:0x60] // @1756 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1722 60 PUSH1 0x40 1724 80 DUP1 1725 51 MLOAD 1726 62 PUSH3 0x461bcd 172A 60 PUSH1 0xe5 172C 1B SHL 172D 81 DUP2 172E 52 MSTORE 172F 60 PUSH1 0x20 1731 60 PUSH1 0x04 1733 80 DUP1 1734 83 DUP4 1735 01 ADD 1736 91 SWAP2 1737 90 SWAP1 1738 91 SWAP2 1739 52 MSTORE 173A 60 PUSH1 0x24 173C 82 DUP3 173D 01 ADD 173E 52 MSTORE 173F 63 PUSH4 0x41443031 1744 60 PUSH1 0xe0 1746 1B SHL 1747 60 PUSH1 0x44 1749 82 DUP3 174A 01 ADD 174B 52 MSTORE 174C 90 SWAP1 174D 51 MLOAD 174E 90 SWAP1 174F 81 DUP2 1750 90 SWAP1 1751 03 SUB 1752 60 PUSH1 0x64 1754 01 ADD 1755 90 SWAP1 1756 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @172E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1739 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @173E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @174B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @1756 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1757: // Incoming jump from 0x1721, if stack[-1] // Inputs[1] { @175E stack[-1] } 1757 5B JUMPDEST 1758 61 PUSH2 0x1769 175B 61 PUSH2 0x0101 175E 82 DUP3 175F 63 PUSH4 0xffffffff 1764 61 PUSH2 0x45eb 1767 16 AND 1768 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1758 stack[0] = 0x1769 // @175B stack[1] = 0x0101 // @175E stack[2] = stack[-1] // } // Block ends with call to 0x45eb & 0xffffffff, returns to 0x1769 label_1769: // Incoming return from call to 0x45EB at 0x1768 // Inputs[4] // { // @176C memory[0x40:0x60] // @1775 stack[-1] // @179D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @179F stack[-2] // } 1769 5B JUMPDEST 176A 60 PUSH1 0x40 176C 51 MLOAD 176D 60 PUSH1 0x01 176F 60 PUSH1 0x01 1771 60 PUSH1 0xa0 1773 1B SHL 1774 03 SUB 1775 82 DUP3 1776 16 AND 1777 90 SWAP1 1778 7F PUSH32 0xa9f13e94f3f7dbf69ac8405e3aa6f43a6f162984687d099c7a5cd9b602552cc2 1799 90 SWAP1 179A 60 PUSH1 0x00 179C 90 SWAP1 179D A2 LOG2 179E 50 POP 179F 56 *JUMP // Stack delta = -2 // Outputs[1] { @179D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xa9f13e94f3f7dbf69ac8405e3aa6f43a6f162984687d099c7a5cd9b602552cc2, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_17A0: // Incoming call from 0x0640, returns to 0x0543 // Inputs[1] { @17A3 storage[0x97] } 17A0 5B JUMPDEST 17A1 60 PUSH1 0x97 17A3 54 SLOAD 17A4 60 PUSH1 0x00 17A6 90 SWAP1 17A7 60 PUSH1 0x01 17A9 60 PUSH1 0x01 17AB 60 PUSH1 0xa0 17AD 1B SHL 17AE 03 SUB 17AF 16 AND 17B0 61 PUSH2 0x17e9 17B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17A6 stack[0] = 0x00 } // Block ends with conditional jump to 0x17e9, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_17B4: // Incoming jump from 0x17B3, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @17B7 memory[0x40:0x60] // @17DF memory[0x40:0x60] // @17E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 17B4 60 PUSH1 0x40 17B6 80 DUP1 17B7 51 MLOAD 17B8 62 PUSH3 0x461bcd 17BC 60 PUSH1 0xe5 17BE 1B SHL 17BF 81 DUP2 17C0 52 MSTORE 17C1 60 PUSH1 0x20 17C3 60 PUSH1 0x04 17C5 80 DUP1 17C6 83 DUP4 17C7 01 ADD 17C8 91 SWAP2 17C9 90 SWAP1 17CA 91 SWAP2 17CB 52 MSTORE 17CC 60 PUSH1 0x24 17CE 82 DUP3 17CF 01 ADD 17D0 52 MSTORE 17D1 63 PUSH4 0x50523031 17D6 60 PUSH1 0xe0 17D8 1B SHL 17D9 60 PUSH1 0x44 17DB 82 DUP3 17DC 01 ADD 17DD 52 MSTORE 17DE 90 SWAP1 17DF 51 MLOAD 17E0 90 SWAP1 17E1 81 DUP2 17E2 90 SWAP1 17E3 03 SUB 17E4 60 PUSH1 0x64 17E6 01 ADD 17E7 90 SWAP1 17E8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @17C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17CB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @17D0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @17DD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @17E8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_17E9: // Incoming jump from 0x17B3, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @17EF storage[0x97] // @1810 memory[0x40:0x60] // @1824 memory[0x40:0x60] // @182B address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } 17E9 5B JUMPDEST 17EA 60 PUSH1 0x97 17EC 60 PUSH1 0x00 17EE 90 SWAP1 17EF 54 SLOAD 17F0 90 SWAP1 17F1 61 PUSH2 0x0100 17F4 0A EXP 17F5 90 SWAP1 17F6 04 DIV 17F7 60 PUSH1 0x01 17F9 60 PUSH1 0x01 17FB 60 PUSH1 0xa0 17FD 1B SHL 17FE 03 SUB 17FF 16 AND 1800 60 PUSH1 0x01 1802 60 PUSH1 0x01 1804 60 PUSH1 0xa0 1806 1B SHL 1807 03 SUB 1808 16 AND 1809 63 PUSH4 0x18160ddd 180E 60 PUSH1 0x40 1810 51 MLOAD 1811 81 DUP2 1812 63 PUSH4 0xffffffff 1817 16 AND 1818 60 PUSH1 0xe0 181A 1B SHL 181B 81 DUP2 181C 52 MSTORE 181D 60 PUSH1 0x04 181F 01 ADD 1820 60 PUSH1 0x20 1822 60 PUSH1 0x40 1824 51 MLOAD 1825 80 DUP1 1826 83 DUP4 1827 03 SUB 1828 81 DUP2 1829 86 DUP7 182A 80 DUP1 182B 3B EXTCODESIZE 182C 15 ISZERO 182D 80 DUP1 182E 15 ISZERO 182F 61 PUSH2 0x1837 1832 57 *JUMPI // Stack delta = +9 // Outputs[10] // { // @1808 stack[0] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @1809 stack[1] = 0x18160ddd // @181C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x18160ddd) << 0xe0 // @181F stack[2] = 0x04 + memory[0x40:0x60] // @1820 stack[3] = 0x20 // @1824 stack[4] = memory[0x40:0x60] // @1827 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1828 stack[6] = memory[0x40:0x60] // @1829 stack[7] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @182C stack[8] = !address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x1837, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length label_1833: // Incoming jump from 0x1832, if not !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Inputs[1] { @1836 memory[0x00:0x00] } 1833 60 PUSH1 0x00 1835 80 DUP1 1836 FD *REVERT // Stack delta = +0 // Outputs[1] { @1836 revert(memory[0x00:0x00]); } // Block terminates label_1837: // Incoming jump from 0x1832, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Incoming jump from 0x1D0C, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @1839 msg.gas // @183A stack[-6] // @183A memory[stack[-3]:stack[-3] + stack[-4]] // @183A stack[-4] // @183A stack[-5] // @183A address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @183A stack[-2] // @183A stack[-3] // } 1837 5B JUMPDEST 1838 50 POP 1839 5A GAS 183A FA STATICCALL 183B 15 ISZERO 183C 80 DUP1 183D 15 ISZERO 183E 61 PUSH2 0x184b 1841 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @183A memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @183B stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x184b, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1842: // Incoming jump from 0x1841, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1842 returndata.length // @1846 returndata[0x00:0x00 + returndata.length] // @1847 returndata.length // @184A memory[0x00:0x00 + returndata.length] // } 1842 3D RETURNDATASIZE 1843 60 PUSH1 0x00 1845 80 DUP1 1846 3E RETURNDATACOPY 1847 3D RETURNDATASIZE 1848 60 PUSH1 0x00 184A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1846 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @184A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_184B: // Incoming jump from 0x1841, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1852 memory[0x40:0x60] // @1853 returndata.length // } 184B 5B JUMPDEST 184C 50 POP 184D 50 POP 184E 50 POP 184F 50 POP 1850 60 PUSH1 0x40 1852 51 MLOAD 1853 3D RETURNDATASIZE 1854 60 PUSH1 0x20 1856 81 DUP2 1857 10 LT 1858 15 ISZERO 1859 61 PUSH2 0x1861 185C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1852 stack[-4] = memory[0x40:0x60] // @1853 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1861, if !(returndata.length < 0x20) label_185D: // Incoming jump from 0x185C, if not !(returndata.length < 0x20) // Inputs[1] { @1860 memory[0x00:0x00] } 185D 60 PUSH1 0x00 185F 80 DUP1 1860 FD *REVERT // Stack delta = +0 // Outputs[1] { @1860 revert(memory[0x00:0x00]); } // Block terminates label_1861: // Incoming jump from 0x185C, if !(returndata.length < 0x20) // Inputs[4] // { // @1863 memory[stack[-2]:stack[-2] + 0x20] // @1863 stack[-2] // @1864 stack[-3] // @1866 stack[-4] // } 1861 5B JUMPDEST 1862 50 POP 1863 51 MLOAD 1864 90 SWAP1 1865 50 POP 1866 90 SWAP1 1867 56 *JUMP // Stack delta = -3 // Outputs[1] { @1866 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1868: // Incoming jump from 0x0666 1868 5B JUMPDEST 1869 61 PUSH2 0x1870 186C 61 PUSH2 0x4380 186F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1869 stack[0] = 0x1870 } // Block ends with call to 0x4380, returns to 0x1870 label_1870: // Incoming return from call to 0x4380 at 0x186F // Inputs[1] { @1879 stack[-1] } 1870 5B JUMPDEST 1871 60 PUSH1 0x01 1873 60 PUSH1 0x01 1875 60 PUSH1 0xa0 1877 1B SHL 1878 03 SUB 1879 16 AND 187A 61 PUSH2 0x1881 187D 61 PUSH2 0x2daa 1880 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1879 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @187A stack[0] = 0x1881 // } // Block ends with call to 0x2daa, returns to 0x1881 label_1881: // Incoming return from call to 0x2DAA at 0x1880 // Inputs[2] // { // @188A stack[-1] // @188B stack[-2] // } 1881 5B JUMPDEST 1882 60 PUSH1 0x01 1884 60 PUSH1 0x01 1886 60 PUSH1 0xa0 1888 1B SHL 1889 03 SUB 188A 16 AND 188B 14 EQ 188C 80 DUP1 188D 61 PUSH2 0x189c 1890 57 *JUMPI // Stack delta = -1 // Outputs[1] { @188B stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x189c, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1891: // Incoming jump from 0x1890, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 1891 50 POP 1892 61 PUSH2 0x189c 1895 61 PUSH2 0x153d 1898 61 PUSH2 0x4380 189B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1892 stack[-1] = 0x189c // @1895 stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_189C: // Incoming jump from 0x1890, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @18A0 stack[-1] } 189C 5B JUMPDEST 189D 61 PUSH2 0x18d6 18A0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18d6, if stack[-1] label_18A1: // Incoming jump from 0x18A0, if not stack[-1] // Inputs[3] // { // @18A4 memory[0x40:0x60] // @18CC memory[0x40:0x60] // @18D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 18A1 60 PUSH1 0x40 18A3 80 DUP1 18A4 51 MLOAD 18A5 62 PUSH3 0x461bcd 18A9 60 PUSH1 0xe5 18AB 1B SHL 18AC 81 DUP2 18AD 52 MSTORE 18AE 60 PUSH1 0x20 18B0 60 PUSH1 0x04 18B2 80 DUP1 18B3 83 DUP4 18B4 01 ADD 18B5 91 SWAP2 18B6 90 SWAP1 18B7 91 SWAP2 18B8 52 MSTORE 18B9 60 PUSH1 0x24 18BB 82 DUP3 18BC 01 ADD 18BD 52 MSTORE 18BE 63 PUSH4 0x41443031 18C3 60 PUSH1 0xe0 18C5 1B SHL 18C6 60 PUSH1 0x44 18C8 82 DUP3 18C9 01 ADD 18CA 52 MSTORE 18CB 90 SWAP1 18CC 51 MLOAD 18CD 90 SWAP1 18CE 81 DUP2 18CF 90 SWAP1 18D0 03 SUB 18D1 60 PUSH1 0x64 18D3 01 ADD 18D4 90 SWAP1 18D5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @18AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18B8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18BD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @18CA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @18D5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_18D6: // Incoming jump from 0x18A0, if stack[-1] // Inputs[1] { @18DC stack[-1] } 18D6 5B JUMPDEST 18D7 61 PUSH2 0x18e7 18DA 60 PUSH1 0xcf 18DC 82 DUP3 18DD 63 PUSH4 0xffffffff 18E2 61 PUSH2 0x44a7 18E5 16 AND 18E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18D7 stack[0] = 0x18e7 // @18DA stack[1] = 0xcf // @18DC stack[2] = stack[-1] // } // Block ends with call to 0x44a7 & 0xffffffff, returns to 0x18E7 label_18E7: // Incoming return from call to 0x44A7 at 0x18E6 // Inputs[4] // { // @18EA memory[0x40:0x60] // @18F3 stack[-1] // @191B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @191D stack[-2] // } 18E7 5B JUMPDEST 18E8 60 PUSH1 0x40 18EA 51 MLOAD 18EB 60 PUSH1 0x01 18ED 60 PUSH1 0x01 18EF 60 PUSH1 0xa0 18F1 1B SHL 18F2 03 SUB 18F3 82 DUP3 18F4 16 AND 18F5 90 SWAP1 18F6 7F PUSH32 0xa7f68f710154f785d34ef4848d515daaf136408524b79a717c82015f9e71fd04 1917 90 SWAP1 1918 60 PUSH1 0x00 191A 90 SWAP1 191B A2 LOG2 191C 50 POP 191D 56 *JUMP // Stack delta = -2 // Outputs[1] { @191B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xa7f68f710154f785d34ef4848d515daaf136408524b79a717c82015f9e71fd04, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_191E: // Incoming jump from 0x06C5 // Inputs[1] { @1921 storage[0x97] } 191E 5B JUMPDEST 191F 60 PUSH1 0x97 1921 54 SLOAD 1922 60 PUSH1 0x01 1924 60 PUSH1 0x01 1926 60 PUSH1 0xa0 1928 1B SHL 1929 03 SUB 192A 16 AND 192B 61 PUSH2 0x1964 192E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1964, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_192F: // Incoming jump from 0x192E, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @1932 memory[0x40:0x60] // @195A memory[0x40:0x60] // @1963 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 192F 60 PUSH1 0x40 1931 80 DUP1 1932 51 MLOAD 1933 62 PUSH3 0x461bcd 1937 60 PUSH1 0xe5 1939 1B SHL 193A 81 DUP2 193B 52 MSTORE 193C 60 PUSH1 0x20 193E 60 PUSH1 0x04 1940 80 DUP1 1941 83 DUP4 1942 01 ADD 1943 91 SWAP2 1944 90 SWAP1 1945 91 SWAP2 1946 52 MSTORE 1947 60 PUSH1 0x24 1949 82 DUP3 194A 01 ADD 194B 52 MSTORE 194C 63 PUSH4 0x50523031 1951 60 PUSH1 0xe0 1953 1B SHL 1954 60 PUSH1 0x44 1956 82 DUP3 1957 01 ADD 1958 52 MSTORE 1959 90 SWAP1 195A 51 MLOAD 195B 90 SWAP1 195C 81 DUP2 195D 90 SWAP1 195E 03 SUB 195F 60 PUSH1 0x64 1961 01 ADD 1962 90 SWAP1 1963 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @193B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1946 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @194B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1958 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @1963 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1964: // Incoming jump from 0x192E, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @1968 stack[-9] // @1969 stack[-4] // @196A stack[-6] // @196B stack[-5] // } 1964 5B JUMPDEST 1965 61 PUSH2 0x1970 1968 89 DUP10 1969 85 DUP6 196A 88 DUP9 196B 88 DUP9 196C 61 PUSH2 0x466c 196F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1965 stack[0] = 0x1970 // @1968 stack[1] = stack[-9] // @1969 stack[2] = stack[-4] // @196A stack[3] = stack[-6] // @196B stack[4] = stack[-5] // } // Block ends with call to 0x466c, returns to 0x1970 label_1970: // Incoming return from call to 0x466C at 0x196F // Inputs[12] // { // @1974 memory[0x40:0x60] // @19A4 stack[-9] // @19AD stack[-8] // @19B8 stack[-7] // @19BF stack[-6] // @19C6 stack[-5] // @19CE stack[-4] // @19D2 memory[0x40:0x60] // @19E7 storage[0x0105] // @19EF stack[-3] // @19F0 stack[-2] // @19F1 stack[-1] // } 1970 5B JUMPDEST 1971 60 PUSH1 0x40 1973 80 DUP1 1974 51 MLOAD 1975 7F PUSH32 0x604bdf0208a879f7d9fa63ff2f539804aaf6f7876eaa13d531bdc957f1c0284f 1996 60 PUSH1 0x20 1998 82 DUP3 1999 01 ADD 199A 52 MSTORE 199B 60 PUSH1 0x01 199D 60 PUSH1 0x01 199F 60 PUSH1 0xa0 19A1 1B SHL 19A2 03 SUB 19A3 80 DUP1 19A4 8C DUP13 19A5 16 AND 19A6 82 DUP3 19A7 84 DUP5 19A8 01 ADD 19A9 81 DUP2 19AA 90 SWAP1 19AB 52 MSTORE 19AC 90 SWAP1 19AD 8B DUP12 19AE 16 AND 19AF 60 PUSH1 0x60 19B1 83 DUP4 19B2 01 ADD 19B3 52 MSTORE 19B4 60 PUSH1 0x80 19B6 82 DUP3 19B7 01 ADD 19B8 8A DUP11 19B9 90 SWAP1 19BA 52 MSTORE 19BB 60 PUSH1 0xa0 19BD 82 DUP3 19BE 01 ADD 19BF 89 DUP10 19C0 90 SWAP1 19C1 52 MSTORE 19C2 60 PUSH1 0xc0 19C4 82 DUP3 19C5 01 ADD 19C6 88 DUP9 19C7 90 SWAP1 19C8 52 MSTORE 19C9 60 PUSH1 0xe0 19CB 80 DUP1 19CC 83 DUP4 19CD 01 ADD 19CE 88 DUP9 19CF 90 SWAP1 19D0 52 MSTORE 19D1 83 DUP4 19D2 51 MLOAD 19D3 80 DUP1 19D4 84 DUP5 19D5 03 SUB 19D6 90 SWAP1 19D7 91 SWAP2 19D8 01 ADD 19D9 81 DUP2 19DA 52 MSTORE 19DB 61 PUSH2 0x0100 19DE 90 SWAP1 19DF 92 SWAP3 19E0 01 ADD 19E1 90 SWAP1 19E2 92 SWAP3 19E3 52 MSTORE 19E4 61 PUSH2 0x0105 19E7 54 SLOAD 19E8 90 SWAP1 19E9 91 SWAP2 19EA 90 SWAP1 19EB 61 PUSH2 0x19f7 19EE 90 SWAP1 19EF 86 DUP7 19F0 86 DUP7 19F1 86 DUP7 19F2 86 DUP7 19F3 61 PUSH2 0x46f6 19F6 56 *JUMP // Stack delta = +8 // Outputs[17] // { // @199A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x604bdf0208a879f7d9fa63ff2f539804aaf6f7876eaa13d531bdc957f1c0284f // @19AB memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @19B3 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @19BA memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-7] // @19C1 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-6] // @19C8 memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-5] // @19D0 memory[memory[0x40:0x60] + 0xe0:memory[0x40:0x60] + 0xe0 + 0x20] = stack[-4] // @19DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @19E3 memory[0x40:0x60] = memory[0x40:0x60] + 0x0100 // @19E9 stack[0] = memory[0x40:0x60] // @19EA stack[1] = stack[-9] & (0x01 << 0xa0) - 0x01 // @19EE stack[2] = 0x19f7 // @19EE stack[3] = storage[0x0105] // @19EF stack[4] = stack[-3] // @19F0 stack[5] = stack[-2] // @19F1 stack[6] = stack[-1] // @19F2 stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x46f6, returns to 0x19F7 label_19F7: // Incoming return from call to 0x46F6 at 0x19F6 // Inputs[2] // { // @1A00 stack[-1] // @1A01 stack[-2] // } 19F7 5B JUMPDEST 19F8 60 PUSH1 0x01 19FA 60 PUSH1 0x01 19FC 60 PUSH1 0xa0 19FE 1B SHL 19FF 03 SUB 1A00 16 AND 1A01 14 EQ 1A02 61 PUSH2 0x1a3b 1A05 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1a3b, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1A06: // Incoming jump from 0x1A05, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @1A09 memory[0x40:0x60] // @1A31 memory[0x40:0x60] // @1A3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1A06 60 PUSH1 0x40 1A08 80 DUP1 1A09 51 MLOAD 1A0A 62 PUSH3 0x461bcd 1A0E 60 PUSH1 0xe5 1A10 1B SHL 1A11 81 DUP2 1A12 52 MSTORE 1A13 60 PUSH1 0x20 1A15 60 PUSH1 0x04 1A17 80 DUP1 1A18 83 DUP4 1A19 01 ADD 1A1A 91 SWAP2 1A1B 90 SWAP1 1A1C 91 SWAP2 1A1D 52 MSTORE 1A1E 60 PUSH1 0x24 1A20 82 DUP3 1A21 01 ADD 1A22 52 MSTORE 1A23 63 PUSH4 0x53493031 1A28 60 PUSH1 0xe0 1A2A 1B SHL 1A2B 60 PUSH1 0x44 1A2D 82 DUP3 1A2E 01 ADD 1A2F 52 MSTORE 1A30 90 SWAP1 1A31 51 MLOAD 1A32 90 SWAP1 1A33 81 DUP2 1A34 90 SWAP1 1A35 03 SUB 1A36 60 PUSH1 0x64 1A38 01 ADD 1A39 90 SWAP1 1A3A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1A12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A1D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A22 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1A2F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53493031 << 0xe0 // @1A3A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1A3B: // Incoming jump from 0x1A05, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @1A3F stack[-10] // @1A40 stack[-5] // } 1A3B 5B JUMPDEST 1A3C 61 PUSH2 0x1a45 1A3F 8A DUP11 1A40 86 DUP7 1A41 61 PUSH2 0x474d 1A44 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A3C stack[0] = 0x1a45 // @1A3F stack[1] = stack[-10] // @1A40 stack[2] = stack[-5] // } // Block ends with call to 0x474d, returns to 0x1A45 label_1A45: // Incoming return from call to 0x474D at 0x1A44 // Inputs[3] // { // @1A49 stack[-10] // @1A4A stack[-9] // @1A4B stack[-8] // } 1A45 5B JUMPDEST 1A46 61 PUSH2 0x1a50 1A49 8A DUP11 1A4A 8A DUP11 1A4B 8A DUP11 1A4C 61 PUSH2 0x47a8 1A4F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A46 stack[0] = 0x1a50 // @1A49 stack[1] = stack[-10] // @1A4A stack[2] = stack[-9] // @1A4B stack[3] = stack[-8] // } // Block ends with call to 0x47a8, returns to 0x1A50 label_1A50: // Incoming return from call to 0x4384 at 0x3D32 // Incoming return from call to 0x4B3F at 0x31DE // Incoming return from call to 0x47A8 at 0x1A4F // Inputs[1] { @1A5B stack[-11] } 1A50 5B JUMPDEST 1A51 50 POP 1A52 50 POP 1A53 50 POP 1A54 50 POP 1A55 50 POP 1A56 50 POP 1A57 50 POP 1A58 50 POP 1A59 50 POP 1A5A 50 POP 1A5B 56 *JUMP // Stack delta = -11 // Block ends with unconditional jump to stack[-11] label_1A5C: // Incoming jump from 0x06FB // Inputs[1] { @1A5F storage[0x97] } 1A5C 5B JUMPDEST 1A5D 60 PUSH1 0x97 1A5F 54 SLOAD 1A60 60 PUSH1 0x00 1A62 90 SWAP1 1A63 60 PUSH1 0x01 1A65 60 PUSH1 0x01 1A67 60 PUSH1 0xa0 1A69 1B SHL 1A6A 03 SUB 1A6B 16 AND 1A6C 61 PUSH2 0x1aa5 1A6F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A62 stack[0] = 0x00 } // Block ends with conditional jump to 0x1aa5, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_1A70: // Incoming jump from 0x1A6F, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @1A73 memory[0x40:0x60] // @1A9B memory[0x40:0x60] // @1AA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1A70 60 PUSH1 0x40 1A72 80 DUP1 1A73 51 MLOAD 1A74 62 PUSH3 0x461bcd 1A78 60 PUSH1 0xe5 1A7A 1B SHL 1A7B 81 DUP2 1A7C 52 MSTORE 1A7D 60 PUSH1 0x20 1A7F 60 PUSH1 0x04 1A81 80 DUP1 1A82 83 DUP4 1A83 01 ADD 1A84 91 SWAP2 1A85 90 SWAP1 1A86 91 SWAP2 1A87 52 MSTORE 1A88 60 PUSH1 0x24 1A8A 82 DUP3 1A8B 01 ADD 1A8C 52 MSTORE 1A8D 63 PUSH4 0x50523031 1A92 60 PUSH1 0xe0 1A94 1B SHL 1A95 60 PUSH1 0x44 1A97 82 DUP3 1A98 01 ADD 1A99 52 MSTORE 1A9A 90 SWAP1 1A9B 51 MLOAD 1A9C 90 SWAP1 1A9D 81 DUP2 1A9E 90 SWAP1 1A9F 03 SUB 1AA0 60 PUSH1 0x64 1AA2 01 ADD 1AA3 90 SWAP1 1AA4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1A7C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A87 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A8C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1A99 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @1AA4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1AA5: // Incoming jump from 0x1A6F, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[2] // { // @1AA8 storage[0x97] // @1AB7 stack[-4] // } 1AA5 5B JUMPDEST 1AA6 60 PUSH1 0x97 1AA8 54 SLOAD 1AA9 60 PUSH1 0x01 1AAB 60 PUSH1 0x01 1AAD 60 PUSH1 0xa0 1AAF 1B SHL 1AB0 03 SUB 1AB1 16 AND 1AB2 63 PUSH4 0xdd62ed3e 1AB7 85 DUP6 1AB8 61 PUSH2 0x1abf 1ABB 61 PUSH2 0x4380 1ABE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AB1 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @1AB2 stack[1] = 0xdd62ed3e // @1AB7 stack[2] = stack[-4] // @1AB8 stack[3] = 0x1abf // } // Block ends with call to 0x4380, returns to 0x1ABF label_1ABF: // Incoming return from call to 0x4380 at 0x1ABE // Inputs[7] // { // @1AC2 memory[0x40:0x60] // @1AC3 stack[-3] // @1AD3 stack[-2] // @1AEB stack[-1] // @1B0B memory[0x40:0x60] // @1B10 stack[-4] // @1B12 address(stack[-4]).code.length // } 1ABF 5B JUMPDEST 1AC0 60 PUSH1 0x40 1AC2 51 MLOAD 1AC3 83 DUP4 1AC4 63 PUSH4 0xffffffff 1AC9 16 AND 1ACA 60 PUSH1 0xe0 1ACC 1B SHL 1ACD 81 DUP2 1ACE 52 MSTORE 1ACF 60 PUSH1 0x04 1AD1 01 ADD 1AD2 80 DUP1 1AD3 83 DUP4 1AD4 60 PUSH1 0x01 1AD6 60 PUSH1 0x01 1AD8 60 PUSH1 0xa0 1ADA 1B SHL 1ADB 03 SUB 1ADC 16 AND 1ADD 60 PUSH1 0x01 1ADF 60 PUSH1 0x01 1AE1 60 PUSH1 0xa0 1AE3 1B SHL 1AE4 03 SUB 1AE5 16 AND 1AE6 81 DUP2 1AE7 52 MSTORE 1AE8 60 PUSH1 0x20 1AEA 01 ADD 1AEB 82 DUP3 1AEC 60 PUSH1 0x01 1AEE 60 PUSH1 0x01 1AF0 60 PUSH1 0xa0 1AF2 1B SHL 1AF3 03 SUB 1AF4 16 AND 1AF5 60 PUSH1 0x01 1AF7 60 PUSH1 0x01 1AF9 60 PUSH1 0xa0 1AFB 1B SHL 1AFC 03 SUB 1AFD 16 AND 1AFE 81 DUP2 1AFF 52 MSTORE 1B00 60 PUSH1 0x20 1B02 01 ADD 1B03 92 SWAP3 1B04 50 POP 1B05 50 POP 1B06 50 POP 1B07 60 PUSH1 0x20 1B09 60 PUSH1 0x40 1B0B 51 MLOAD 1B0C 80 DUP1 1B0D 83 DUP4 1B0E 03 SUB 1B0F 81 DUP2 1B10 86 DUP7 1B11 80 DUP1 1B12 3B EXTCODESIZE 1B13 15 ISZERO 1B14 80 DUP1 1B15 15 ISZERO 1B16 61 PUSH2 0x1b1e 1B19 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @1ACE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-3]) << 0xe0 // @1AE7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-2] // @1AFF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-1] // @1B03 stack[-2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1B07 stack[-1] = 0x20 // @1B0B stack[0] = memory[0x40:0x60] // @1B0E stack[1] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1B0F stack[2] = memory[0x40:0x60] // @1B10 stack[3] = stack[-4] // @1B13 stack[4] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x1b1e, if !!address(stack[-4]).code.length label_1B1A: // Incoming jump from 0x1B19, if not !!address(stack[-4]).code.length // Inputs[1] { @1B1D memory[0x00:0x00] } 1B1A 60 PUSH1 0x00 1B1C 80 DUP1 1B1D FD *REVERT // Stack delta = +0 // Outputs[1] { @1B1D revert(memory[0x00:0x00]); } // Block terminates label_1B1E: // Incoming jump from 0x1B19, if !!address(stack[-4]).code.length // Inputs[8] // { // @1B20 msg.gas // @1B21 stack[-2] // @1B21 stack[-5] // @1B21 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1B21 memory[stack[-3]:stack[-3] + stack[-4]] // @1B21 stack[-4] // @1B21 stack[-3] // @1B21 stack[-6] // } 1B1E 5B JUMPDEST 1B1F 50 POP 1B20 5A GAS 1B21 FA STATICCALL 1B22 15 ISZERO 1B23 80 DUP1 1B24 15 ISZERO 1B25 61 PUSH2 0x1b32 1B28 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1B21 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1B22 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1b32, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1B29: // Incoming jump from 0x1B28, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1B29 returndata.length // @1B2D returndata[0x00:0x00 + returndata.length] // @1B2E returndata.length // @1B31 memory[0x00:0x00 + returndata.length] // } 1B29 3D RETURNDATASIZE 1B2A 60 PUSH1 0x00 1B2C 80 DUP1 1B2D 3E RETURNDATACOPY 1B2E 3D RETURNDATASIZE 1B2F 60 PUSH1 0x00 1B31 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B2D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1B31 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1B32: // Incoming jump from 0x1B28, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1B39 memory[0x40:0x60] // @1B3A returndata.length // } 1B32 5B JUMPDEST 1B33 50 POP 1B34 50 POP 1B35 50 POP 1B36 50 POP 1B37 60 PUSH1 0x40 1B39 51 MLOAD 1B3A 3D RETURNDATASIZE 1B3B 60 PUSH1 0x20 1B3D 81 DUP2 1B3E 10 LT 1B3F 15 ISZERO 1B40 61 PUSH2 0x1b48 1B43 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1B39 stack[-4] = memory[0x40:0x60] // @1B3A stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1b48, if !(returndata.length < 0x20) label_1B44: // Incoming jump from 0x1B43, if not !(returndata.length < 0x20) // Inputs[1] { @1B47 memory[0x00:0x00] } 1B44 60 PUSH1 0x00 1B46 80 DUP1 1B47 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B47 revert(memory[0x00:0x00]); } // Block terminates label_1B48: // Incoming jump from 0x1B43, if !(returndata.length < 0x20) // Inputs[3] // { // @1B4A stack[-2] // @1B4A memory[stack[-2]:stack[-2] + 0x20] // @1B4B stack[-4] // } 1B48 5B JUMPDEST 1B49 50 POP 1B4A 51 MLOAD 1B4B 82 DUP3 1B4C 11 GT 1B4D 15 ISZERO 1B4E 61 PUSH2 0x1b87 1B51 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1b87, if !(stack[-4] > memory[stack[-2]:stack[-2] + 0x20]) label_1B52: // Incoming jump from 0x1B51, if not !(stack[-4] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1B55 memory[0x40:0x60] // @1B7D memory[0x40:0x60] // @1B86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1B52 60 PUSH1 0x40 1B54 80 DUP1 1B55 51 MLOAD 1B56 62 PUSH3 0x461bcd 1B5A 60 PUSH1 0xe5 1B5C 1B SHL 1B5D 81 DUP2 1B5E 52 MSTORE 1B5F 60 PUSH1 0x20 1B61 60 PUSH1 0x04 1B63 80 DUP1 1B64 83 DUP4 1B65 01 ADD 1B66 91 SWAP2 1B67 90 SWAP1 1B68 91 SWAP2 1B69 52 MSTORE 1B6A 60 PUSH1 0x24 1B6C 82 DUP3 1B6D 01 ADD 1B6E 52 MSTORE 1B6F 63 PUSH4 0x414c3031 1B74 60 PUSH1 0xe0 1B76 1B SHL 1B77 60 PUSH1 0x44 1B79 82 DUP3 1B7A 01 ADD 1B7B 52 MSTORE 1B7C 90 SWAP1 1B7D 51 MLOAD 1B7E 90 SWAP1 1B7F 81 DUP2 1B80 90 SWAP1 1B81 03 SUB 1B82 60 PUSH1 0x64 1B84 01 ADD 1B85 90 SWAP1 1B86 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B69 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B6E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1B7B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x414c3031 << 0xe0 // @1B86 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1B87: // Incoming jump from 0x1B51, if !(stack[-4] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1B90 stack[-4] // @1B91 stack[-3] // @1B92 stack[-2] // } 1B87 5B JUMPDEST 1B88 60 PUSH1 0x00 1B8A 80 DUP1 1B8B 60 PUSH1 0x00 1B8D 61 PUSH2 0x1b97 1B90 87 DUP8 1B91 87 DUP8 1B92 87 DUP8 1B93 61 PUSH2 0x450e 1B96 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1B88 stack[0] = 0x00 // @1B8A stack[1] = 0x00 // @1B8B stack[2] = 0x00 // @1B8D stack[3] = 0x1b97 // @1B90 stack[4] = stack[-4] // @1B91 stack[5] = stack[-3] // @1B92 stack[6] = stack[-2] // } // Block ends with call to 0x450e, returns to 0x1B97 label_1B97: // Incoming return from call to 0x450E at 0x1B96 // Inputs[8] // { // @1B9A storage[0x97] // @1B9B stack[-3] // @1B9C stack[-6] // @1B9E stack[-1] // @1B9E stack[-2] // @1B9F stack[-5] // @1BA1 stack[-4] // @1BB1 stack[-10] // } 1B97 5B JUMPDEST 1B98 60 PUSH1 0x97 1B9A 54 SLOAD 1B9B 92 SWAP3 1B9C 95 SWAP6 1B9D 50 POP 1B9E 90 SWAP1 1B9F 93 SWAP4 1BA0 50 POP 1BA1 91 SWAP2 1BA2 50 POP 1BA3 60 PUSH1 0x01 1BA5 60 PUSH1 0x01 1BA7 60 PUSH1 0xa0 1BA9 1B SHL 1BAA 03 SUB 1BAB 16 AND 1BAC 63 PUSH4 0xf019c267 1BB1 88 DUP9 1BB2 61 PUSH2 0x1bb9 1BB5 61 PUSH2 0x4380 1BB8 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @1B9C stack[-6] = stack[-3] // @1B9F stack[-5] = stack[-2] // @1BA1 stack[-4] = stack[-1] // @1BAB stack[-3] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @1BAC stack[-2] = 0xf019c267 // @1BB1 stack[-1] = stack[-10] // @1BB2 stack[0] = 0x1bb9 // } // Block ends with call to 0x4380, returns to 0x1BB9 label_1BB9: // Incoming return from call to 0x4380 at 0x1BB8 // Inputs[8] // { // @1BBA stack[-5] // @1BBD memory[0x40:0x60] // @1BBE stack[-3] // @1BCE stack[-2] // @1BE6 stack[-1] // @1C0D memory[0x40:0x60] // @1C14 stack[-4] // @1C16 address(stack[-4]).code.length // } 1BB9 5B JUMPDEST 1BBA 84 DUP5 1BBB 60 PUSH1 0x40 1BBD 51 MLOAD 1BBE 84 DUP5 1BBF 63 PUSH4 0xffffffff 1BC4 16 AND 1BC5 60 PUSH1 0xe0 1BC7 1B SHL 1BC8 81 DUP2 1BC9 52 MSTORE 1BCA 60 PUSH1 0x04 1BCC 01 ADD 1BCD 80 DUP1 1BCE 84 DUP5 1BCF 60 PUSH1 0x01 1BD1 60 PUSH1 0x01 1BD3 60 PUSH1 0xa0 1BD5 1B SHL 1BD6 03 SUB 1BD7 16 AND 1BD8 60 PUSH1 0x01 1BDA 60 PUSH1 0x01 1BDC 60 PUSH1 0xa0 1BDE 1B SHL 1BDF 03 SUB 1BE0 16 AND 1BE1 81 DUP2 1BE2 52 MSTORE 1BE3 60 PUSH1 0x20 1BE5 01 ADD 1BE6 83 DUP4 1BE7 60 PUSH1 0x01 1BE9 60 PUSH1 0x01 1BEB 60 PUSH1 0xa0 1BED 1B SHL 1BEE 03 SUB 1BEF 16 AND 1BF0 60 PUSH1 0x01 1BF2 60 PUSH1 0x01 1BF4 60 PUSH1 0xa0 1BF6 1B SHL 1BF7 03 SUB 1BF8 16 AND 1BF9 81 DUP2 1BFA 52 MSTORE 1BFB 60 PUSH1 0x20 1BFD 01 ADD 1BFE 82 DUP3 1BFF 81 DUP2 1C00 52 MSTORE 1C01 60 PUSH1 0x20 1C03 01 ADD 1C04 93 SWAP4 1C05 50 POP 1C06 50 POP 1C07 50 POP 1C08 50 POP 1C09 60 PUSH1 0x00 1C0B 60 PUSH1 0x40 1C0D 51 MLOAD 1C0E 80 DUP1 1C0F 83 DUP4 1C10 03 SUB 1C11 81 DUP2 1C12 60 PUSH1 0x00 1C14 87 DUP8 1C15 80 DUP1 1C16 3B EXTCODESIZE 1C17 15 ISZERO 1C18 80 DUP1 1C19 15 ISZERO 1C1A 61 PUSH2 0x1c22 1C1D 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @1BC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-3]) << 0xe0 // @1BE2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-2] // @1BFA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-1] // @1C00 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @1C04 stack[-2] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1C09 stack[-1] = 0x00 // @1C0D stack[0] = memory[0x40:0x60] // @1C10 stack[1] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1C11 stack[2] = memory[0x40:0x60] // @1C12 stack[3] = 0x00 // @1C14 stack[4] = stack[-4] // @1C17 stack[5] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x1c22, if !!address(stack[-4]).code.length label_1C1E: // Incoming jump from 0x1C1D, if not !!address(stack[-4]).code.length // Inputs[1] { @1C21 memory[0x00:0x00] } 1C1E 60 PUSH1 0x00 1C20 80 DUP1 1C21 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C21 revert(memory[0x00:0x00]); } // Block terminates label_1C22: // Incoming jump from 0x1C1D, if !!address(stack[-4]).code.length // Inputs[9] // { // @1C24 msg.gas // @1C25 memory[stack[-4]:stack[-4] + stack[-5]] // @1C25 stack[-3] // @1C25 stack[-6] // @1C25 stack[-5] // @1C25 stack[-4] // @1C25 stack[-2] // @1C25 stack[-7] // @1C25 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 1C22 5B JUMPDEST 1C23 50 POP 1C24 5A GAS 1C25 F1 CALL 1C26 15 ISZERO 1C27 80 DUP1 1C28 15 ISZERO 1C29 61 PUSH2 0x1c36 1C2C 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1C25 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1C26 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 0x1c36, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1C2D: // Incoming jump from 0x1C2C, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1C2D returndata.length // @1C31 returndata[0x00:0x00 + returndata.length] // @1C32 returndata.length // @1C35 memory[0x00:0x00 + returndata.length] // } 1C2D 3D RETURNDATASIZE 1C2E 60 PUSH1 0x00 1C30 80 DUP1 1C31 3E RETURNDATACOPY 1C32 3D RETURNDATASIZE 1C33 60 PUSH1 0x00 1C35 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1C31 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1C35 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1C36: // Incoming jump from 0x1C2C, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1C3A stack[-12] // @1C3B stack[-11] // } 1C36 5B JUMPDEST 1C37 50 POP 1C38 60 PUSH1 0x01 1C3A 9A SWAP11 1C3B 99 SWAP10 1C3C 50 POP 1C3D 50 POP 1C3E 50 POP 1C3F 50 POP 1C40 50 POP 1C41 50 POP 1C42 50 POP 1C43 50 POP 1C44 50 POP 1C45 50 POP 1C46 56 *JUMP // Stack delta = -11 // Outputs[1] { @1C3A stack[-12] = 0x01 } // Block ends with unconditional jump to stack[-12] label_1C47: // Incoming call from 0x0703, returns to 0x0704 // Inputs[2] // { // @1C4A storage[0x9c] // @1C54 stack[-1] // } 1C47 5B JUMPDEST 1C48 60 PUSH1 0x9c 1C4A 54 SLOAD 1C4B 60 PUSH1 0x01 1C4D 60 PUSH1 0x01 1C4F 60 PUSH1 0xa0 1C51 1B SHL 1C52 03 SUB 1C53 16 AND 1C54 90 SWAP1 1C55 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C54 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x9c] } // Block ends with unconditional jump to stack[-1] label_1C56: // Incoming call from 0x0727, returns to 0x0543 // Inputs[1] { @1C78 stack[-1] } 1C56 5B JUMPDEST 1C57 7F PUSH32 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 1C78 81 DUP2 1C79 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C57 stack[0] = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 } // Block ends with unconditional jump to stack[-1] label_1C7A: // Incoming call from 0x072F, returns to 0x0730 // Inputs[1] { @1C7D storage[0x97] } 1C7A 5B JUMPDEST 1C7B 60 PUSH1 0x97 1C7D 54 SLOAD 1C7E 60 PUSH1 0x00 1C80 90 SWAP1 1C81 60 PUSH1 0x01 1C83 60 PUSH1 0x01 1C85 60 PUSH1 0xa0 1C87 1B SHL 1C88 03 SUB 1C89 16 AND 1C8A 61 PUSH2 0x1cc3 1C8D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C80 stack[0] = 0x00 } // Block ends with conditional jump to 0x1cc3, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_1C8E: // Incoming jump from 0x1C8D, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @1C91 memory[0x40:0x60] // @1CB9 memory[0x40:0x60] // @1CC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1C8E 60 PUSH1 0x40 1C90 80 DUP1 1C91 51 MLOAD 1C92 62 PUSH3 0x461bcd 1C96 60 PUSH1 0xe5 1C98 1B SHL 1C99 81 DUP2 1C9A 52 MSTORE 1C9B 60 PUSH1 0x20 1C9D 60 PUSH1 0x04 1C9F 80 DUP1 1CA0 83 DUP4 1CA1 01 ADD 1CA2 91 SWAP2 1CA3 90 SWAP1 1CA4 91 SWAP2 1CA5 52 MSTORE 1CA6 60 PUSH1 0x24 1CA8 82 DUP3 1CA9 01 ADD 1CAA 52 MSTORE 1CAB 63 PUSH4 0x50523031 1CB0 60 PUSH1 0xe0 1CB2 1B SHL 1CB3 60 PUSH1 0x44 1CB5 82 DUP3 1CB6 01 ADD 1CB7 52 MSTORE 1CB8 90 SWAP1 1CB9 51 MLOAD 1CBA 90 SWAP1 1CBB 81 DUP2 1CBC 90 SWAP1 1CBD 03 SUB 1CBE 60 PUSH1 0x64 1CC0 01 ADD 1CC1 90 SWAP1 1CC2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1C9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1CA5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1CAA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1CB7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @1CC2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1CC3: // Incoming jump from 0x1C8D, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @1CC9 storage[0x97] // @1CEA memory[0x40:0x60] // @1CFE memory[0x40:0x60] // @1D05 address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } 1CC3 5B JUMPDEST 1CC4 60 PUSH1 0x97 1CC6 60 PUSH1 0x00 1CC8 90 SWAP1 1CC9 54 SLOAD 1CCA 90 SWAP1 1CCB 61 PUSH2 0x0100 1CCE 0A EXP 1CCF 90 SWAP1 1CD0 04 DIV 1CD1 60 PUSH1 0x01 1CD3 60 PUSH1 0x01 1CD5 60 PUSH1 0xa0 1CD7 1B SHL 1CD8 03 SUB 1CD9 16 AND 1CDA 60 PUSH1 0x01 1CDC 60 PUSH1 0x01 1CDE 60 PUSH1 0xa0 1CE0 1B SHL 1CE1 03 SUB 1CE2 16 AND 1CE3 63 PUSH4 0x313ce567 1CE8 60 PUSH1 0x40 1CEA 51 MLOAD 1CEB 81 DUP2 1CEC 63 PUSH4 0xffffffff 1CF1 16 AND 1CF2 60 PUSH1 0xe0 1CF4 1B SHL 1CF5 81 DUP2 1CF6 52 MSTORE 1CF7 60 PUSH1 0x04 1CF9 01 ADD 1CFA 60 PUSH1 0x20 1CFC 60 PUSH1 0x40 1CFE 51 MLOAD 1CFF 80 DUP1 1D00 83 DUP4 1D01 03 SUB 1D02 81 DUP2 1D03 86 DUP7 1D04 80 DUP1 1D05 3B EXTCODESIZE 1D06 15 ISZERO 1D07 80 DUP1 1D08 15 ISZERO 1D09 61 PUSH2 0x1837 1D0C 57 *JUMPI // Stack delta = +9 // Outputs[10] // { // @1CE2 stack[0] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @1CE3 stack[1] = 0x313ce567 // @1CF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x313ce567) << 0xe0 // @1CF9 stack[2] = 0x04 + memory[0x40:0x60] // @1CFA stack[3] = 0x20 // @1CFE stack[4] = memory[0x40:0x60] // @1D01 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1D02 stack[6] = memory[0x40:0x60] // @1D03 stack[7] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @1D06 stack[8] = !address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x1837, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length label_1D0D: // Incoming jump from 0x1D0C, if not !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Inputs[1] { @1D10 memory[0x00:0x00] } 1D0D 60 PUSH1 0x00 1D0F 80 DUP1 1D10 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D10 revert(memory[0x00:0x00]); } // Block terminates label_1D11: // Incoming call from 0x074D, returns to 0x03E8 // Inputs[2] // { // @1D16 storage[0x0104] // @1D1A memory[0x40:0x60] // } 1D11 5B JUMPDEST 1D12 61 PUSH2 0x0104 1D15 80 DUP1 1D16 54 SLOAD 1D17 60 PUSH1 0x40 1D19 80 DUP1 1D1A 51 MLOAD 1D1B 60 PUSH1 0x20 1D1D 60 PUSH1 0x1f 1D1F 60 PUSH1 0x02 1D21 60 PUSH1 0x00 1D23 19 NOT 1D24 61 PUSH2 0x0100 1D27 60 PUSH1 0x01 1D29 88 DUP9 1D2A 16 AND 1D2B 15 ISZERO 1D2C 02 MUL 1D2D 01 ADD 1D2E 90 SWAP1 1D2F 95 SWAP6 1D30 16 AND 1D31 94 SWAP5 1D32 90 SWAP1 1D33 94 SWAP5 1D34 04 DIV 1D35 93 SWAP4 1D36 84 DUP5 1D37 01 ADD 1D38 81 DUP2 1D39 90 SWAP1 1D3A 04 DIV 1D3B 81 DUP2 1D3C 02 MUL 1D3D 82 DUP3 1D3E 01 ADD 1D3F 81 DUP2 1D40 01 ADD 1D41 90 SWAP1 1D42 92 SWAP3 1D43 52 MSTORE 1D44 82 DUP3 1D45 81 DUP2 1D46 52 MSTORE 1D47 60 PUSH1 0x60 1D49 93 SWAP4 1D4A 90 SWAP1 1D4B 92 SWAP3 1D4C 90 SWAP1 1D4D 91 SWAP2 1D4E 83 DUP4 1D4F 01 ADD 1D50 82 DUP3 1D51 82 DUP3 1D52 80 DUP1 1D53 15 ISZERO 1D54 61 PUSH2 0x1d9e 1D57 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1D43 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0104] & !(storage[0x0104] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @1D46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0104] & !(storage[0x0104] & 0x01) * 0x0100 + ~0x00) / 0x02 // @1D49 stack[0] = 0x60 // @1D4B stack[1] = memory[0x40:0x60] // @1D4C stack[3] = (storage[0x0104] & !(storage[0x0104] & 0x01) * 0x0100 + ~0x00) / 0x02 // @1D4D stack[2] = 0x0104 // @1D4F stack[4] = memory[0x40:0x60] + 0x20 // @1D50 stack[5] = 0x0104 // @1D51 stack[6] = (storage[0x0104] & !(storage[0x0104] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x1d9e, if !((storage[0x0104] & !(storage[0x0104] & 0x01) * 0x0100 + ~0x00) / 0x02) label_1D58: // Incoming jump from 0x1D57, if not !((storage[0x0104] & !(storage[0x0104] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @1D58 stack[-1] } 1D58 80 DUP1 1D59 60 PUSH1 0x1f 1D5B 10 LT 1D5C 61 PUSH2 0x1d73 1D5F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d73, if 0x1f < stack[-1] label_1D60: // Incoming jump from 0x1D5F, if not 0x1f < stack[-1] // Inputs[4] // { // @1D64 stack[-2] // @1D65 storage[stack[-2]] // @1D68 stack[-3] // @1D6A stack[-1] // } 1D60 61 PUSH2 0x0100 1D63 80 DUP1 1D64 83 DUP4 1D65 54 SLOAD 1D66 04 DIV 1D67 02 MUL 1D68 83 DUP4 1D69 52 MSTORE 1D6A 91 SWAP2 1D6B 60 PUSH1 0x20 1D6D 01 ADD 1D6E 91 SWAP2 1D6F 61 PUSH2 0x1d9e 1D72 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1D69 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1D6E stack[-1] = stack[-1] // @1D6E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1d9e label_1D73: // Incoming jump from 0x1D5F, if 0x1f < stack[-1] // Inputs[5] // { // @1D74 stack[-3] // @1D75 stack[-1] // @1D77 stack[-2] // @1D7F memory[0x00:0x20] // @1D83 storage[keccak256(memory[0x00:0x20])] // } 1D73 5B JUMPDEST 1D74 82 DUP3 1D75 01 ADD 1D76 91 SWAP2 1D77 90 SWAP1 1D78 60 PUSH1 0x00 1D7A 52 MSTORE 1D7B 60 PUSH1 0x20 1D7D 60 PUSH1 0x00 1D7F 20 SHA3 1D80 90 SWAP1 1D81 5B JUMPDEST 1D82 81 DUP2 1D83 54 SLOAD 1D84 81 DUP2 1D85 52 MSTORE 1D86 90 SWAP1 1D87 60 PUSH1 0x01 1D89 01 ADD 1D8A 90 SWAP1 1D8B 60 PUSH1 0x20 1D8D 01 ADD 1D8E 80 DUP1 1D8F 83 DUP4 1D90 11 GT 1D91 61 PUSH2 0x1d81 1D94 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1D76 stack[-3] = stack[-3] + stack[-1] // @1D7A memory[0x00:0x20] = stack[-2] // @1D85 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1D8A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1D8D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1d81, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1D95: // Incoming jump from 0x1D94, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1D94, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1D95 stack[-3] // @1D96 stack[-1] // } 1D95 82 DUP3 1D96 90 SWAP1 1D97 03 SUB 1D98 60 PUSH1 0x1f 1D9A 16 AND 1D9B 82 DUP3 1D9C 01 ADD 1D9D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1D9D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1D9D stack[-1] = stack[-3] // } // Block continues label_1D9E: // Incoming jump from 0x34B8, if !storage[0x9a] // Incoming jump from 0x1D72 // Incoming jump from 0x1D9D // Incoming jump from 0x1D57, if !((storage[0x0104] & !(storage[0x0104] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[3] // { // @1DA4 stack[-6] // @1DA4 stack[-7] // @1DA6 stack[-8] // } 1D9E 5B JUMPDEST 1D9F 50 POP 1DA0 50 POP 1DA1 50 POP 1DA2 50 POP 1DA3 50 POP 1DA4 90 SWAP1 1DA5 50 POP 1DA6 90 SWAP1 1DA7 56 *JUMP // Stack delta = -7 // Outputs[1] { @1DA6 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1DA8: // Incoming call from 0x0755, returns to 0x0543 // Inputs[2] // { // @1DAC storage[0x0105] // @1DAD stack[-1] // } 1DA8 5B JUMPDEST 1DA9 61 PUSH2 0x0105 1DAC 54 SLOAD 1DAD 81 DUP2 1DAE 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DAC stack[0] = storage[0x0105] } // Block ends with unconditional jump to stack[-1] label_1DAF: // Incoming jump from 0x077B 1DAF 5B JUMPDEST 1DB0 61 PUSH2 0x1db7 1DB3 61 PUSH2 0x4380 1DB6 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DB0 stack[0] = 0x1db7 } // Block ends with call to 0x4380, returns to 0x1DB7 label_1DB7: // Incoming return from call to 0x4380 at 0x1DB6 // Inputs[1] { @1DC0 stack[-1] } 1DB7 5B JUMPDEST 1DB8 60 PUSH1 0x01 1DBA 60 PUSH1 0x01 1DBC 60 PUSH1 0xa0 1DBE 1B SHL 1DBF 03 SUB 1DC0 16 AND 1DC1 61 PUSH2 0x1dc8 1DC4 61 PUSH2 0x2daa 1DC7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1DC0 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1DC1 stack[0] = 0x1dc8 // } // Block ends with call to 0x2daa, returns to 0x1DC8 label_1DC8: // Incoming return from call to 0x2DAA at 0x1DC7 // Inputs[2] // { // @1DD1 stack[-1] // @1DD2 stack[-2] // } 1DC8 5B JUMPDEST 1DC9 60 PUSH1 0x01 1DCB 60 PUSH1 0x01 1DCD 60 PUSH1 0xa0 1DCF 1B SHL 1DD0 03 SUB 1DD1 16 AND 1DD2 14 EQ 1DD3 80 DUP1 1DD4 61 PUSH2 0x1de3 1DD7 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1DD2 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x1de3, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1DD8: // Incoming jump from 0x1DD7, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 1DD8 50 POP 1DD9 61 PUSH2 0x1de3 1DDC 61 PUSH2 0x153d 1DDF 61 PUSH2 0x4380 1DE2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1DD9 stack[-1] = 0x1de3 // @1DDC stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_1DE3: // Incoming jump from 0x1DD7, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1DE7 stack[-1] } 1DE3 5B JUMPDEST 1DE4 61 PUSH2 0x1e1d 1DE7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e1d, if stack[-1] label_1DE8: // Incoming jump from 0x1DE7, if not stack[-1] // Inputs[3] // { // @1DEB memory[0x40:0x60] // @1E13 memory[0x40:0x60] // @1E1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1DE8 60 PUSH1 0x40 1DEA 80 DUP1 1DEB 51 MLOAD 1DEC 62 PUSH3 0x461bcd 1DF0 60 PUSH1 0xe5 1DF2 1B SHL 1DF3 81 DUP2 1DF4 52 MSTORE 1DF5 60 PUSH1 0x20 1DF7 60 PUSH1 0x04 1DF9 80 DUP1 1DFA 83 DUP4 1DFB 01 ADD 1DFC 91 SWAP2 1DFD 90 SWAP1 1DFE 91 SWAP2 1DFF 52 MSTORE 1E00 60 PUSH1 0x24 1E02 82 DUP3 1E03 01 ADD 1E04 52 MSTORE 1E05 63 PUSH4 0x41443031 1E0A 60 PUSH1 0xe0 1E0C 1B SHL 1E0D 60 PUSH1 0x44 1E0F 82 DUP3 1E10 01 ADD 1E11 52 MSTORE 1E12 90 SWAP1 1E13 51 MLOAD 1E14 90 SWAP1 1E15 81 DUP2 1E16 90 SWAP1 1E17 03 SUB 1E18 60 PUSH1 0x64 1E1A 01 ADD 1E1B 90 SWAP1 1E1C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1DF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DFF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E04 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @1E11 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @1E1C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1E1D: // Incoming jump from 0x1DE7, if stack[-1] // Inputs[1] { @1E23 stack[-1] } 1E1D 5B JUMPDEST 1E1E 61 PUSH2 0x1e2e 1E21 60 PUSH1 0x99 1E23 82 DUP3 1E24 63 PUSH4 0xffffffff 1E29 61 PUSH2 0x45eb 1E2C 16 AND 1E2D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E1E stack[0] = 0x1e2e // @1E21 stack[1] = 0x99 // @1E23 stack[2] = stack[-1] // } // Block ends with call to 0x45eb & 0xffffffff, returns to 0x1E2E label_1E2E: // Incoming return from call to 0x45EB at 0x1E2D // Inputs[4] // { // @1E31 memory[0x40:0x60] // @1E3A stack[-1] // @1E62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1E64 stack[-2] // } 1E2E 5B JUMPDEST 1E2F 60 PUSH1 0x40 1E31 51 MLOAD 1E32 60 PUSH1 0x01 1E34 60 PUSH1 0x01 1E36 60 PUSH1 0xa0 1E38 1B SHL 1E39 03 SUB 1E3A 82 DUP3 1E3B 16 AND 1E3C 90 SWAP1 1E3D 7F PUSH32 0x34384dcb6ac9672707fe22d862bf7e9ccaead052d4e8c8e8ffffcdc94b98dfd2 1E5E 90 SWAP1 1E5F 60 PUSH1 0x00 1E61 90 SWAP1 1E62 A2 LOG2 1E63 50 POP 1E64 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E62 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x34384dcb6ac9672707fe22d862bf7e9ccaead052d4e8c8e8ffffcdc94b98dfd2, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_1E65: // Incoming jump from 0x07A7 1E65 5B JUMPDEST 1E66 61 PUSH2 0x1e75 1E69 61 PUSH2 0x1e70 1E6C 61 PUSH2 0x4380 1E6F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E66 stack[0] = 0x1e75 // @1E69 stack[1] = 0x1e70 // } // Block ends with call to 0x4380, returns to 0x1E70 label_1E70: // Incoming return from call to 0x4380 at 0x2F34 // Incoming return from call to 0x4380 at 0x1E6F 1E70 5B JUMPDEST 1E71 61 PUSH2 0x20cf 1E74 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x20cf 1E75 5B JUMPDEST 1E76 61 PUSH2 0x1eaf 1E79 57 *JUMPI 1E7A 60 PUSH1 0x40 1E7C 80 DUP1 1E7D 51 MLOAD 1E7E 62 PUSH3 0x461bcd 1E82 60 PUSH1 0xe5 1E84 1B SHL 1E85 81 DUP2 1E86 52 MSTORE 1E87 60 PUSH1 0x20 1E89 60 PUSH1 0x04 1E8B 80 DUP1 1E8C 83 DUP4 1E8D 01 ADD 1E8E 91 SWAP2 1E8F 90 SWAP1 1E90 91 SWAP2 1E91 52 MSTORE 1E92 60 PUSH1 0x24 1E94 82 DUP3 1E95 01 ADD 1E96 52 MSTORE 1E97 63 PUSH4 0x53553031 1E9C 60 PUSH1 0xe0 1E9E 1B SHL 1E9F 60 PUSH1 0x44 1EA1 82 DUP3 1EA2 01 ADD 1EA3 52 MSTORE 1EA4 90 SWAP1 1EA5 51 MLOAD 1EA6 90 SWAP1 1EA7 81 DUP2 1EA8 90 SWAP1 1EA9 03 SUB 1EAA 60 PUSH1 0x64 1EAC 01 ADD 1EAD 90 SWAP1 1EAE FD *REVERT 1EAF 5B JUMPDEST 1EB0 60 PUSH1 0x97 1EB2 54 SLOAD 1EB3 60 PUSH1 0x01 1EB5 60 PUSH1 0x01 1EB7 60 PUSH1 0xa0 1EB9 1B SHL 1EBA 03 SUB 1EBB 16 AND 1EBC 61 PUSH2 0x1ef5 1EBF 57 *JUMPI 1EC0 60 PUSH1 0x40 1EC2 80 DUP1 1EC3 51 MLOAD 1EC4 62 PUSH3 0x461bcd 1EC8 60 PUSH1 0xe5 1ECA 1B SHL 1ECB 81 DUP2 1ECC 52 MSTORE 1ECD 60 PUSH1 0x20 1ECF 60 PUSH1 0x04 1ED1 80 DUP1 1ED2 83 DUP4 1ED3 01 ADD 1ED4 91 SWAP2 1ED5 90 SWAP1 1ED6 91 SWAP2 1ED7 52 MSTORE 1ED8 60 PUSH1 0x24 1EDA 82 DUP3 1EDB 01 ADD 1EDC 52 MSTORE 1EDD 63 PUSH4 0x50523031 1EE2 60 PUSH1 0xe0 1EE4 1B SHL 1EE5 60 PUSH1 0x44 1EE7 82 DUP3 1EE8 01 ADD 1EE9 52 MSTORE 1EEA 90 SWAP1 1EEB 51 MLOAD 1EEC 90 SWAP1 1EED 81 DUP2 1EEE 90 SWAP1 1EEF 03 SUB 1EF0 60 PUSH1 0x64 1EF2 01 ADD 1EF3 90 SWAP1 1EF4 FD *REVERT 1EF5 5B JUMPDEST 1EF6 60 PUSH1 0x97 1EF8 54 SLOAD 1EF9 60 PUSH1 0x01 1EFB 60 PUSH1 0x01 1EFD 60 PUSH1 0xa0 1EFF 1B SHL 1F00 03 SUB 1F01 16 AND 1F02 63 PUSH4 0xc6c3bbe6 1F07 61 PUSH2 0x1f0e 1F0A 61 PUSH2 0x4380 1F0D 56 *JUMP 1F0E 5B JUMPDEST 1F0F 60 PUSH1 0x40 1F11 80 DUP1 1F12 51 MLOAD 1F13 60 PUSH1 0x01 1F15 60 PUSH1 0x01 1F17 60 PUSH1 0xe0 1F19 1B SHL 1F1A 03 SUB 1F1B 19 NOT 1F1C 60 PUSH1 0xe0 1F1E 85 DUP6 1F1F 90 SWAP1 1F20 1B SHL 1F21 16 AND 1F22 81 DUP2 1F23 52 MSTORE 1F24 60 PUSH1 0x01 1F26 60 PUSH1 0x01 1F28 60 PUSH1 0xa0 1F2A 1B SHL 1F2B 03 SUB 1F2C 92 SWAP3 1F2D 83 DUP4 1F2E 16 AND 1F2F 60 PUSH1 0x04 1F31 82 DUP3 1F32 01 ADD 1F33 52 MSTORE 1F34 91 SWAP2 1F35 86 DUP7 1F36 16 AND 1F37 60 PUSH1 0x24 1F39 83 DUP4 1F3A 01 ADD 1F3B 52 MSTORE 1F3C 60 PUSH1 0x44 1F3E 82 DUP3 1F3F 01 ADD 1F40 85 DUP6 1F41 90 SWAP1 1F42 52 MSTORE 1F43 51 MLOAD 1F44 60 PUSH1 0x64 1F46 80 DUP1 1F47 83 DUP4 1F48 01 ADD 1F49 92 SWAP3 1F4A 60 PUSH1 0x00 1F4C 92 SWAP3 1F4D 91 SWAP2 1F4E 90 SWAP1 1F4F 82 DUP3 1F50 90 SWAP1 1F51 03 SUB 1F52 01 ADD 1F53 81 DUP2 1F54 83 DUP4 1F55 87 DUP8 1F56 80 DUP1 1F57 3B EXTCODESIZE 1F58 15 ISZERO 1F59 80 DUP1 1F5A 15 ISZERO 1F5B 61 PUSH2 0x1f63 1F5E 57 *JUMPI 1F5F 60 PUSH1 0x00 1F61 80 DUP1 1F62 FD *REVERT 1F63 5B JUMPDEST 1F64 50 POP 1F65 5A GAS 1F66 F1 CALL 1F67 15 ISZERO 1F68 80 DUP1 1F69 15 ISZERO 1F6A 61 PUSH2 0x1f77 1F6D 57 *JUMPI 1F6E 3D RETURNDATASIZE 1F6F 60 PUSH1 0x00 1F71 80 DUP1 1F72 3E RETURNDATACOPY 1F73 3D RETURNDATASIZE 1F74 60 PUSH1 0x00 1F76 FD *REVERT 1F77 5B JUMPDEST 1F78 50 POP 1F79 50 POP 1F7A 60 PUSH1 0x40 1F7C 80 DUP1 1F7D 51 MLOAD 1F7E 84 DUP5 1F7F 81 DUP2 1F80 52 MSTORE 1F81 90 SWAP1 1F82 51 MLOAD 1F83 60 PUSH1 0x01 1F85 60 PUSH1 0x01 1F87 60 PUSH1 0xa0 1F89 1B SHL 1F8A 03 SUB 1F8B 86 DUP7 1F8C 16 AND 1F8D 93 SWAP4 1F8E 50 POP 1F8F 7F PUSH32 0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885 1FB0 92 SWAP3 1FB1 50 POP 1FB2 90 SWAP1 1FB3 81 DUP2 1FB4 90 SWAP1 1FB5 03 SUB 1FB6 60 PUSH1 0x20 1FB8 01 ADD 1FB9 90 SWAP1 1FBA A2 LOG2 1FBB 60 PUSH1 0x40 1FBD 80 DUP1 1FBE 51 MLOAD 1FBF 82 DUP3 1FC0 81 DUP2 1FC1 52 MSTORE 1FC2 90 SWAP1 1FC3 51 MLOAD 1FC4 60 PUSH1 0x01 1FC6 60 PUSH1 0x01 1FC8 60 PUSH1 0xa0 1FCA 1B SHL 1FCB 03 SUB 1FCC 84 DUP5 1FCD 16 AND 1FCE 91 SWAP2 1FCF 60 PUSH1 0x00 1FD1 91 SWAP2 1FD2 60 PUSH1 0x00 1FD4 80 DUP1 1FD5 51 MLOAD 1FD6 60 PUSH1 0x20 1FD8 61 PUSH2 0x5729 1FDB 83 DUP4 1FDC 39 CODECOPY 1FDD 81 DUP2 1FDE 51 MLOAD 1FDF 91 SWAP2 1FE0 52 MSTORE 1FE1 91 SWAP2 1FE2 81 DUP2 1FE3 90 SWAP1 1FE4 03 SUB 1FE5 60 PUSH1 0x20 1FE7 01 ADD 1FE8 90 SWAP1 1FE9 A3 LOG3 1FEA 50 POP 1FEB 50 POP 1FEC 56 *JUMP label_1FED: // Incoming jump from 0x0815 1FED 5B JUMPDEST 1FEE 61 PUSH2 0x1ff5 1FF1 61 PUSH2 0x4380 1FF4 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FEE stack[0] = 0x1ff5 } // Block ends with call to 0x4380, returns to 0x1FF5 label_1FF5: // Incoming return from call to 0x4380 at 0x1FF4 // Inputs[1] { @1FFE stack[-1] } 1FF5 5B JUMPDEST 1FF6 60 PUSH1 0x01 1FF8 60 PUSH1 0x01 1FFA 60 PUSH1 0xa0 1FFC 1B SHL 1FFD 03 SUB 1FFE 16 AND 1FFF 61 PUSH2 0x2006 2002 61 PUSH2 0x2daa 2005 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1FFE stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1FFF stack[0] = 0x2006 // } // Block ends with call to 0x2daa, returns to 0x2006 label_2006: // Incoming return from call to 0x2DAA at 0x2005 // Inputs[2] // { // @200F stack[-1] // @2010 stack[-2] // } 2006 5B JUMPDEST 2007 60 PUSH1 0x01 2009 60 PUSH1 0x01 200B 60 PUSH1 0xa0 200D 1B SHL 200E 03 SUB 200F 16 AND 2010 14 EQ 2011 80 DUP1 2012 61 PUSH2 0x2021 2015 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2010 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x2021, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_2016: // Incoming jump from 0x2015, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 2016 50 POP 2017 61 PUSH2 0x2021 201A 61 PUSH2 0x153d 201D 61 PUSH2 0x4380 2020 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2017 stack[-1] = 0x2021 // @201A stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_2021: // Incoming jump from 0x2015, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @2025 stack[-1] } 2021 5B JUMPDEST 2022 61 PUSH2 0x205b 2025 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x205b, if stack[-1] label_2026: // Incoming jump from 0x2025, if not stack[-1] // Inputs[3] // { // @2029 memory[0x40:0x60] // @2051 memory[0x40:0x60] // @205A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2026 60 PUSH1 0x40 2028 80 DUP1 2029 51 MLOAD 202A 62 PUSH3 0x461bcd 202E 60 PUSH1 0xe5 2030 1B SHL 2031 81 DUP2 2032 52 MSTORE 2033 60 PUSH1 0x20 2035 60 PUSH1 0x04 2037 80 DUP1 2038 83 DUP4 2039 01 ADD 203A 91 SWAP2 203B 90 SWAP1 203C 91 SWAP2 203D 52 MSTORE 203E 60 PUSH1 0x24 2040 82 DUP3 2041 01 ADD 2042 52 MSTORE 2043 63 PUSH4 0x41443031 2048 60 PUSH1 0xe0 204A 1B SHL 204B 60 PUSH1 0x44 204D 82 DUP3 204E 01 ADD 204F 52 MSTORE 2050 90 SWAP1 2051 51 MLOAD 2052 90 SWAP1 2053 81 DUP2 2054 90 SWAP1 2055 03 SUB 2056 60 PUSH1 0x64 2058 01 ADD 2059 90 SWAP1 205A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2032 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @203D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2042 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @204F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @205A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_205B: // Incoming jump from 0x2025, if stack[-1] // Inputs[2] // { // @2061 stack[-2] // @2062 stack[-1] // } 205B 5B JUMPDEST 205C 61 PUSH2 0x2067 205F 60 PUSH1 0x9a 2061 83 DUP4 2062 83 DUP4 2063 61 PUSH2 0x5480 2066 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @205C stack[0] = 0x2067 // @205F stack[1] = 0x9a // @2061 stack[2] = stack[-2] // @2062 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x5480 2067 5B JUMPDEST 2068 50 POP 2069 7F PUSH32 0x57c55be0f3a533db430bb8586b26f0e2efa5afdd84b6657634863b9115cb63f8 208A 82 DUP3 208B 82 DUP3 208C 60 PUSH1 0x40 208E 51 MLOAD 208F 80 DUP1 2090 80 DUP1 2091 60 PUSH1 0x20 2093 01 ADD 2094 82 DUP3 2095 81 DUP2 2096 03 SUB 2097 82 DUP3 2098 52 MSTORE 2099 84 DUP5 209A 84 DUP5 209B 82 DUP3 209C 81 DUP2 209D 81 DUP2 209E 52 MSTORE 209F 60 PUSH1 0x20 20A1 01 ADD 20A2 92 SWAP3 20A3 50 POP 20A4 60 PUSH1 0x20 20A6 02 MUL 20A7 80 DUP1 20A8 82 DUP3 20A9 84 DUP5 20AA 37 CALLDATACOPY 20AB 60 PUSH1 0x00 20AD 83 DUP4 20AE 82 DUP3 20AF 01 ADD 20B0 52 MSTORE 20B1 60 PUSH1 0x40 20B3 51 MLOAD 20B4 60 PUSH1 0x1f 20B6 90 SWAP1 20B7 91 SWAP2 20B8 01 ADD 20B9 60 PUSH1 0x1f 20BB 19 NOT 20BC 16 AND 20BD 90 SWAP1 20BE 92 SWAP3 20BF 01 ADD 20C0 82 DUP3 20C1 90 SWAP1 20C2 03 SUB 20C3 95 SWAP6 20C4 50 POP 20C5 90 SWAP1 20C6 93 SWAP4 20C7 50 POP 20C8 50 POP 20C9 50 POP 20CA 50 POP 20CB A1 LOG1 20CC 50 POP 20CD 50 POP 20CE 56 *JUMP label_20CF: // Incoming jump from 0x1E74 // Incoming jump from 0x083B // Inputs[1] { @20D8 stack[-1] } 20CF 5B JUMPDEST 20D0 60 PUSH1 0x00 20D2 61 PUSH2 0x14f0 20D5 61 PUSH2 0x0101 20D8 83 DUP4 20D9 63 PUSH4 0xffffffff 20DE 61 PUSH2 0x4440 20E1 16 AND 20E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20D0 stack[0] = 0x00 // @20D2 stack[1] = 0x14f0 // @20D5 stack[2] = 0x0101 // @20D8 stack[3] = stack[-1] // } // Block ends with call to 0x4440 & 0xffffffff, returns to 0x14F0 label_20E3: // Incoming jump from 0x0869 // Incoming jump from 0x4DDC // Incoming jump from 0x4DDC // Inputs[1] { @20E6 storage[0x00] } 20E3 5B JUMPDEST 20E4 60 PUSH1 0x00 20E6 54 SLOAD 20E7 61 PUSH2 0x0100 20EA 90 SWAP1 20EB 04 DIV 20EC 60 PUSH1 0xff 20EE 16 AND 20EF 80 DUP1 20F0 61 PUSH2 0x20fc 20F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20EE stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x20fc, if 0xff & storage[0x00] / 0x0100 label_20F4: // Incoming jump from 0x20F3, if not 0xff & storage[0x00] / 0x0100 20F4 50 POP 20F5 61 PUSH2 0x20fc 20F8 61 PUSH2 0x48ef 20FB 56 *JUMP // Stack delta = +0 // Outputs[1] { @20F5 stack[-1] = 0x20fc } // Block ends with call to 0x48ef, returns to 0x20FC label_20FC: // Incoming return from call to 0x48EF at 0x20FB // Incoming jump from 0x20F3, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @20FD stack[-1] } 20FC 5B JUMPDEST 20FD 80 DUP1 20FE 61 PUSH2 0x210a 2101 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x210a, if stack[-1] label_2102: // Incoming jump from 0x2101, if not stack[-1] // Inputs[1] { @2105 storage[0x00] } 2102 50 POP 2103 60 PUSH1 0x00 2105 54 SLOAD 2106 60 PUSH1 0xff 2108 16 AND 2109 15 ISZERO 210A 5B JUMPDEST 210B 61 PUSH2 0x2145 210E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2145, if !(0xff & storage[0x00]) label_210F: // Incoming jump from 0x210E, if not !(0xff & storage[0x00]) // Incoming jump from 0x210E, if not stack[-1] // Inputs[3] // { // @2111 memory[0x40:0x60] // @213F memory[0x40:0x60] // @2144 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 210F 60 PUSH1 0x40 2111 51 MLOAD 2112 62 PUSH3 0x461bcd 2116 60 PUSH1 0xe5 2118 1B SHL 2119 81 DUP2 211A 52 MSTORE 211B 60 PUSH1 0x04 211D 01 ADD 211E 80 DUP1 211F 80 DUP1 2120 60 PUSH1 0x20 2122 01 ADD 2123 82 DUP3 2124 81 DUP2 2125 03 SUB 2126 82 DUP3 2127 52 MSTORE 2128 60 PUSH1 0x2e 212A 81 DUP2 212B 52 MSTORE 212C 60 PUSH1 0x20 212E 01 ADD 212F 80 DUP1 2130 61 PUSH2 0x56fb 2133 60 PUSH1 0x2e 2135 91 SWAP2 2136 39 CODECOPY 2137 60 PUSH1 0x40 2139 01 ADD 213A 91 SWAP2 213B 50 POP 213C 50 POP 213D 60 PUSH1 0x40 213F 51 MLOAD 2140 80 DUP1 2141 91 SWAP2 2142 03 SUB 2143 90 SWAP1 2144 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @211A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2127 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @212B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @2136 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x56fb:0x5729] // @2144 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2145: // Incoming jump from 0x210E, if !(0xff & storage[0x00]) // Incoming jump from 0x210E, if stack[-1] // Inputs[1] { @2148 storage[0x00] } 2145 5B JUMPDEST 2146 60 PUSH1 0x00 2148 54 SLOAD 2149 61 PUSH2 0x0100 214C 90 SWAP1 214D 04 DIV 214E 60 PUSH1 0xff 2150 16 AND 2151 15 ISZERO 2152 80 DUP1 2153 15 ISZERO 2154 61 PUSH2 0x2170 2157 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2151 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x2170, if !!(0xff & storage[0x00] / 0x0100) label_2158: // Incoming jump from 0x2157, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[3] // { // @215B storage[0x00] // @2174 stack[-3] // @2175 stack[-2] // } 2158 60 PUSH1 0x00 215A 80 DUP1 215B 54 SLOAD 215C 60 PUSH1 0xff 215E 19 NOT 215F 61 PUSH2 0xff00 2162 19 NOT 2163 90 SWAP1 2164 91 SWAP2 2165 16 AND 2166 61 PUSH2 0x0100 2169 17 OR 216A 16 AND 216B 60 PUSH1 0x01 216D 17 OR 216E 90 SWAP1 216F 55 SSTORE 2170 5B JUMPDEST 2171 61 PUSH2 0x217a 2174 83 DUP4 2175 83 DUP4 2176 61 PUSH2 0x48f5 2179 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @216F storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @2171 stack[0] = 0x217a // @2174 stack[1] = stack[-3] // @2175 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x48f5 217A 5B JUMPDEST 217B 80 DUP1 217C 15 ISZERO 217D 61 PUSH2 0x218c 2180 57 *JUMPI 2181 60 PUSH1 0x00 2183 80 DUP1 2184 54 SLOAD 2185 61 PUSH2 0xff00 2188 19 NOT 2189 16 AND 218A 90 SWAP1 218B 55 SSTORE 218C 5B JUMPDEST 218D 50 POP 218E 50 POP 218F 50 POP 2190 56 *JUMP label_2191: // Incoming call from 0x0871, returns to 0x0872 // Inputs[3] // { // @219D storage[0x0102] // @21A7 memory[0x40:0x60] // @21BA storage[0x0102] // } 2191 5B JUMPDEST 2192 60 PUSH1 0x60 2194 80 DUP1 2195 61 PUSH2 0x0102 2198 61 PUSH2 0x0103 219B 81 DUP2 219C 80 DUP1 219D 54 SLOAD 219E 80 DUP1 219F 60 PUSH1 0x20 21A1 02 MUL 21A2 60 PUSH1 0x20 21A4 01 ADD 21A5 60 PUSH1 0x40 21A7 51 MLOAD 21A8 90 SWAP1 21A9 81 DUP2 21AA 01 ADD 21AB 60 PUSH1 0x40 21AD 52 MSTORE 21AE 80 DUP1 21AF 92 SWAP3 21B0 91 SWAP2 21B1 90 SWAP1 21B2 81 DUP2 21B3 81 DUP2 21B4 52 MSTORE 21B5 60 PUSH1 0x20 21B7 01 ADD 21B8 82 DUP3 21B9 80 DUP1 21BA 54 SLOAD 21BB 80 DUP1 21BC 15 ISZERO 21BD 61 PUSH2 0x21e5 21C0 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @2192 stack[0] = 0x60 // @2194 stack[1] = 0x60 // @2195 stack[2] = 0x0102 // @2198 stack[3] = 0x0103 // @21AD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x0102] // @21AF stack[4] = memory[0x40:0x60] // @21B0 stack[5] = 0x0102 // @21B1 stack[6] = storage[0x0102] // @21B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0102] // @21B7 stack[7] = 0x20 + memory[0x40:0x60] // @21B8 stack[8] = 0x0102 // @21BA stack[9] = storage[0x0102] // } // Block ends with conditional jump to 0x21e5, if !storage[0x0102] label_21C1: // Incoming jump from 0x21C0, if not !storage[0x0102] // Inputs[5] // { // @21C3 stack[-1] // @21C4 stack[-3] // @21C7 stack[-2] // @21CF memory[0x00:0x20] // @21D3 storage[keccak256(memory[0x00:0x20])] // } 21C1 60 PUSH1 0x20 21C3 02 MUL 21C4 82 DUP3 21C5 01 ADD 21C6 91 SWAP2 21C7 90 SWAP1 21C8 60 PUSH1 0x00 21CA 52 MSTORE 21CB 60 PUSH1 0x20 21CD 60 PUSH1 0x00 21CF 20 SHA3 21D0 90 SWAP1 21D1 5B JUMPDEST 21D2 81 DUP2 21D3 54 SLOAD 21D4 81 DUP2 21D5 52 MSTORE 21D6 60 PUSH1 0x20 21D8 01 ADD 21D9 90 SWAP1 21DA 60 PUSH1 0x01 21DC 01 ADD 21DD 90 SWAP1 21DE 80 DUP1 21DF 83 DUP4 21E0 11 GT 21E1 61 PUSH2 0x21d1 21E4 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @21C6 stack[-3] = stack[-3] + 0x20 * stack[-1] // @21CA memory[0x00:0x20] = stack[-2] // @21D5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @21DD stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @21DD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x21d1, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_21E5: // Incoming jump from 0x21C0, if !storage[0x0102] // Incoming jump from 0x21E4, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x21E4, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Inputs[6] // { // @21EB stack[-8] // @21EB stack[-6] // @21ED stack[-7] // @21EF storage[stack[-7]] // @21F9 memory[0x40:0x60] // @220C storage[stack[-7]] // } 21E5 5B JUMPDEST 21E6 50 POP 21E7 50 POP 21E8 50 POP 21E9 50 POP 21EA 50 POP 21EB 91 SWAP2 21EC 50 POP 21ED 80 DUP1 21EE 80 DUP1 21EF 54 SLOAD 21F0 80 DUP1 21F1 60 PUSH1 0x20 21F3 02 MUL 21F4 60 PUSH1 0x20 21F6 01 ADD 21F7 60 PUSH1 0x40 21F9 51 MLOAD 21FA 90 SWAP1 21FB 81 DUP2 21FC 01 ADD 21FD 60 PUSH1 0x40 21FF 52 MSTORE 2200 80 DUP1 2201 92 SWAP3 2202 91 SWAP2 2203 90 SWAP1 2204 81 DUP2 2205 81 DUP2 2206 52 MSTORE 2207 60 PUSH1 0x20 2209 01 ADD 220A 82 DUP3 220B 80 DUP1 220C 54 SLOAD 220D 80 DUP1 220E 15 ISZERO 220F 61 PUSH2 0x2237 2212 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @21EB stack[-8] = stack[-6] // @21FF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[stack[-7]] // @2201 stack[-6] = memory[0x40:0x60] // @2202 stack[-5] = stack[-7] // @2203 stack[-4] = storage[stack[-7]] // @2206 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[stack[-7]] // @2209 stack[-3] = 0x20 + memory[0x40:0x60] // @220A stack[-2] = stack[-7] // @220C stack[-1] = storage[stack[-7]] // } // Block ends with conditional jump to 0x2237, if !storage[stack[-7]] label_2213: // Incoming jump from 0x2212, if not !storage[stack[-7]] // Inputs[5] // { // @2215 stack[-1] // @2216 stack[-3] // @2219 stack[-2] // @2221 memory[0x00:0x20] // @2225 storage[keccak256(memory[0x00:0x20])] // } 2213 60 PUSH1 0x20 2215 02 MUL 2216 82 DUP3 2217 01 ADD 2218 91 SWAP2 2219 90 SWAP1 221A 60 PUSH1 0x00 221C 52 MSTORE 221D 60 PUSH1 0x20 221F 60 PUSH1 0x00 2221 20 SHA3 2222 90 SWAP1 2223 5B JUMPDEST 2224 81 DUP2 2225 54 SLOAD 2226 81 DUP2 2227 52 MSTORE 2228 60 PUSH1 0x20 222A 01 ADD 222B 90 SWAP1 222C 60 PUSH1 0x01 222E 01 ADD 222F 90 SWAP1 2230 80 DUP1 2231 83 DUP4 2232 11 GT 2233 61 PUSH2 0x2223 2236 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2218 stack[-3] = stack[-3] + 0x20 * stack[-1] // @221C memory[0x00:0x20] = stack[-2] // @2227 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @222F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @222F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2223, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_2237: // Incoming jump from 0x2236, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2236, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x2212, if !storage[stack[-7]] // Inputs[6] // { // @223D stack[-6] // @223D stack[-7] // @223F stack[-9] // @2241 stack[-10] // @2241 stack[-8] // @2244 stack[-11] // } 2237 5B JUMPDEST 2238 50 POP 2239 50 POP 223A 50 POP 223B 50 POP 223C 50 POP 223D 90 SWAP1 223E 50 POP 223F 91 SWAP2 2240 50 POP 2241 91 SWAP2 2242 50 POP 2243 90 SWAP1 2244 91 SWAP2 2245 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @2243 stack[-10] = stack[-6] // @2244 stack[-11] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_2246: // Incoming jump from 0x0930 2246 5B JUMPDEST 2247 61 PUSH2 0x224e 224A 61 PUSH2 0x4380 224D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2247 stack[0] = 0x224e } // Block ends with call to 0x4380, returns to 0x224E label_224E: // Incoming return from call to 0x4380 at 0x224D // Inputs[1] { @2257 stack[-1] } 224E 5B JUMPDEST 224F 60 PUSH1 0x01 2251 60 PUSH1 0x01 2253 60 PUSH1 0xa0 2255 1B SHL 2256 03 SUB 2257 16 AND 2258 61 PUSH2 0x225f 225B 61 PUSH2 0x2daa 225E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2257 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2258 stack[0] = 0x225f // } // Block ends with call to 0x2daa, returns to 0x225F label_225F: // Incoming return from call to 0x2DAA at 0x225E // Inputs[2] // { // @2268 stack[-1] // @2269 stack[-2] // } 225F 5B JUMPDEST 2260 60 PUSH1 0x01 2262 60 PUSH1 0x01 2264 60 PUSH1 0xa0 2266 1B SHL 2267 03 SUB 2268 16 AND 2269 14 EQ 226A 80 DUP1 226B 61 PUSH2 0x227a 226E 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2269 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x227a, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_226F: // Incoming jump from 0x226E, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 226F 50 POP 2270 61 PUSH2 0x227a 2273 61 PUSH2 0x153d 2276 61 PUSH2 0x4380 2279 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2270 stack[-1] = 0x227a // @2273 stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_227A: // Incoming jump from 0x226E, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @227E stack[-1] } 227A 5B JUMPDEST 227B 61 PUSH2 0x22b4 227E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x22b4, if stack[-1] label_227F: // Incoming jump from 0x227E, if not stack[-1] // Inputs[3] // { // @2282 memory[0x40:0x60] // @22AA memory[0x40:0x60] // @22B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 227F 60 PUSH1 0x40 2281 80 DUP1 2282 51 MLOAD 2283 62 PUSH3 0x461bcd 2287 60 PUSH1 0xe5 2289 1B SHL 228A 81 DUP2 228B 52 MSTORE 228C 60 PUSH1 0x20 228E 60 PUSH1 0x04 2290 80 DUP1 2291 83 DUP4 2292 01 ADD 2293 91 SWAP2 2294 90 SWAP1 2295 91 SWAP2 2296 52 MSTORE 2297 60 PUSH1 0x24 2299 82 DUP3 229A 01 ADD 229B 52 MSTORE 229C 63 PUSH4 0x41443031 22A1 60 PUSH1 0xe0 22A3 1B SHL 22A4 60 PUSH1 0x44 22A6 82 DUP3 22A7 01 ADD 22A8 52 MSTORE 22A9 90 SWAP1 22AA 51 MLOAD 22AB 90 SWAP1 22AC 81 DUP2 22AD 90 SWAP1 22AE 03 SUB 22AF 60 PUSH1 0x64 22B1 01 ADD 22B2 90 SWAP1 22B3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @228B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2296 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @229B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @22A8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @22B3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_22B4: // Incoming jump from 0x227E, if stack[-1] // Inputs[5] // { // @22B8 storage[0x9c] // @22CB stack[-1] // @22D5 memory[0x40:0x60] // @22FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @22FD stack[-2] // } 22B4 5B JUMPDEST 22B5 60 PUSH1 0x9c 22B7 80 DUP1 22B8 54 SLOAD 22B9 60 PUSH1 0x01 22BB 60 PUSH1 0x01 22BD 60 PUSH1 0xa0 22BF 1B SHL 22C0 03 SUB 22C1 19 NOT 22C2 16 AND 22C3 60 PUSH1 0x01 22C5 60 PUSH1 0x01 22C7 60 PUSH1 0xa0 22C9 1B SHL 22CA 03 SUB 22CB 83 DUP4 22CC 16 AND 22CD 90 SWAP1 22CE 81 DUP2 22CF 17 OR 22D0 90 SWAP1 22D1 91 SWAP2 22D2 55 SSTORE 22D3 60 PUSH1 0x40 22D5 51 MLOAD 22D6 7F PUSH32 0xb36d86785c7d32b1ad714bb705e00e93eccc37b8cf47549043e61e10908ad251 22F7 90 SWAP1 22F8 60 PUSH1 0x00 22FA 90 SWAP1 22FB A2 LOG2 22FC 50 POP 22FD 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @22D2 storage[0x9c] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x9c]) // @22FB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xb36d86785c7d32b1ad714bb705e00e93eccc37b8cf47549043e61e10908ad251, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_22FE: // Incoming jump from 0x0956 22FE 5B JUMPDEST 22FF 61 PUSH2 0x2306 2302 61 PUSH2 0x4380 2305 56 *JUMP // Stack delta = +1 // Outputs[1] { @22FF stack[0] = 0x2306 } // Block ends with call to 0x4380, returns to 0x2306 label_2306: // Incoming return from call to 0x4380 at 0x2305 // Inputs[1] { @230F stack[-1] } 2306 5B JUMPDEST 2307 60 PUSH1 0x01 2309 60 PUSH1 0x01 230B 60 PUSH1 0xa0 230D 1B SHL 230E 03 SUB 230F 16 AND 2310 61 PUSH2 0x2317 2313 61 PUSH2 0x2daa 2316 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @230F stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2310 stack[0] = 0x2317 // } // Block ends with call to 0x2daa, returns to 0x2317 label_2317: // Incoming return from call to 0x2DAA at 0x2316 // Inputs[2] // { // @2320 stack[-1] // @2321 stack[-2] // } 2317 5B JUMPDEST 2318 60 PUSH1 0x01 231A 60 PUSH1 0x01 231C 60 PUSH1 0xa0 231E 1B SHL 231F 03 SUB 2320 16 AND 2321 14 EQ 2322 80 DUP1 2323 61 PUSH2 0x2332 2326 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2321 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x2332, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_2327: // Incoming jump from 0x2326, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 2327 50 POP 2328 61 PUSH2 0x2332 232B 61 PUSH2 0x153d 232E 61 PUSH2 0x4380 2331 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2328 stack[-1] = 0x2332 // @232B stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_2332: // Incoming jump from 0x2326, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @2336 stack[-1] } 2332 5B JUMPDEST 2333 61 PUSH2 0x236c 2336 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x236c, if stack[-1] label_2337: // Incoming jump from 0x2336, if not stack[-1] // Inputs[3] // { // @233A memory[0x40:0x60] // @2362 memory[0x40:0x60] // @236B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2337 60 PUSH1 0x40 2339 80 DUP1 233A 51 MLOAD 233B 62 PUSH3 0x461bcd 233F 60 PUSH1 0xe5 2341 1B SHL 2342 81 DUP2 2343 52 MSTORE 2344 60 PUSH1 0x20 2346 60 PUSH1 0x04 2348 80 DUP1 2349 83 DUP4 234A 01 ADD 234B 91 SWAP2 234C 90 SWAP1 234D 91 SWAP2 234E 52 MSTORE 234F 60 PUSH1 0x24 2351 82 DUP3 2352 01 ADD 2353 52 MSTORE 2354 63 PUSH4 0x41443031 2359 60 PUSH1 0xe0 235B 1B SHL 235C 60 PUSH1 0x44 235E 82 DUP3 235F 01 ADD 2360 52 MSTORE 2361 90 SWAP1 2362 51 MLOAD 2363 90 SWAP1 2364 81 DUP2 2365 90 SWAP1 2366 03 SUB 2367 60 PUSH1 0x64 2369 01 ADD 236A 90 SWAP1 236B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2343 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @234E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2353 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2360 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @236B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_236C: // Incoming jump from 0x2336, if stack[-1] // Inputs[1] { @2372 stack[-1] } 236C 5B JUMPDEST 236D 61 PUSH2 0x237d 2370 60 PUSH1 0xcf 2372 82 DUP3 2373 63 PUSH4 0xffffffff 2378 61 PUSH2 0x45eb 237B 16 AND 237C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @236D stack[0] = 0x237d // @2370 stack[1] = 0xcf // @2372 stack[2] = stack[-1] // } // Block ends with call to 0x45eb & 0xffffffff, returns to 0x237D label_237D: // Incoming return from call to 0x45EB at 0x237C // Inputs[4] // { // @2380 memory[0x40:0x60] // @2389 stack[-1] // @23B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @23B3 stack[-2] // } 237D 5B JUMPDEST 237E 60 PUSH1 0x40 2380 51 MLOAD 2381 60 PUSH1 0x01 2383 60 PUSH1 0x01 2385 60 PUSH1 0xa0 2387 1B SHL 2388 03 SUB 2389 82 DUP3 238A 16 AND 238B 90 SWAP1 238C 7F PUSH32 0x8990e54f9b080279eec4654d02ab4bc37586d8b2a7c4553dba17ccb6a0aceca1 23AD 90 SWAP1 23AE 60 PUSH1 0x00 23B0 90 SWAP1 23B1 A2 LOG2 23B2 50 POP 23B3 56 *JUMP // Stack delta = -2 // Outputs[1] { @23B1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8990e54f9b080279eec4654d02ab4bc37586d8b2a7c4553dba17ccb6a0aceca1, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_23B4: // Incoming jump from 0x0997 // Inputs[2] // { // @23B8 stack[-5] // @23B9 stack[-4] // } 23B4 5B JUMPDEST 23B5 61 PUSH2 0x23be 23B8 85 DUP6 23B9 85 DUP6 23BA 61 PUSH2 0x4a2f 23BD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23B5 stack[0] = 0x23be // @23B8 stack[1] = stack[-5] // @23B9 stack[2] = stack[-4] // } // Block ends with call to 0x4a2f, returns to 0x23BE label_23BE: // Incoming return from call to 0x4A2F at 0x23BD // Inputs[8] // { // @23C2 memory[0x40:0x60] // @23F1 stack[-5] // @23FE stack[-4] // @2402 memory[0x40:0x60] // @2416 storage[0x0105] // @241E stack[-3] // @241F stack[-2] // @2420 stack[-1] // } 23BE 5B JUMPDEST 23BF 60 PUSH1 0x40 23C1 80 DUP1 23C2 51 MLOAD 23C3 7F PUSH32 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429 23E4 60 PUSH1 0x20 23E6 82 DUP3 23E7 01 ADD 23E8 52 MSTORE 23E9 60 PUSH1 0x01 23EB 60 PUSH1 0x01 23ED 60 PUSH1 0xa0 23EF 1B SHL 23F0 03 SUB 23F1 87 DUP8 23F2 16 AND 23F3 81 DUP2 23F4 83 DUP4 23F5 01 ADD 23F6 81 DUP2 23F7 90 SWAP1 23F8 52 MSTORE 23F9 60 PUSH1 0x60 23FB 82 DUP3 23FC 81 DUP2 23FD 01 ADD 23FE 88 DUP9 23FF 90 SWAP1 2400 52 MSTORE 2401 83 DUP4 2402 51 MLOAD 2403 80 DUP1 2404 84 DUP5 2405 03 SUB 2406 90 SWAP1 2407 91 SWAP2 2408 01 ADD 2409 81 DUP2 240A 52 MSTORE 240B 60 PUSH1 0x80 240D 90 SWAP1 240E 92 SWAP3 240F 01 ADD 2410 90 SWAP1 2411 92 SWAP3 2412 52 MSTORE 2413 61 PUSH2 0x0105 2416 54 SLOAD 2417 90 SWAP1 2418 91 SWAP2 2419 90 SWAP1 241A 61 PUSH2 0x2426 241D 90 SWAP1 241E 86 DUP7 241F 86 DUP7 2420 86 DUP7 2421 86 DUP7 2422 61 PUSH2 0x46f6 2425 56 *JUMP // Stack delta = +8 // Outputs[13] // { // @23E8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429 // @23F8 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2400 memory[0x60 + memory[0x40:0x60]:0x60 + memory[0x40:0x60] + 0x20] = stack[-4] // @240A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x60 + (memory[0x40:0x60] - memory[0x40:0x60]) // @2412 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @2418 stack[0] = memory[0x40:0x60] // @2419 stack[1] = stack[-5] & (0x01 << 0xa0) - 0x01 // @241D stack[2] = 0x2426 // @241D stack[3] = storage[0x0105] // @241E stack[4] = stack[-3] // @241F stack[5] = stack[-2] // @2420 stack[6] = stack[-1] // @2421 stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x46f6, returns to 0x2426 label_2426: // Incoming return from call to 0x46F6 at 0x2425 // Inputs[2] // { // @242F stack[-1] // @2430 stack[-2] // } 2426 5B JUMPDEST 2427 60 PUSH1 0x01 2429 60 PUSH1 0x01 242B 60 PUSH1 0xa0 242D 1B SHL 242E 03 SUB 242F 16 AND 2430 14 EQ 2431 61 PUSH2 0x246a 2434 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x246a, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_2435: // Incoming jump from 0x2434, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @2438 memory[0x40:0x60] // @2460 memory[0x40:0x60] // @2469 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2435 60 PUSH1 0x40 2437 80 DUP1 2438 51 MLOAD 2439 62 PUSH3 0x461bcd 243D 60 PUSH1 0xe5 243F 1B SHL 2440 81 DUP2 2441 52 MSTORE 2442 60 PUSH1 0x20 2444 60 PUSH1 0x04 2446 80 DUP1 2447 83 DUP4 2448 01 ADD 2449 91 SWAP2 244A 90 SWAP1 244B 91 SWAP2 244C 52 MSTORE 244D 60 PUSH1 0x24 244F 82 DUP3 2450 01 ADD 2451 52 MSTORE 2452 63 PUSH4 0x53493031 2457 60 PUSH1 0xe0 2459 1B SHL 245A 60 PUSH1 0x44 245C 82 DUP3 245D 01 ADD 245E 52 MSTORE 245F 90 SWAP1 2460 51 MLOAD 2461 90 SWAP1 2462 81 DUP2 2463 90 SWAP1 2464 03 SUB 2465 60 PUSH1 0x64 2467 01 ADD 2468 90 SWAP1 2469 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2441 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @244C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2451 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @245E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53493031 << 0xe0 // @2469 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_246A: // Incoming jump from 0x2434, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[8] // { // @2473 stack[-6] // @2486 memory[0x00:0x40] // @2487 stack[-5] // @248F memory[0x00:0x40] // @2491 storage[keccak256(memory[0x00:0x40])] // @249B memory[0x40:0x60] // @24C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @24C8 stack[-7] // } 246A 5B JUMPDEST 246B 60 PUSH1 0x01 246D 60 PUSH1 0x01 246F 60 PUSH1 0xa0 2471 1B SHL 2472 03 SUB 2473 86 DUP7 2474 16 AND 2475 60 PUSH1 0x00 2477 81 DUP2 2478 81 DUP2 2479 52 MSTORE 247A 61 PUSH2 0x0107 247D 60 PUSH1 0x20 247F 90 SWAP1 2480 81 DUP2 2481 52 MSTORE 2482 60 PUSH1 0x40 2484 80 DUP1 2485 83 DUP4 2486 20 SHA3 2487 89 DUP10 2488 84 DUP5 2489 52 MSTORE 248A 90 SWAP1 248B 91 SWAP2 248C 52 MSTORE 248D 80 DUP1 248E 82 DUP3 248F 20 SHA3 2490 80 DUP1 2491 54 SLOAD 2492 60 PUSH1 0xff 2494 19 NOT 2495 16 AND 2496 60 PUSH1 0x02 2498 17 OR 2499 90 SWAP1 249A 55 SSTORE 249B 51 MLOAD 249C 87 DUP8 249D 92 SWAP3 249E 91 SWAP2 249F 7F PUSH32 0x1cdd46ff242716cdaa72d159d339a485b3438398348d68f09d7c8c0a59353d81 24C0 91 SWAP2 24C1 A3 LOG3 24C2 50 POP 24C3 50 POP 24C4 50 POP 24C5 50 POP 24C6 50 POP 24C7 50 POP 24C8 56 *JUMP // Stack delta = -7 // Outputs[6] // { // @2479 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2481 memory[0x20:0x40] = 0x0107 // @2489 memory[0x00:0x20] = stack[-5] // @248C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @249A storage[keccak256(memory[0x00:0x40])] = 0x02 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @24C1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x1cdd46ff242716cdaa72d159d339a485b3438398348d68f09d7c8c0a59353d81, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] label_24C9: // Incoming jump from 0x09C3 // Inputs[1] { @24CC storage[0x97] } 24C9 5B JUMPDEST 24CA 60 PUSH1 0x97 24CC 54 SLOAD 24CD 60 PUSH1 0x01 24CF 60 PUSH1 0x01 24D1 60 PUSH1 0xa0 24D3 1B SHL 24D4 03 SUB 24D5 16 AND 24D6 61 PUSH2 0x250f 24D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x250f, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_24DA: // Incoming jump from 0x24D9, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @24DD memory[0x40:0x60] // @2505 memory[0x40:0x60] // @250E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 24DA 60 PUSH1 0x40 24DC 80 DUP1 24DD 51 MLOAD 24DE 62 PUSH3 0x461bcd 24E2 60 PUSH1 0xe5 24E4 1B SHL 24E5 81 DUP2 24E6 52 MSTORE 24E7 60 PUSH1 0x20 24E9 60 PUSH1 0x04 24EB 80 DUP1 24EC 83 DUP4 24ED 01 ADD 24EE 91 SWAP2 24EF 90 SWAP1 24F0 91 SWAP2 24F1 52 MSTORE 24F2 60 PUSH1 0x24 24F4 82 DUP3 24F5 01 ADD 24F6 52 MSTORE 24F7 63 PUSH4 0x50523031 24FC 60 PUSH1 0xe0 24FE 1B SHL 24FF 60 PUSH1 0x44 2501 82 DUP3 2502 01 ADD 2503 52 MSTORE 2504 90 SWAP1 2505 51 MLOAD 2506 90 SWAP1 2507 81 DUP2 2508 90 SWAP1 2509 03 SUB 250A 60 PUSH1 0x64 250C 01 ADD 250D 90 SWAP1 250E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @24E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @24F1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @24F6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2503 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @250E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_250F: // Incoming jump from 0x24D9, if (0x01 << 0xa0) - 0x01 & storage[0x97] 250F 5B JUMPDEST 2510 61 PUSH2 0x2521 2513 61 PUSH2 0x251a 2516 61 PUSH2 0x4380 2519 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2510 stack[0] = 0x2521 // @2513 stack[1] = 0x251a // } // Block ends with call to 0x4380, returns to 0x251A label_251A: // Incoming return from call to 0x4380 at 0x2519 // Inputs[2] // { // @251B stack[-4] // @251C stack[-3] // } 251A 5B JUMPDEST 251B 83 DUP4 251C 83 DUP4 251D 61 PUSH2 0x47a8 2520 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @251B stack[0] = stack[-4] // @251C stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x47a8 label_2521: // Incoming return from call to 0x251A at 0x2519 // Incoming jump from 0x4A67, if stack[-1] == stack[-2] // Incoming return from call to 0x3A72 at 0x3A71 // Inputs[1] { @2524 stack[-3] } 2521 5B JUMPDEST 2522 50 POP 2523 50 POP 2524 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_2525: // Incoming jump from 0x09E9 2525 5B JUMPDEST 2526 61 PUSH2 0x252d 2529 61 PUSH2 0x4380 252C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2526 stack[0] = 0x252d } // Block ends with call to 0x4380, returns to 0x252D label_252D: // Incoming return from call to 0x4380 at 0x252C // Inputs[2] // { // @2530 storage[0x65] // @253C stack[-1] // } 252D 5B JUMPDEST 252E 60 PUSH1 0x65 2530 54 SLOAD 2531 60 PUSH1 0x01 2533 60 PUSH1 0x01 2535 60 PUSH1 0xa0 2537 1B SHL 2538 03 SUB 2539 90 SWAP1 253A 81 DUP2 253B 16 AND 253C 91 SWAP2 253D 16 AND 253E 14 EQ 253F 61 PUSH2 0x257d 2542 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x257d, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] label_2543: // Incoming jump from 0x2542, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[5] // { // @2546 memory[0x40:0x60] // @2561 memory[0x00:0x20] // @256A memory[0x00:0x20] // @2573 memory[0x40:0x60] // @257C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2543 60 PUSH1 0x40 2545 80 DUP1 2546 51 MLOAD 2547 62 PUSH3 0x461bcd 254B 60 PUSH1 0xe5 254D 1B SHL 254E 81 DUP2 254F 52 MSTORE 2550 60 PUSH1 0x20 2552 60 PUSH1 0x04 2554 82 DUP3 2555 01 ADD 2556 81 DUP2 2557 90 SWAP1 2558 52 MSTORE 2559 60 PUSH1 0x24 255B 82 DUP3 255C 01 ADD 255D 52 MSTORE 255E 60 PUSH1 0x00 2560 80 DUP1 2561 51 MLOAD 2562 60 PUSH1 0x20 2564 61 PUSH2 0x56b9 2567 83 DUP4 2568 39 CODECOPY 2569 81 DUP2 256A 51 MLOAD 256B 91 SWAP2 256C 52 MSTORE 256D 60 PUSH1 0x44 256F 82 DUP3 2570 01 ADD 2571 52 MSTORE 2572 90 SWAP1 2573 51 MLOAD 2574 90 SWAP1 2575 81 DUP2 2576 90 SWAP1 2577 03 SUB 2578 60 PUSH1 0x64 257A 01 ADD 257B 90 SWAP1 257C FD *REVERT // Stack delta = +0 // Outputs[7] // { // @254F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2558 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @255D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @2568 memory[0x00:0x20] = code[0x56b9:0x56d9] // @256C memory[0x00:0x20] = memory[0x00:0x20] // @2571 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @257C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_257D: // Incoming jump from 0x2542, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[1] { @2583 stack[-1] } 257D 5B JUMPDEST 257E 61 PUSH2 0x258e 2581 60 PUSH1 0x98 2583 82 DUP3 2584 63 PUSH4 0xffffffff 2589 61 PUSH2 0x44a7 258C 16 AND 258D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @257E stack[0] = 0x258e // @2581 stack[1] = 0x98 // @2583 stack[2] = stack[-1] // } // Block ends with call to 0x44a7 & 0xffffffff, returns to 0x258E label_258E: // Incoming return from call to 0x44A7 at 0x258D // Inputs[4] // { // @2591 memory[0x40:0x60] // @259A stack[-1] // @25C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @25C4 stack[-2] // } 258E 5B JUMPDEST 258F 60 PUSH1 0x40 2591 51 MLOAD 2592 60 PUSH1 0x01 2594 60 PUSH1 0x01 2596 60 PUSH1 0xa0 2598 1B SHL 2599 03 SUB 259A 82 DUP3 259B 16 AND 259C 90 SWAP1 259D 7F PUSH32 0xd5c9a61a4ab4b84f78da506149b7b0d376843283a81eee2dbdc9a55f988ab643 25BE 90 SWAP1 25BF 60 PUSH1 0x00 25C1 90 SWAP1 25C2 A2 LOG2 25C3 50 POP 25C4 56 *JUMP // Stack delta = -2 // Outputs[1] { @25C2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xd5c9a61a4ab4b84f78da506149b7b0d376843283a81eee2dbdc9a55f988ab643, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_25C5: // Incoming call from 0x09F1, returns to 0x0543 // Inputs[1] { @25E7 stack[-1] } 25C5 5B JUMPDEST 25C6 7F PUSH32 0x604bdf0208a879f7d9fa63ff2f539804aaf6f7876eaa13d531bdc957f1c0284f 25E7 81 DUP2 25E8 56 *JUMP // Stack delta = +1 // Outputs[1] { @25C6 stack[0] = 0x604bdf0208a879f7d9fa63ff2f539804aaf6f7876eaa13d531bdc957f1c0284f } // Block ends with unconditional jump to stack[-1] label_25E9: // Incoming jump from 0x0A17 // Inputs[1] { @25EC storage[0x97] } 25E9 5B JUMPDEST 25EA 60 PUSH1 0x97 25EC 54 SLOAD 25ED 60 PUSH1 0x00 25EF 90 SWAP1 25F0 60 PUSH1 0x01 25F2 60 PUSH1 0x01 25F4 60 PUSH1 0xa0 25F6 1B SHL 25F7 03 SUB 25F8 16 AND 25F9 61 PUSH2 0x2632 25FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25EF stack[0] = 0x00 } // Block ends with conditional jump to 0x2632, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_25FD: // Incoming jump from 0x25FC, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @2600 memory[0x40:0x60] // @2628 memory[0x40:0x60] // @2631 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 25FD 60 PUSH1 0x40 25FF 80 DUP1 2600 51 MLOAD 2601 62 PUSH3 0x461bcd 2605 60 PUSH1 0xe5 2607 1B SHL 2608 81 DUP2 2609 52 MSTORE 260A 60 PUSH1 0x20 260C 60 PUSH1 0x04 260E 80 DUP1 260F 83 DUP4 2610 01 ADD 2611 91 SWAP2 2612 90 SWAP1 2613 91 SWAP2 2614 52 MSTORE 2615 60 PUSH1 0x24 2617 82 DUP3 2618 01 ADD 2619 52 MSTORE 261A 63 PUSH4 0x50523031 261F 60 PUSH1 0xe0 2621 1B SHL 2622 60 PUSH1 0x44 2624 82 DUP3 2625 01 ADD 2626 52 MSTORE 2627 90 SWAP1 2628 51 MLOAD 2629 90 SWAP1 262A 81 DUP2 262B 90 SWAP1 262C 03 SUB 262D 60 PUSH1 0x64 262F 01 ADD 2630 90 SWAP1 2631 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2609 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2614 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2619 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2626 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @2631 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2632: // Incoming jump from 0x25FC, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[5] // { // @2635 storage[0x97] // @2639 memory[0x40:0x60] // @264C stack[-2] // @2655 memory[0x40:0x60] // @2673 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 2632 5B JUMPDEST 2633 60 PUSH1 0x97 2635 54 SLOAD 2636 60 PUSH1 0x40 2638 80 DUP1 2639 51 MLOAD 263A 63 PUSH4 0x70a08231 263F 60 PUSH1 0xe0 2641 1B SHL 2642 81 DUP2 2643 52 MSTORE 2644 60 PUSH1 0x01 2646 60 PUSH1 0x01 2648 60 PUSH1 0xa0 264A 1B SHL 264B 03 SUB 264C 85 DUP6 264D 81 DUP2 264E 16 AND 264F 60 PUSH1 0x04 2651 83 DUP4 2652 01 ADD 2653 52 MSTORE 2654 91 SWAP2 2655 51 MLOAD 2656 91 SWAP2 2657 90 SWAP1 2658 92 SWAP3 2659 16 AND 265A 91 SWAP2 265B 63 PUSH4 0x70a08231 2660 91 SWAP2 2661 60 PUSH1 0x24 2663 80 DUP1 2664 83 DUP4 2665 01 ADD 2666 92 SWAP3 2667 60 PUSH1 0x20 2669 92 SWAP3 266A 91 SWAP2 266B 90 SWAP1 266C 82 DUP3 266D 90 SWAP1 266E 03 SUB 266F 01 ADD 2670 81 DUP2 2671 86 DUP7 2672 80 DUP1 2673 3B EXTCODESIZE 2674 15 ISZERO 2675 80 DUP1 2676 15 ISZERO 2677 61 PUSH2 0x267f 267A 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @2643 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @2653 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @265A stack[0] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @2660 stack[1] = 0x70a08231 // @2666 stack[2] = memory[0x40:0x60] + 0x24 // @2669 stack[3] = 0x20 // @266A stack[4] = memory[0x40:0x60] // @266F stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @2670 stack[6] = memory[0x40:0x60] // @2671 stack[7] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @2674 stack[8] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x267f, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_267B: // Incoming jump from 0x267A, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @267E memory[0x00:0x00] } 267B 60 PUSH1 0x00 267D 80 DUP1 267E FD *REVERT // Stack delta = +0 // Outputs[1] { @267E revert(memory[0x00:0x00]); } // Block terminates label_267F: // Incoming jump from 0x267A, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @2681 msg.gas // @2682 stack[-2] // @2682 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2682 memory[stack[-3]:stack[-3] + stack[-4]] // @2682 stack[-6] // @2682 stack[-5] // @2682 stack[-3] // @2682 stack[-4] // } 267F 5B JUMPDEST 2680 50 POP 2681 5A GAS 2682 FA STATICCALL 2683 15 ISZERO 2684 80 DUP1 2685 15 ISZERO 2686 61 PUSH2 0x2693 2689 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2682 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2683 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2693, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_268A: // Incoming jump from 0x2689, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @268A returndata.length // @268E returndata[0x00:0x00 + returndata.length] // @268F returndata.length // @2692 memory[0x00:0x00 + returndata.length] // } 268A 3D RETURNDATASIZE 268B 60 PUSH1 0x00 268D 80 DUP1 268E 3E RETURNDATACOPY 268F 3D RETURNDATASIZE 2690 60 PUSH1 0x00 2692 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @268E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2692 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2693: // Incoming jump from 0x2689, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @269A memory[0x40:0x60] // @269B returndata.length // } 2693 5B JUMPDEST 2694 50 POP 2695 50 POP 2696 50 POP 2697 50 POP 2698 60 PUSH1 0x40 269A 51 MLOAD 269B 3D RETURNDATASIZE 269C 60 PUSH1 0x20 269E 81 DUP2 269F 10 LT 26A0 15 ISZERO 26A1 61 PUSH2 0x26a9 26A4 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @269A stack[-4] = memory[0x40:0x60] // @269B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x26a9, if !(returndata.length < 0x20) label_26A5: // Incoming jump from 0x26A4, if not !(returndata.length < 0x20) // Inputs[1] { @26A8 memory[0x00:0x00] } 26A5 60 PUSH1 0x00 26A7 80 DUP1 26A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @26A8 revert(memory[0x00:0x00]); } // Block terminates label_26A9: // Incoming jump from 0x26A4, if !(returndata.length < 0x20) // Inputs[4] // { // @26AB stack[-2] // @26AB memory[stack[-2]:stack[-2] + 0x20] // @26AC stack[-5] // @26AD stack[-4] // } 26A9 5B JUMPDEST 26AA 50 POP 26AB 51 MLOAD 26AC 92 SWAP3 26AD 91 SWAP2 26AE 50 POP 26AF 50 POP 26B0 56 *JUMP // Stack delta = -4 // Outputs[1] { @26AC stack[-5] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-5] label_26B1: // Incoming call from 0x0A1F, returns to 0x04E9 26B1 5B JUMPDEST 26B2 61 PUSH2 0x26b9 26B5 61 PUSH2 0x4380 26B8 56 *JUMP // Stack delta = +1 // Outputs[1] { @26B2 stack[0] = 0x26b9 } // Block ends with call to 0x4380, returns to 0x26B9 label_26B9: // Incoming return from call to 0x4380 at 0x26B8 // Inputs[2] // { // @26BC storage[0x65] // @26C8 stack[-1] // } 26B9 5B JUMPDEST 26BA 60 PUSH1 0x65 26BC 54 SLOAD 26BD 60 PUSH1 0x01 26BF 60 PUSH1 0x01 26C1 60 PUSH1 0xa0 26C3 1B SHL 26C4 03 SUB 26C5 90 SWAP1 26C6 81 DUP2 26C7 16 AND 26C8 91 SWAP2 26C9 16 AND 26CA 14 EQ 26CB 61 PUSH2 0x2709 26CE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2709, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] label_26CF: // Incoming jump from 0x26CE, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[5] // { // @26D2 memory[0x40:0x60] // @26ED memory[0x00:0x20] // @26F6 memory[0x00:0x20] // @26FF memory[0x40:0x60] // @2708 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 26CF 60 PUSH1 0x40 26D1 80 DUP1 26D2 51 MLOAD 26D3 62 PUSH3 0x461bcd 26D7 60 PUSH1 0xe5 26D9 1B SHL 26DA 81 DUP2 26DB 52 MSTORE 26DC 60 PUSH1 0x20 26DE 60 PUSH1 0x04 26E0 82 DUP3 26E1 01 ADD 26E2 81 DUP2 26E3 90 SWAP1 26E4 52 MSTORE 26E5 60 PUSH1 0x24 26E7 82 DUP3 26E8 01 ADD 26E9 52 MSTORE 26EA 60 PUSH1 0x00 26EC 80 DUP1 26ED 51 MLOAD 26EE 60 PUSH1 0x20 26F0 61 PUSH2 0x56b9 26F3 83 DUP4 26F4 39 CODECOPY 26F5 81 DUP2 26F6 51 MLOAD 26F7 91 SWAP2 26F8 52 MSTORE 26F9 60 PUSH1 0x44 26FB 82 DUP3 26FC 01 ADD 26FD 52 MSTORE 26FE 90 SWAP1 26FF 51 MLOAD 2700 90 SWAP1 2701 81 DUP2 2702 90 SWAP1 2703 03 SUB 2704 60 PUSH1 0x64 2706 01 ADD 2707 90 SWAP1 2708 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @26DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @26E4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @26E9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @26F4 memory[0x00:0x20] = code[0x56b9:0x56d9] // @26F8 memory[0x00:0x20] = memory[0x00:0x20] // @26FD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @2708 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2709: // Incoming jump from 0x26CE, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[5] // { // @270C storage[0x65] // @270F memory[0x40:0x60] // @2741 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2745 storage[0x65] // @2752 stack[-1] // } 2709 5B JUMPDEST 270A 60 PUSH1 0x65 270C 54 SLOAD 270D 60 PUSH1 0x40 270F 51 MLOAD 2710 60 PUSH1 0x00 2712 91 SWAP2 2713 60 PUSH1 0x01 2715 60 PUSH1 0x01 2717 60 PUSH1 0xa0 2719 1B SHL 271A 03 SUB 271B 16 AND 271C 90 SWAP1 271D 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 273E 90 SWAP1 273F 83 DUP4 2740 90 SWAP1 2741 A3 LOG3 2742 60 PUSH1 0x65 2744 80 DUP1 2745 54 SLOAD 2746 60 PUSH1 0x01 2748 60 PUSH1 0x01 274A 60 PUSH1 0xa0 274C 1B SHL 274D 03 SUB 274E 19 NOT 274F 16 AND 2750 90 SWAP1 2751 55 SSTORE 2752 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2741 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x65] & (0x01 << 0xa0) - 0x01, 0x00]); // @2751 storage[0x65] = ~((0x01 << 0xa0) - 0x01) & storage[0x65] // } // Block ends with unconditional jump to stack[-1] label_2753: // Incoming jump from 0x0A97 // Inputs[1] { @2756 storage[0x97] } 2753 5B JUMPDEST 2754 60 PUSH1 0x97 2756 54 SLOAD 2757 60 PUSH1 0x00 2759 90 SWAP1 275A 60 PUSH1 0x01 275C 60 PUSH1 0x01 275E 60 PUSH1 0xa0 2760 1B SHL 2761 03 SUB 2762 16 AND 2763 61 PUSH2 0x279c 2766 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2759 stack[0] = 0x00 } // Block ends with conditional jump to 0x279c, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_2767: // Incoming jump from 0x2766, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @276A memory[0x40:0x60] // @2792 memory[0x40:0x60] // @279B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2767 60 PUSH1 0x40 2769 80 DUP1 276A 51 MLOAD 276B 62 PUSH3 0x461bcd 276F 60 PUSH1 0xe5 2771 1B SHL 2772 81 DUP2 2773 52 MSTORE 2774 60 PUSH1 0x20 2776 60 PUSH1 0x04 2778 80 DUP1 2779 83 DUP4 277A 01 ADD 277B 91 SWAP2 277C 90 SWAP1 277D 91 SWAP2 277E 52 MSTORE 277F 60 PUSH1 0x24 2781 82 DUP3 2782 01 ADD 2783 52 MSTORE 2784 63 PUSH4 0x50523031 2789 60 PUSH1 0xe0 278B 1B SHL 278C 60 PUSH1 0x44 278E 82 DUP3 278F 01 ADD 2790 52 MSTORE 2791 90 SWAP1 2792 51 MLOAD 2793 90 SWAP1 2794 81 DUP2 2795 90 SWAP1 2796 03 SUB 2797 60 PUSH1 0x64 2799 01 ADD 279A 90 SWAP1 279B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2773 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @277E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2783 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2790 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @279B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_279C: // Incoming jump from 0x2766, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[1] { @279F storage[0x9c] } 279C 5B JUMPDEST 279D 60 PUSH1 0x9c 279F 54 SLOAD 27A0 60 PUSH1 0x01 27A2 60 PUSH1 0x01 27A4 60 PUSH1 0xa0 27A6 1B SHL 27A7 03 SUB 27A8 16 AND 27A9 61 PUSH2 0x27e2 27AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x27e2, if (0x01 << 0xa0) - 0x01 & storage[0x9c] label_27AD: // Incoming jump from 0x27AC, if not (0x01 << 0xa0) - 0x01 & storage[0x9c] // Inputs[3] // { // @27B0 memory[0x40:0x60] // @27D8 memory[0x40:0x60] // @27E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 27AD 60 PUSH1 0x40 27AF 80 DUP1 27B0 51 MLOAD 27B1 62 PUSH3 0x461bcd 27B5 60 PUSH1 0xe5 27B7 1B SHL 27B8 81 DUP2 27B9 52 MSTORE 27BA 60 PUSH1 0x20 27BC 60 PUSH1 0x04 27BE 80 DUP1 27BF 83 DUP4 27C0 01 ADD 27C1 91 SWAP2 27C2 90 SWAP1 27C3 91 SWAP2 27C4 52 MSTORE 27C5 60 PUSH1 0x24 27C7 82 DUP3 27C8 01 ADD 27C9 52 MSTORE 27CA 63 PUSH4 0x504f3033 27CF 60 PUSH1 0xe0 27D1 1B SHL 27D2 60 PUSH1 0x44 27D4 82 DUP3 27D5 01 ADD 27D6 52 MSTORE 27D7 90 SWAP1 27D8 51 MLOAD 27D9 90 SWAP1 27DA 81 DUP2 27DB 90 SWAP1 27DC 03 SUB 27DD 60 PUSH1 0x64 27DF 01 ADD 27E0 90 SWAP1 27E1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @27B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @27C4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @27C9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @27D6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x504f3033 << 0xe0 // @27E1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_27E2: // Incoming jump from 0x27AC, if (0x01 << 0xa0) - 0x01 & storage[0x9c] // Inputs[5] // { // @27E5 storage[0x97] // @27E9 memory[0x40:0x60] // @27F5 memory[0x40:0x60] // @27F6 stack[-5] // @2821 address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // } 27E2 5B JUMPDEST 27E3 60 PUSH1 0x97 27E5 54 SLOAD 27E6 60 PUSH1 0x40 27E8 80 DUP1 27E9 51 MLOAD 27EA 63 PUSH4 0x313ce567 27EF 60 PUSH1 0xe0 27F1 1B SHL 27F2 81 DUP2 27F3 52 MSTORE 27F4 90 SWAP1 27F5 51 MLOAD 27F6 87 DUP8 27F7 92 SWAP3 27F8 60 PUSH1 0x00 27FA 92 SWAP3 27FB 83 DUP4 27FC 92 SWAP3 27FD 83 DUP4 27FE 92 SWAP3 27FF 60 PUSH1 0x01 2801 60 PUSH1 0x01 2803 60 PUSH1 0xa0 2805 1B SHL 2806 03 SUB 2807 16 AND 2808 91 SWAP2 2809 63 PUSH4 0x313ce567 280E 91 SWAP2 280F 60 PUSH1 0x04 2811 80 DUP1 2812 83 DUP4 2813 01 ADD 2814 92 SWAP3 2815 60 PUSH1 0x20 2817 92 SWAP3 2818 91 SWAP2 2819 90 SWAP1 281A 82 DUP3 281B 90 SWAP1 281C 03 SUB 281D 01 ADD 281E 81 DUP2 281F 86 DUP7 2820 80 DUP1 2821 3B EXTCODESIZE 2822 15 ISZERO 2823 80 DUP1 2824 15 ISZERO 2825 61 PUSH2 0x282d 2828 57 *JUMPI // Stack delta = +13 // Outputs[14] // { // @27F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x313ce567 << 0xe0 // @27F7 stack[0] = stack[-5] // @27FA stack[1] = 0x00 // @27FC stack[2] = 0x00 // @27FE stack[3] = 0x00 // @2808 stack[4] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @280E stack[5] = 0x313ce567 // @2814 stack[6] = memory[0x40:0x60] + 0x04 // @2817 stack[7] = 0x20 // @2818 stack[8] = memory[0x40:0x60] // @281D stack[9] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @281E stack[10] = memory[0x40:0x60] // @281F stack[11] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @2822 stack[12] = !address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // } // Block ends with conditional jump to 0x282d, if !!address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length label_2829: // Incoming jump from 0x2828, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // Inputs[1] { @282C memory[0x00:0x00] } 2829 60 PUSH1 0x00 282B 80 DUP1 282C FD *REVERT // Stack delta = +0 // Outputs[1] { @282C revert(memory[0x00:0x00]); } // Block terminates label_282D: // Incoming jump from 0x2828, if !!address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // Inputs[8] // { // @282F msg.gas // @2830 stack[-2] // @2830 stack[-4] // @2830 stack[-6] // @2830 stack[-3] // @2830 stack[-5] // @2830 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2830 memory[stack[-3]:stack[-3] + stack[-4]] // } 282D 5B JUMPDEST 282E 50 POP 282F 5A GAS 2830 FA STATICCALL 2831 15 ISZERO 2832 80 DUP1 2833 15 ISZERO 2834 61 PUSH2 0x2841 2837 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2830 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2831 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2841, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2838: // Incoming jump from 0x2837, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2838 returndata.length // @283C returndata[0x00:0x00 + returndata.length] // @283D returndata.length // @2840 memory[0x00:0x00 + returndata.length] // } 2838 3D RETURNDATASIZE 2839 60 PUSH1 0x00 283B 80 DUP1 283C 3E RETURNDATACOPY 283D 3D RETURNDATASIZE 283E 60 PUSH1 0x00 2840 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @283C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2840 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2841: // Incoming jump from 0x2837, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2848 memory[0x40:0x60] // @2849 returndata.length // } 2841 5B JUMPDEST 2842 50 POP 2843 50 POP 2844 50 POP 2845 50 POP 2846 60 PUSH1 0x40 2848 51 MLOAD 2849 3D RETURNDATASIZE 284A 60 PUSH1 0x20 284C 81 DUP2 284D 10 LT 284E 15 ISZERO 284F 61 PUSH2 0x2857 2852 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2848 stack[-4] = memory[0x40:0x60] // @2849 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2857, if !(returndata.length < 0x20) label_2853: // Incoming jump from 0x2852, if not !(returndata.length < 0x20) // Inputs[1] { @2856 memory[0x00:0x00] } 2853 60 PUSH1 0x00 2855 80 DUP1 2856 FD *REVERT // Stack delta = +0 // Outputs[1] { @2856 revert(memory[0x00:0x00]); } // Block terminates label_2857: // Incoming jump from 0x2852, if !(returndata.length < 0x20) // Inputs[8] // { // @2859 stack[-2] // @2859 memory[stack[-2]:stack[-2] + 0x20] // @285C storage[0x9c] // @285F storage[0x97] // @2863 memory[0x40:0x60] // @286F memory[0x40:0x60] // @2871 stack[-3] // @28A2 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 2857 5B JUMPDEST 2858 50 POP 2859 51 MLOAD 285A 60 PUSH1 0x9c 285C 54 SLOAD 285D 60 PUSH1 0x97 285F 54 SLOAD 2860 60 PUSH1 0x40 2862 80 DUP1 2863 51 MLOAD 2864 63 PUSH4 0x95d89b41 2869 60 PUSH1 0xe0 286B 1B SHL 286C 81 DUP2 286D 52 MSTORE 286E 90 SWAP1 286F 51 MLOAD 2870 93 SWAP4 2871 94 SWAP5 2872 50 POP 2873 60 PUSH1 0x01 2875 60 PUSH1 0x01 2877 60 PUSH1 0xa0 2879 1B SHL 287A 03 SUB 287B 92 SWAP3 287C 83 DUP4 287D 16 AND 287E 93 SWAP4 287F 63 PUSH4 0x3d0f34da 2884 93 SWAP4 2885 90 SWAP1 2886 92 SWAP3 2887 16 AND 2888 91 SWAP2 2889 63 PUSH4 0x95d89b41 288E 91 SWAP2 288F 60 PUSH1 0x04 2891 80 DUP1 2892 82 DUP3 2893 01 ADD 2894 92 SWAP3 2895 60 PUSH1 0x00 2897 92 SWAP3 2898 90 SWAP1 2899 91 SWAP2 289A 90 SWAP1 289B 82 DUP3 289C 90 SWAP1 289D 03 SUB 289E 01 ADD 289F 81 DUP2 28A0 86 DUP7 28A1 80 DUP1 28A2 3B EXTCODESIZE 28A3 15 ISZERO 28A4 80 DUP1 28A5 15 ISZERO 28A6 61 PUSH2 0x28ae 28A9 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @286D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x95d89b41 << 0xe0 // @2871 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @287E stack[-2] = (0x01 << 0xa0) - 0x01 & storage[0x9c] // @2884 stack[-1] = 0x3d0f34da // @2888 stack[0] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @288E stack[1] = 0x95d89b41 // @2894 stack[2] = memory[0x40:0x60] + 0x04 // @2897 stack[3] = 0x00 // @2899 stack[4] = memory[0x40:0x60] // @289E stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @289F stack[6] = memory[0x40:0x60] // @28A0 stack[7] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @28A3 stack[8] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x28ae, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_28AA: // Incoming jump from 0x28A9, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @28AD memory[0x00:0x00] } 28AA 60 PUSH1 0x00 28AC 80 DUP1 28AD FD *REVERT // Stack delta = +0 // Outputs[1] { @28AD revert(memory[0x00:0x00]); } // Block terminates label_28AE: // Incoming jump from 0x28A9, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @28B0 msg.gas // @28B1 stack[-6] // @28B1 stack[-5] // @28B1 stack[-2] // @28B1 stack[-3] // @28B1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @28B1 stack[-4] // @28B1 memory[stack[-3]:stack[-3] + stack[-4]] // } 28AE 5B JUMPDEST 28AF 50 POP 28B0 5A GAS 28B1 FA STATICCALL 28B2 15 ISZERO 28B3 80 DUP1 28B4 15 ISZERO 28B5 61 PUSH2 0x28c2 28B8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @28B1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @28B2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x28c2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_28B9: // Incoming jump from 0x28B8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @28B9 returndata.length // @28BD returndata[0x00:0x00 + returndata.length] // @28BE returndata.length // @28C1 memory[0x00:0x00 + returndata.length] // } 28B9 3D RETURNDATASIZE 28BA 60 PUSH1 0x00 28BC 80 DUP1 28BD 3E RETURNDATACOPY 28BE 3D RETURNDATASIZE 28BF 60 PUSH1 0x00 28C1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @28BD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @28C1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_28C2: // Incoming jump from 0x28B8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @28C9 memory[0x40:0x60] // @28CA returndata.length // @28CE returndata[0x00:0x00 + returndata.length] // @28D1 returndata.length // } 28C2 5B JUMPDEST 28C3 50 POP 28C4 50 POP 28C5 50 POP 28C6 50 POP 28C7 60 PUSH1 0x40 28C9 51 MLOAD 28CA 3D RETURNDATASIZE 28CB 60 PUSH1 0x00 28CD 82 DUP3 28CE 3E RETURNDATACOPY 28CF 60 PUSH1 0x1f 28D1 3D RETURNDATASIZE 28D2 90 SWAP1 28D3 81 DUP2 28D4 01 ADD 28D5 60 PUSH1 0x1f 28D7 19 NOT 28D8 16 AND 28D9 82 DUP3 28DA 01 ADD 28DB 60 PUSH1 0x40 28DD 52 MSTORE 28DE 60 PUSH1 0x20 28E0 81 DUP2 28E1 10 LT 28E2 15 ISZERO 28E3 61 PUSH2 0x28eb 28E6 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @28C9 stack[-4] = memory[0x40:0x60] // @28CE memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @28D2 stack[-3] = returndata.length // @28DD memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // } // Block ends with conditional jump to 0x28eb, if !(returndata.length < 0x20) label_28E7: // Incoming jump from 0x28E6, if not !(returndata.length < 0x20) // Inputs[1] { @28EA memory[0x00:0x00] } 28E7 60 PUSH1 0x00 28E9 80 DUP1 28EA FD *REVERT // Stack delta = +0 // Outputs[1] { @28EA revert(memory[0x00:0x00]); } // Block terminates label_28EB: // Incoming jump from 0x28E6, if !(returndata.length < 0x20) // Inputs[4] // { // @28EC stack[-2] // @28ED stack[-1] // @28F1 memory[stack[-2]:stack[-2] + 0x20] // @28F4 memory[0x40:0x60] // } 28EB 5B JUMPDEST 28EC 81 DUP2 28ED 01 ADD 28EE 90 SWAP1 28EF 80 DUP1 28F0 80 DUP1 28F1 51 MLOAD 28F2 60 PUSH1 0x40 28F4 51 MLOAD 28F5 93 SWAP4 28F6 92 SWAP3 28F7 91 SWAP2 28F8 90 SWAP1 28F9 84 DUP5 28FA 60 PUSH1 0x01 28FC 60 PUSH1 0x20 28FE 1B SHL 28FF 82 DUP3 2900 11 GT 2901 15 ISZERO 2902 61 PUSH2 0x290a 2905 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @28F5 stack[-2] = memory[0x40:0x60] // @28F6 stack[-1] = stack[-2] + stack[-1] // @28F7 stack[0] = stack[-2] // @28F8 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @28F8 stack[1] = stack[-2] // @28F9 stack[3] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x290a, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_2906: // Incoming jump from 0x2905, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @2909 memory[0x00:0x00] } 2906 60 PUSH1 0x00 2908 80 DUP1 2909 FD *REVERT // Stack delta = +0 // Outputs[1] { @2909 revert(memory[0x00:0x00]); } // Block terminates label_290A: // Incoming jump from 0x2905, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[4] // { // @290B stack[-2] // @290B stack[-1] // @290C stack[-4] // @2913 stack[-5] // } 290A 5B JUMPDEST 290B 90 SWAP1 290C 83 DUP4 290D 01 ADD 290E 90 SWAP1 290F 60 PUSH1 0x20 2911 82 DUP3 2912 01 ADD 2913 85 DUP6 2914 81 DUP2 2915 11 GT 2916 15 ISZERO 2917 61 PUSH2 0x291f 291A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @290E stack[-2] = stack[-4] + stack[-2] // @290E stack[-1] = stack[-1] // @2912 stack[0] = stack[-4] + stack[-2] + 0x20 // } // Block ends with conditional jump to 0x291f, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_291B: // Incoming jump from 0x291A, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @291E memory[0x00:0x00] } 291B 60 PUSH1 0x00 291D 80 DUP1 291E FD *REVERT // Stack delta = +0 // Outputs[1] { @291E revert(memory[0x00:0x00]); } // Block terminates label_291F: // Incoming jump from 0x291A, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[4] // { // @2920 stack[-3] // @2921 memory[stack[-3]:stack[-3] + 0x20] // @2929 stack[-1] // @292C stack[-6] // } 291F 5B JUMPDEST 2920 82 DUP3 2921 51 MLOAD 2922 60 PUSH1 0x01 2924 60 PUSH1 0x20 2926 1B SHL 2927 81 DUP2 2928 11 GT 2929 82 DUP3 292A 82 DUP3 292B 01 ADD 292C 88 DUP9 292D 10 LT 292E 17 OR 292F 15 ISZERO 2930 61 PUSH2 0x2938 2933 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2921 stack[0] = memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2938, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) label_2934: // Incoming jump from 0x2933, if not !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[1] { @2937 memory[0x00:0x00] } 2934 60 PUSH1 0x00 2936 80 DUP1 2937 FD *REVERT // Stack delta = +0 // Outputs[1] { @2937 revert(memory[0x00:0x00]); } // Block terminates label_2938: // Incoming jump from 0x2933, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[4] // { // @2939 stack[-3] // @293A stack[-1] // @293C stack[-4] // @293D memory[stack[-4]:stack[-4] + 0x20] // } 2938 5B JUMPDEST 2939 82 DUP3 293A 52 MSTORE 293B 50 POP 293C 81 DUP2 293D 51 MLOAD 293E 60 PUSH1 0x20 2940 91 SWAP2 2941 82 DUP3 2942 01 ADD 2943 92 SWAP3 2944 90 SWAP1 2945 91 SWAP2 2946 01 ADD 2947 90 SWAP1 2948 80 DUP1 2949 83 DUP4 294A 83 DUP4 294B 60 PUSH1 0x00 294D 5B JUMPDEST 294E 83 DUP4 294F 81 DUP2 2950 10 LT 2951 15 ISZERO 2952 61 PUSH2 0x2965 2955 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @293A memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @2943 stack[-4] = 0x20 + stack[-3] // @2947 stack[-2] = memory[stack[-4]:stack[-4] + 0x20] // @2947 stack[-3] = 0x20 + stack[-4] // @2948 stack[-1] = memory[stack[-4]:stack[-4] + 0x20] // @2949 stack[0] = 0x20 + stack[-3] // @294A stack[1] = 0x20 + stack[-4] // @294B stack[2] = 0x00 // } // Block ends with conditional jump to 0x2965, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_2956: // Incoming jump from 0x2955, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2955, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2956 stack[-2] // @2957 stack[-1] // @2959 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @295A stack[-3] // } 2956 81 DUP2 2957 81 DUP2 2958 01 ADD 2959 51 MLOAD 295A 83 DUP4 295B 82 DUP3 295C 01 ADD 295D 52 MSTORE 295E 60 PUSH1 0x20 2960 01 ADD 2961 61 PUSH2 0x294d 2964 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @295D memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2960 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x294d label_2965: // Incoming jump from 0x2955, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2955, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @296A stack[-6] // @296A stack[-5] // @296C stack[-7] // } 2965 5B JUMPDEST 2966 50 POP 2967 50 POP 2968 50 POP 2969 50 POP 296A 90 SWAP1 296B 50 POP 296C 90 SWAP1 296D 81 DUP2 296E 01 ADD 296F 90 SWAP1 2970 60 PUSH1 0x1f 2972 16 AND 2973 80 DUP1 2974 15 ISZERO 2975 61 PUSH2 0x2992 2978 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @296F stack[-7] = stack[-5] + stack[-7] // @2972 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2992, if !(0x1f & stack[-5]) label_2979: // Incoming jump from 0x2978, if not !(0x1f & stack[-5]) // Inputs[10] // { // @2979 stack[-1] // @297A stack[-2] // @297D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @299A stack[-16] // @299B stack[-15] // @299E memory[0x40:0x60] // @299F stack[-7] // @29BC stack[-6] // @29BF memory[stack[-6]:stack[-6] + 0x20] // @29C8 memory[stack[-6]:stack[-6] + 0x20] // } 2979 80 DUP1 297A 82 DUP3 297B 03 SUB 297C 80 DUP1 297D 51 MLOAD 297E 60 PUSH1 0x01 2980 83 DUP4 2981 60 PUSH1 0x20 2983 03 SUB 2984 61 PUSH2 0x0100 2987 0A EXP 2988 03 SUB 2989 19 NOT 298A 16 AND 298B 81 DUP2 298C 52 MSTORE 298D 60 PUSH1 0x20 298F 01 ADD 2990 91 SWAP2 2991 50 POP 2992 5B JUMPDEST 2993 50 POP 2994 60 PUSH1 0x40 2996 52 MSTORE 2997 50 POP 2998 50 POP 2999 50 POP 299A 8A DUP11 299B 8A DUP11 299C 60 PUSH1 0x40 299E 51 MLOAD 299F 84 DUP5 29A0 63 PUSH4 0xffffffff 29A5 16 AND 29A6 60 PUSH1 0xe0 29A8 1B SHL 29A9 81 DUP2 29AA 52 MSTORE 29AB 60 PUSH1 0x04 29AD 01 ADD 29AE 80 DUP1 29AF 80 DUP1 29B0 60 PUSH1 0x20 29B2 01 ADD 29B3 80 DUP1 29B4 60 PUSH1 0x20 29B6 01 ADD 29B7 83 DUP4 29B8 81 DUP2 29B9 03 SUB 29BA 83 DUP4 29BB 52 MSTORE 29BC 86 DUP7 29BD 81 DUP2 29BE 81 DUP2 29BF 51 MLOAD 29C0 81 DUP2 29C1 52 MSTORE 29C2 60 PUSH1 0x20 29C4 01 ADD 29C5 91 SWAP2 29C6 50 POP 29C7 80 DUP1 29C8 51 MLOAD 29C9 90 SWAP1 29CA 60 PUSH1 0x20 29CC 01 ADD 29CD 90 SWAP1 29CE 80 DUP1 29CF 83 DUP4 29D0 83 DUP4 29D1 60 PUSH1 0x00 29D3 5B JUMPDEST 29D4 83 DUP4 29D5 81 DUP2 29D6 10 LT 29D7 15 ISZERO 29D8 61 PUSH2 0x29eb 29DB 57 *JUMPI // Stack delta = +7 // Outputs[17] // { // @298C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2996 memory[0x40:0x60] = 0x20 + (stack[-2] - stack[-1]) // @299A stack[-5] = stack[-16] // @299B stack[-4] = stack[-15] // @29AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-7]) << 0xe0 // @29AD stack[-3] = 0x04 + memory[0x40:0x60] // @29AE stack[-2] = 0x04 + memory[0x40:0x60] // @29B2 stack[-1] = 0x20 + 0x04 + memory[0x40:0x60] // @29BB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @29C1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @29C5 stack[0] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @29CD stack[2] = memory[stack[-6]:stack[-6] + 0x20] // @29CD stack[1] = 0x20 + stack[-6] // @29CE stack[3] = memory[stack[-6]:stack[-6] + 0x20] // @29CF stack[4] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @29D0 stack[5] = 0x20 + stack[-6] // @29D1 stack[6] = 0x00 // } // Block ends with conditional jump to 0x29eb, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_29DC: // Incoming jump from 0x29DB, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x29DB, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x29DB, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @29DC stack[-2] // @29DD stack[-1] // @29DF memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @29E0 stack[-3] // } 29DC 81 DUP2 29DD 81 DUP2 29DE 01 ADD 29DF 51 MLOAD 29E0 83 DUP4 29E1 82 DUP3 29E2 01 ADD 29E3 52 MSTORE 29E4 60 PUSH1 0x20 29E6 01 ADD 29E7 61 PUSH2 0x29d3 29EA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @29E3 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @29E6 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x29d3 label_29EB: // Incoming jump from 0x29DB, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x29DB, if !(stack[-1] < stack[-4]) // Incoming jump from 0x29DB, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @29F0 stack[-6] // @29F0 stack[-5] // @29F2 stack[-7] // } 29EB 5B JUMPDEST 29EC 50 POP 29ED 50 POP 29EE 50 POP 29EF 50 POP 29F0 90 SWAP1 29F1 50 POP 29F2 90 SWAP1 29F3 81 DUP2 29F4 01 ADD 29F5 90 SWAP1 29F6 60 PUSH1 0x1f 29F8 16 AND 29F9 80 DUP1 29FA 15 ISZERO 29FB 61 PUSH2 0x2a18 29FE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @29F5 stack[-7] = stack[-5] + stack[-7] // @29F8 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2a18, if !(0x1f & stack[-5]) label_29FF: // Incoming jump from 0x29FE, if not !(0x1f & stack[-5]) // Inputs[12] // { // @29FF stack[-1] // @2A00 stack[-2] // @2A03 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2A1A stack[-5] // @2A1D stack[-3] // @2A1F stack[-6] // @2A25 stack[-7] // @2A2A msg.data[stack[-7]:stack[-7] + stack[-6]] // @2A42 stack[-8] // @2A4C memory[0x40:0x60] // @2A51 stack[-10] // @2A53 address(stack[-10]).code.length // } 29FF 80 DUP1 2A00 82 DUP3 2A01 03 SUB 2A02 80 DUP1 2A03 51 MLOAD 2A04 60 PUSH1 0x01 2A06 83 DUP4 2A07 60 PUSH1 0x20 2A09 03 SUB 2A0A 61 PUSH2 0x0100 2A0D 0A EXP 2A0E 03 SUB 2A0F 19 NOT 2A10 16 AND 2A11 81 DUP2 2A12 52 MSTORE 2A13 60 PUSH1 0x20 2A15 01 ADD 2A16 91 SWAP2 2A17 50 POP 2A18 5B JUMPDEST 2A19 50 POP 2A1A 83 DUP4 2A1B 81 DUP2 2A1C 03 SUB 2A1D 82 DUP3 2A1E 52 MSTORE 2A1F 84 DUP5 2A20 81 DUP2 2A21 52 MSTORE 2A22 60 PUSH1 0x20 2A24 01 ADD 2A25 85 DUP6 2A26 85 DUP6 2A27 80 DUP1 2A28 82 DUP3 2A29 84 DUP5 2A2A 37 CALLDATACOPY 2A2B 60 PUSH1 0x00 2A2D 81 DUP2 2A2E 84 DUP5 2A2F 01 ADD 2A30 52 MSTORE 2A31 60 PUSH1 0x1f 2A33 19 NOT 2A34 60 PUSH1 0x1f 2A36 82 DUP3 2A37 01 ADD 2A38 16 AND 2A39 90 SWAP1 2A3A 50 POP 2A3B 80 DUP1 2A3C 83 DUP4 2A3D 01 ADD 2A3E 92 SWAP3 2A3F 50 POP 2A40 50 POP 2A41 50 POP 2A42 95 SWAP6 2A43 50 POP 2A44 50 POP 2A45 50 POP 2A46 50 POP 2A47 50 POP 2A48 50 POP 2A49 60 PUSH1 0x40 2A4B 80 DUP1 2A4C 51 MLOAD 2A4D 80 DUP1 2A4E 83 DUP4 2A4F 03 SUB 2A50 81 DUP2 2A51 86 DUP7 2A52 80 DUP1 2A53 3B EXTCODESIZE 2A54 15 ISZERO 2A55 80 DUP1 2A56 15 ISZERO 2A57 61 PUSH2 0x2a5f 2A5A 57 *JUMPI // Stack delta = -1 // Outputs[12] // { // @2A12 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2A1E memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @2A21 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = stack[-6] // @2A2A memory[0x20 + 0x20 + (stack[-2] - stack[-1]):0x20 + 0x20 + (stack[-2] - stack[-1]) + stack[-6]] = msg.data[stack[-7]:stack[-7] + stack[-6]] // @2A30 memory[0x20 + 0x20 + (stack[-2] - stack[-1]) + stack[-6]:0x20 + 0x20 + (stack[-2] - stack[-1]) + stack[-6] + 0x20] = 0x00 // @2A42 stack[-8] = 0x20 + 0x20 + (stack[-2] - stack[-1]) + (stack[-6] + 0x1f & ~0x1f) // @2A49 stack[-7] = 0x40 // @2A4C stack[-6] = memory[0x40:0x60] // @2A4F stack[-5] = (0x20 + 0x20 + (stack[-2] - stack[-1]) + (stack[-6] + 0x1f & ~0x1f)) - memory[0x40:0x60] // @2A50 stack[-4] = memory[0x40:0x60] // @2A51 stack[-3] = stack[-10] // @2A54 stack[-2] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x2a5f, if !!address(stack[-10]).code.length label_2A5B: // Incoming jump from 0x2A5A, if not !!address(stack[-10]).code.length // Incoming jump from 0x2A5A, if not !!address(stack[-10]).code.length // Inputs[1] { @2A5E memory[0x00:0x00] } 2A5B 60 PUSH1 0x00 2A5D 80 DUP1 2A5E FD *REVERT // Stack delta = +0 // Outputs[1] { @2A5E revert(memory[0x00:0x00]); } // Block terminates label_2A5F: // Incoming jump from 0x2A5A, if !!address(stack[-10]).code.length // Incoming jump from 0x2A5A, if !!address(stack[-10]).code.length // Inputs[8] // { // @2A61 msg.gas // @2A62 stack[-6] // @2A62 stack[-4] // @2A62 stack[-2] // @2A62 stack[-3] // @2A62 memory[stack[-3]:stack[-3] + stack[-4]] // @2A62 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2A62 stack[-5] // } 2A5F 5B JUMPDEST 2A60 50 POP 2A61 5A GAS 2A62 FA STATICCALL 2A63 15 ISZERO 2A64 80 DUP1 2A65 15 ISZERO 2A66 61 PUSH2 0x2a73 2A69 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2A62 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2A63 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2a73, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2A6A: // Incoming jump from 0x2A69, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2A6A returndata.length // @2A6E returndata[0x00:0x00 + returndata.length] // @2A6F returndata.length // @2A72 memory[0x00:0x00 + returndata.length] // } 2A6A 3D RETURNDATASIZE 2A6B 60 PUSH1 0x00 2A6D 80 DUP1 2A6E 3E RETURNDATACOPY 2A6F 3D RETURNDATASIZE 2A70 60 PUSH1 0x00 2A72 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2A6E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2A72 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2A73: // Incoming jump from 0x2A69, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2A7A memory[0x40:0x60] // @2A7B returndata.length // } 2A73 5B JUMPDEST 2A74 50 POP 2A75 50 POP 2A76 50 POP 2A77 50 POP 2A78 60 PUSH1 0x40 2A7A 51 MLOAD 2A7B 3D RETURNDATASIZE 2A7C 60 PUSH1 0x40 2A7E 81 DUP2 2A7F 10 LT 2A80 15 ISZERO 2A81 61 PUSH2 0x2a89 2A84 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2A7A stack[-4] = memory[0x40:0x60] // @2A7B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2a89, if !(returndata.length < 0x40) label_2A85: // Incoming jump from 0x2A84, if not !(returndata.length < 0x40) // Inputs[1] { @2A88 memory[0x00:0x00] } 2A85 60 PUSH1 0x00 2A87 80 DUP1 2A88 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A88 revert(memory[0x00:0x00]); } // Block terminates label_2A89: // Incoming jump from 0x2A84, if !(returndata.length < 0x40) // Inputs[6] // { // @2A8B stack[-2] // @2A8C memory[stack[-2]:stack[-2] + 0x20] // @2A92 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2A94 stack[-5] // @2A96 stack[-4] // @2A9B stack[-8] // } 2A89 5B JUMPDEST 2A8A 50 POP 2A8B 80 DUP1 2A8C 51 MLOAD 2A8D 60 PUSH1 0x20 2A8F 90 SWAP1 2A90 91 SWAP2 2A91 01 ADD 2A92 51 MLOAD 2A93 90 SWAP1 2A94 93 SWAP4 2A95 50 POP 2A96 91 SWAP2 2A97 50 POP 2A98 60 PUSH1 0xff 2A9A 80 DUP1 2A9B 87 DUP8 2A9C 16 AND 2A9D 90 SWAP1 2A9E 83 DUP4 2A9F 16 AND 2AA0 11 GT 2AA1 15 ISZERO 2AA2 61 PUSH2 0x2ac3 2AA5 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2A94 stack[-5] = memory[stack[-2]:stack[-2] + 0x20] // @2A96 stack[-4] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2ac3, if !(memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xff > stack[-8] & 0xff) label_2AA6: // Incoming jump from 0x2AA5, if not !(memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xff > stack[-8] & 0xff) // Inputs[3] // { // @2AA9 stack[-3] // @2AAC stack[-6] // @2AAD stack[-2] // } 2AA6 61 PUSH2 0x2abd 2AA9 83 DUP4 2AAA 60 PUSH1 0xff 2AAC 88 DUP9 2AAD 85 DUP6 2AAE 03 SUB 2AAF 16 AND 2AB0 60 PUSH1 0x0a 2AB2 0A EXP 2AB3 63 PUSH4 0xffffffff 2AB8 61 PUSH2 0x4a9d 2ABB 16 AND 2ABC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2AA6 stack[0] = 0x2abd // @2AA9 stack[1] = stack[-3] // @2AB2 stack[2] = 0x0a ** (stack[-2] - stack[-6] & 0xff) // } // Block ends with unconditional jump to 0x4a9d & 0xffffffff 2ABD 5B JUMPDEST 2ABE 92 SWAP3 2ABF 50 POP 2AC0 85 DUP6 2AC1 91 SWAP2 2AC2 50 POP label_2AC3: // Incoming jump from 0x2AA5, if !(memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xff > stack[-8] & 0xff) // Inputs[2] // { // @2AC4 stack[-6] // @2AC8 stack[-1] // } 2AC3 5B JUMPDEST 2AC4 85 DUP6 2AC5 60 PUSH1 0xff 2AC7 16 AND 2AC8 81 DUP2 2AC9 60 PUSH1 0xff 2ACB 16 AND 2ACC 11 GT 2ACD 15 ISZERO 2ACE 61 PUSH2 0x2aef 2AD1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2aef, if !(0xff & stack[-1] > 0xff & stack[-6]) label_2AD2: // Incoming jump from 0x2AD1, if not !(0xff & stack[-1] > 0xff & stack[-6]) // Inputs[3] // { // @2AD5 stack[-4] // @2AD8 stack[-6] // @2AD9 stack[-1] // } 2AD2 61 PUSH2 0x2ae9 2AD5 84 DUP5 2AD6 60 PUSH1 0xff 2AD8 88 DUP9 2AD9 84 DUP5 2ADA 03 SUB 2ADB 16 AND 2ADC 60 PUSH1 0x0a 2ADE 0A EXP 2ADF 63 PUSH4 0xffffffff 2AE4 61 PUSH2 0x4a9d 2AE7 16 AND 2AE8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2AD2 stack[0] = 0x2ae9 // @2AD5 stack[1] = stack[-4] // @2ADE stack[2] = 0x0a ** (stack[-1] - stack[-6] & 0xff) // } // Block ends with unconditional jump to 0x4a9d & 0xffffffff 2AE9 5B JUMPDEST 2AEA 93 SWAP4 2AEB 50 POP 2AEC 85 DUP6 2AED 90 SWAP1 2AEE 50 POP label_2AEF: // Incoming jump from 0x2AD1, if !(0xff & stack[-1] > 0xff & stack[-6]) // Inputs[5] // { // @2AF7 stack[-6] // @2AF9 stack[-2] // @2AFC stack[-1] // @2B06 stack[-4] // @2B07 stack[-3] // } 2AEF 5B JUMPDEST 2AF0 61 PUSH2 0x2b1e 2AF3 60 PUSH1 0xff 2AF5 60 PUSH1 0x02 2AF7 88 DUP9 2AF8 02 MUL 2AF9 84 DUP5 2AFA 90 SWAP1 2AFB 03 SUB 2AFC 83 DUP4 2AFD 90 SWAP1 2AFE 03 SUB 2AFF 16 AND 2B00 60 PUSH1 0x0a 2B02 0A EXP 2B03 61 PUSH2 0x2b12 2B06 86 DUP7 2B07 86 DUP7 2B08 63 PUSH4 0xffffffff 2B0D 61 PUSH2 0x4ae6 2B10 16 AND 2B11 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2AF0 stack[0] = 0x2b1e // @2B02 stack[1] = 0x0a ** (stack[-6] * 0x02 - stack[-2] - stack[-1] & 0xff) // @2B03 stack[2] = 0x2b12 // @2B06 stack[3] = stack[-4] // @2B07 stack[4] = stack[-3] // } // Block ends with call to 0x4ae6 & 0xffffffff, returns to 0x2B12 label_2B12: // Incoming return from call to 0x4AE6 at 0x2B11 // Inputs[2] // { // @2B13 stack[-1] // @2B13 stack[-2] // } 2B12 5B JUMPDEST 2B13 90 SWAP1 2B14 63 PUSH4 0xffffffff 2B19 61 PUSH2 0x4ae6 2B1C 16 AND 2B1D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2B13 stack[-1] = stack[-2] // @2B13 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x4ae6 & 0xffffffff label_2B1E: // Incoming return from call to 0x2B12 at 0x2B11 // Inputs[3] // { // @2B1F stack[-11] // @2B1F stack[-1] // @2B20 stack[-10] // } 2B1E 5B JUMPDEST 2B1F 99 SWAP10 2B20 98 SWAP9 2B21 50 POP 2B22 50 POP 2B23 50 POP 2B24 50 POP 2B25 50 POP 2B26 50 POP 2B27 50 POP 2B28 50 POP 2B29 50 POP 2B2A 56 *JUMP // Stack delta = -10 // Outputs[1] { @2B1F stack[-11] = stack[-1] } // Block ends with unconditional jump to stack[-11] label_2B2B: // Incoming jump from 0x0ABD // Inputs[4] // { // @2B34 stack[-1] // @2B3A memory[0x00:0x40] // @2B3B storage[keccak256(memory[0x00:0x40])] // @2B3C stack[-2] // } 2B2B 5B JUMPDEST 2B2C 61 PUSH2 0x0106 2B2F 60 PUSH1 0x20 2B31 52 MSTORE 2B32 60 PUSH1 0x00 2B34 90 SWAP1 2B35 81 DUP2 2B36 52 MSTORE 2B37 60 PUSH1 0x40 2B39 90 SWAP1 2B3A 20 SHA3 2B3B 54 SLOAD 2B3C 81 DUP2 2B3D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2B31 memory[0x20:0x40] = 0x0106 // @2B36 memory[0x00:0x20] = stack[-1] // @2B3B stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_2B3E: // Incoming jump from 0x0B2B 2B3E 5B JUMPDEST 2B3F 61 PUSH2 0x2b46 2B42 61 PUSH2 0x4380 2B45 56 *JUMP // Stack delta = +1 // Outputs[1] { @2B3F stack[0] = 0x2b46 } // Block ends with call to 0x4380, returns to 0x2B46 label_2B46: // Incoming return from call to 0x4380 at 0x2B45 // Inputs[1] { @2B4F stack[-1] } 2B46 5B JUMPDEST 2B47 60 PUSH1 0x01 2B49 60 PUSH1 0x01 2B4B 60 PUSH1 0xa0 2B4D 1B SHL 2B4E 03 SUB 2B4F 16 AND 2B50 61 PUSH2 0x2b57 2B53 61 PUSH2 0x2daa 2B56 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2B4F stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2B50 stack[0] = 0x2b57 // } // Block ends with call to 0x2daa, returns to 0x2B57 label_2B57: // Incoming return from call to 0x2DAA at 0x2B56 // Inputs[2] // { // @2B60 stack[-1] // @2B61 stack[-2] // } 2B57 5B JUMPDEST 2B58 60 PUSH1 0x01 2B5A 60 PUSH1 0x01 2B5C 60 PUSH1 0xa0 2B5E 1B SHL 2B5F 03 SUB 2B60 16 AND 2B61 14 EQ 2B62 80 DUP1 2B63 61 PUSH2 0x2b72 2B66 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2B61 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x2b72, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_2B67: // Incoming jump from 0x2B66, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 2B67 50 POP 2B68 61 PUSH2 0x2b72 2B6B 61 PUSH2 0x153d 2B6E 61 PUSH2 0x4380 2B71 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2B68 stack[-1] = 0x2b72 // @2B6B stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_2B72: // Incoming jump from 0x2B66, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @2B76 stack[-1] } 2B72 5B JUMPDEST 2B73 61 PUSH2 0x2bac 2B76 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2bac, if stack[-1] label_2B77: // Incoming jump from 0x2B76, if not stack[-1] // Inputs[3] // { // @2B7A memory[0x40:0x60] // @2BA2 memory[0x40:0x60] // @2BAB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2B77 60 PUSH1 0x40 2B79 80 DUP1 2B7A 51 MLOAD 2B7B 62 PUSH3 0x461bcd 2B7F 60 PUSH1 0xe5 2B81 1B SHL 2B82 81 DUP2 2B83 52 MSTORE 2B84 60 PUSH1 0x20 2B86 60 PUSH1 0x04 2B88 80 DUP1 2B89 83 DUP4 2B8A 01 ADD 2B8B 91 SWAP2 2B8C 90 SWAP1 2B8D 91 SWAP2 2B8E 52 MSTORE 2B8F 60 PUSH1 0x24 2B91 82 DUP3 2B92 01 ADD 2B93 52 MSTORE 2B94 63 PUSH4 0x41443031 2B99 60 PUSH1 0xe0 2B9B 1B SHL 2B9C 60 PUSH1 0x44 2B9E 82 DUP3 2B9F 01 ADD 2BA0 52 MSTORE 2BA1 90 SWAP1 2BA2 51 MLOAD 2BA3 90 SWAP1 2BA4 81 DUP2 2BA5 90 SWAP1 2BA6 03 SUB 2BA7 60 PUSH1 0x64 2BA9 01 ADD 2BAA 90 SWAP1 2BAB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2B83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2B8E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2B93 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2BA0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @2BAB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2BAC: // Incoming jump from 0x2B76, if stack[-1] // Inputs[2] // { // @2BB3 stack[-2] // @2BB4 stack[-1] // } 2BAC 5B JUMPDEST 2BAD 61 PUSH2 0x2bb9 2BB0 61 PUSH2 0x0104 2BB3 83 DUP4 2BB4 83 DUP4 2BB5 61 PUSH2 0x54e3 2BB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2BAD stack[0] = 0x2bb9 // @2BB0 stack[1] = 0x0104 // @2BB3 stack[2] = stack[-2] // @2BB4 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x54e3 2BB9 5B JUMPDEST 2BBA 50 POP 2BBB 7F PUSH32 0xf9899ddebaa7f77fdae22ed7ae5f68a84752a461fd088c59c7ea3a33cd2c0e0a 2BDC 82 DUP3 2BDD 82 DUP3 2BDE 60 PUSH1 0x40 2BE0 51 MLOAD 2BE1 80 DUP1 2BE2 80 DUP1 2BE3 60 PUSH1 0x20 2BE5 01 ADD 2BE6 82 DUP3 2BE7 81 DUP2 2BE8 03 SUB 2BE9 82 DUP3 2BEA 52 MSTORE 2BEB 84 DUP5 2BEC 84 DUP5 2BED 82 DUP3 2BEE 81 DUP2 2BEF 81 DUP2 2BF0 52 MSTORE 2BF1 60 PUSH1 0x20 2BF3 01 ADD 2BF4 92 SWAP3 2BF5 50 POP 2BF6 80 DUP1 2BF7 82 DUP3 2BF8 84 DUP5 2BF9 37 CALLDATACOPY 2BFA 60 PUSH1 0x00 2BFC 83 DUP4 2BFD 82 DUP3 2BFE 01 ADD 2BFF 52 MSTORE 2C00 60 PUSH1 0x40 2C02 51 MLOAD 2C03 60 PUSH1 0x1f 2C05 90 SWAP1 2C06 91 SWAP2 2C07 01 ADD 2C08 60 PUSH1 0x1f 2C0A 19 NOT 2C0B 16 AND 2C0C 90 SWAP1 2C0D 92 SWAP3 2C0E 01 ADD 2C0F 82 DUP3 2C10 90 SWAP1 2C11 03 SUB 2C12 95 SWAP6 2C13 50 POP 2C14 90 SWAP1 2C15 93 SWAP4 2C16 50 POP 2C17 50 POP 2C18 50 POP 2C19 50 POP 2C1A A1 LOG1 2C1B 50 POP 2C1C 50 POP 2C1D 56 *JUMP label_2C1E: // Incoming jump from 0x0BE9 2C1E 5B JUMPDEST 2C1F 61 PUSH2 0x2c26 2C22 61 PUSH2 0x4380 2C25 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C1F stack[0] = 0x2c26 } // Block ends with call to 0x4380, returns to 0x2C26 label_2C26: // Incoming return from call to 0x4380 at 0x2C25 // Inputs[1] { @2C2F stack[-1] } 2C26 5B JUMPDEST 2C27 60 PUSH1 0x01 2C29 60 PUSH1 0x01 2C2B 60 PUSH1 0xa0 2C2D 1B SHL 2C2E 03 SUB 2C2F 16 AND 2C30 61 PUSH2 0x2c37 2C33 61 PUSH2 0x2daa 2C36 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2C2F stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2C30 stack[0] = 0x2c37 // } // Block ends with call to 0x2daa, returns to 0x2C37 label_2C37: // Incoming return from call to 0x2DAA at 0x2C36 // Inputs[2] // { // @2C40 stack[-1] // @2C41 stack[-2] // } 2C37 5B JUMPDEST 2C38 60 PUSH1 0x01 2C3A 60 PUSH1 0x01 2C3C 60 PUSH1 0xa0 2C3E 1B SHL 2C3F 03 SUB 2C40 16 AND 2C41 14 EQ 2C42 80 DUP1 2C43 61 PUSH2 0x2c52 2C46 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2C41 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x2c52, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_2C47: // Incoming jump from 0x2C46, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 2C47 50 POP 2C48 61 PUSH2 0x2c52 2C4B 61 PUSH2 0x153d 2C4E 61 PUSH2 0x4380 2C51 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2C48 stack[-1] = 0x2c52 // @2C4B stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_2C52: // Incoming jump from 0x2C46, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @2C56 stack[-1] } 2C52 5B JUMPDEST 2C53 61 PUSH2 0x2c8c 2C56 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2c8c, if stack[-1] label_2C57: // Incoming jump from 0x2C56, if not stack[-1] // Inputs[3] // { // @2C5A memory[0x40:0x60] // @2C82 memory[0x40:0x60] // @2C8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2C57 60 PUSH1 0x40 2C59 80 DUP1 2C5A 51 MLOAD 2C5B 62 PUSH3 0x461bcd 2C5F 60 PUSH1 0xe5 2C61 1B SHL 2C62 81 DUP2 2C63 52 MSTORE 2C64 60 PUSH1 0x20 2C66 60 PUSH1 0x04 2C68 80 DUP1 2C69 83 DUP4 2C6A 01 ADD 2C6B 91 SWAP2 2C6C 90 SWAP1 2C6D 91 SWAP2 2C6E 52 MSTORE 2C6F 60 PUSH1 0x24 2C71 82 DUP3 2C72 01 ADD 2C73 52 MSTORE 2C74 63 PUSH4 0x41443031 2C79 60 PUSH1 0xe0 2C7B 1B SHL 2C7C 60 PUSH1 0x44 2C7E 82 DUP3 2C7F 01 ADD 2C80 52 MSTORE 2C81 90 SWAP1 2C82 51 MLOAD 2C83 90 SWAP1 2C84 81 DUP2 2C85 90 SWAP1 2C86 03 SUB 2C87 60 PUSH1 0x64 2C89 01 ADD 2C8A 90 SWAP1 2C8B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2C63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2C6E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2C73 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2C80 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @2C8B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2C8C: // Incoming jump from 0x2C56, if stack[-1] // Inputs[2] // { // @2C8D stack[-3] // @2C8E stack[-1] // } 2C8C 5B JUMPDEST 2C8D 82 DUP3 2C8E 81 DUP2 2C8F 14 EQ 2C90 61 PUSH2 0x2cc9 2C93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2cc9, if stack[-1] == stack[-3] label_2C94: // Incoming jump from 0x2C93, if not stack[-1] == stack[-3] // Inputs[3] // { // @2C97 memory[0x40:0x60] // @2CBF memory[0x40:0x60] // @2CC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2C94 60 PUSH1 0x40 2C96 80 DUP1 2C97 51 MLOAD 2C98 62 PUSH3 0x461bcd 2C9C 60 PUSH1 0xe5 2C9E 1B SHL 2C9F 81 DUP2 2CA0 52 MSTORE 2CA1 60 PUSH1 0x20 2CA3 60 PUSH1 0x04 2CA5 80 DUP1 2CA6 83 DUP4 2CA7 01 ADD 2CA8 91 SWAP2 2CA9 90 SWAP1 2CAA 91 SWAP2 2CAB 52 MSTORE 2CAC 60 PUSH1 0x24 2CAE 82 DUP3 2CAF 01 ADD 2CB0 52 MSTORE 2CB1 63 PUSH4 0x52553031 2CB6 60 PUSH1 0xe0 2CB8 1B SHL 2CB9 60 PUSH1 0x44 2CBB 82 DUP3 2CBC 01 ADD 2CBD 52 MSTORE 2CBE 90 SWAP1 2CBF 51 MLOAD 2CC0 90 SWAP1 2CC1 81 DUP2 2CC2 90 SWAP1 2CC3 03 SUB 2CC4 60 PUSH1 0x64 2CC6 01 ADD 2CC7 90 SWAP1 2CC8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2CA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2CAB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2CB0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2CBD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x52553031 << 0xe0 // @2CC8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2CC9: // Incoming jump from 0x2C93, if stack[-1] == stack[-3] // Inputs[2] // { // @2CD0 stack[-4] // @2CD1 stack[-3] // } 2CC9 5B JUMPDEST 2CCA 61 PUSH2 0x2cd6 2CCD 61 PUSH2 0x0102 2CD0 85 DUP6 2CD1 85 DUP6 2CD2 61 PUSH2 0x555d 2CD5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2CCA stack[0] = 0x2cd6 // @2CCD stack[1] = 0x0102 // @2CD0 stack[2] = stack[-4] // @2CD1 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x555d 2CD6 5B JUMPDEST 2CD7 50 POP 2CD8 61 PUSH2 0x2ce4 2CDB 61 PUSH2 0x0103 2CDE 83 DUP4 2CDF 83 DUP4 2CE0 61 PUSH2 0x555d 2CE3 56 *JUMP 2CE4 5B JUMPDEST 2CE5 50 POP 2CE6 7F PUSH32 0xea151774b9c9cb9dbecc6a5859099bc715b907ebd16cb2d48a2fc63ab3e29f12 2D07 61 PUSH2 0x0102 2D0A 61 PUSH2 0x0103 2D0D 60 PUSH1 0x40 2D0F 51 MLOAD 2D10 80 DUP1 2D11 80 DUP1 2D12 60 PUSH1 0x20 2D14 01 ADD 2D15 80 DUP1 2D16 60 PUSH1 0x20 2D18 01 ADD 2D19 83 DUP4 2D1A 81 DUP2 2D1B 03 SUB 2D1C 83 DUP4 2D1D 52 MSTORE 2D1E 85 DUP6 2D1F 81 DUP2 2D20 81 DUP2 2D21 54 SLOAD 2D22 81 DUP2 2D23 52 MSTORE 2D24 60 PUSH1 0x20 2D26 01 ADD 2D27 91 SWAP2 2D28 50 POP 2D29 80 DUP1 2D2A 54 SLOAD 2D2B 80 DUP1 2D2C 15 ISZERO 2D2D 61 PUSH2 0x2d55 2D30 57 *JUMPI 2D31 60 PUSH1 0x20 2D33 02 MUL 2D34 82 DUP3 2D35 01 ADD 2D36 91 SWAP2 2D37 90 SWAP1 2D38 60 PUSH1 0x00 2D3A 52 MSTORE 2D3B 60 PUSH1 0x20 2D3D 60 PUSH1 0x00 2D3F 20 SHA3 2D40 90 SWAP1 2D41 5B JUMPDEST 2D42 81 DUP2 2D43 54 SLOAD 2D44 81 DUP2 2D45 52 MSTORE 2D46 60 PUSH1 0x20 2D48 01 ADD 2D49 90 SWAP1 2D4A 60 PUSH1 0x01 2D4C 01 ADD 2D4D 90 SWAP1 2D4E 80 DUP1 2D4F 83 DUP4 2D50 11 GT 2D51 61 PUSH2 0x2d41 2D54 57 *JUMPI 2D55 5B JUMPDEST 2D56 50 POP 2D57 50 POP 2D58 83 DUP4 2D59 81 DUP2 2D5A 03 SUB 2D5B 82 DUP3 2D5C 52 MSTORE 2D5D 84 DUP5 2D5E 81 DUP2 2D5F 81 DUP2 2D60 54 SLOAD 2D61 81 DUP2 2D62 52 MSTORE 2D63 60 PUSH1 0x20 2D65 01 ADD 2D66 91 SWAP2 2D67 50 POP 2D68 80 DUP1 2D69 54 SLOAD 2D6A 80 DUP1 2D6B 15 ISZERO 2D6C 61 PUSH2 0x2d94 2D6F 57 *JUMPI 2D70 60 PUSH1 0x20 2D72 02 MUL 2D73 82 DUP3 2D74 01 ADD 2D75 91 SWAP2 2D76 90 SWAP1 2D77 60 PUSH1 0x00 2D79 52 MSTORE 2D7A 60 PUSH1 0x20 2D7C 60 PUSH1 0x00 2D7E 20 SHA3 2D7F 90 SWAP1 2D80 5B JUMPDEST 2D81 81 DUP2 2D82 54 SLOAD 2D83 81 DUP2 2D84 52 MSTORE 2D85 60 PUSH1 0x20 2D87 01 ADD 2D88 90 SWAP1 2D89 60 PUSH1 0x01 2D8B 01 ADD 2D8C 90 SWAP1 2D8D 80 DUP1 2D8E 83 DUP4 2D8F 11 GT 2D90 61 PUSH2 0x2d80 2D93 57 *JUMPI 2D94 5B JUMPDEST 2D95 50 POP 2D96 50 POP 2D97 94 SWAP5 2D98 50 POP 2D99 50 POP 2D9A 50 POP 2D9B 50 POP 2D9C 50 POP 2D9D 60 PUSH1 0x40 2D9F 51 MLOAD 2DA0 80 DUP1 2DA1 91 SWAP2 2DA2 03 SUB 2DA3 90 SWAP1 2DA4 A1 LOG1 2DA5 50 POP 2DA6 50 POP 2DA7 50 POP 2DA8 50 POP 2DA9 56 *JUMP label_2DAA: // Incoming call from 0x2E8C, returns to 0x2E8D // Incoming call from 0x1521, returns to 0x1522 // Incoming call from 0x3299, returns to 0x329A // Incoming call from 0x2316, returns to 0x2317 // Incoming call from 0x1880, returns to 0x1881 // Incoming call from 0x225E, returns to 0x225F // Incoming call from 0x1701, returns to 0x1702 // Incoming call from 0x3D4B, returns to 0x3D4C // Incoming call from 0x2005, returns to 0x2006 // Incoming call from 0x1DC7, returns to 0x1DC8 // Incoming call from 0x0BF1, returns to 0x0704 // Incoming call from 0x2B56, returns to 0x2B57 // Incoming call from 0x2C36, returns to 0x2C37 // Inputs[2] // { // @2DAD storage[0x65] // @2DB7 stack[-1] // } 2DAA 5B JUMPDEST 2DAB 60 PUSH1 0x65 2DAD 54 SLOAD 2DAE 60 PUSH1 0x01 2DB0 60 PUSH1 0x01 2DB2 60 PUSH1 0xa0 2DB4 1B SHL 2DB5 03 SUB 2DB6 16 AND 2DB7 90 SWAP1 2DB8 56 *JUMP // Stack delta = +0 // Outputs[1] { @2DB7 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x65] } // Block ends with unconditional jump to stack[-1] label_2DB9: // Incoming call from 0x0BF9, returns to 0x03E8 // Inputs[1] { @2DBC storage[0x97] } 2DB9 5B JUMPDEST 2DBA 60 PUSH1 0x97 2DBC 54 SLOAD 2DBD 60 PUSH1 0x60 2DBF 90 SWAP1 2DC0 60 PUSH1 0x01 2DC2 60 PUSH1 0x01 2DC4 60 PUSH1 0xa0 2DC6 1B SHL 2DC7 03 SUB 2DC8 16 AND 2DC9 61 PUSH2 0x2e02 2DCC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2DBF stack[0] = 0x60 } // Block ends with conditional jump to 0x2e02, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_2DCD: // Incoming jump from 0x2DCC, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @2DD0 memory[0x40:0x60] // @2DF8 memory[0x40:0x60] // @2E01 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2DCD 60 PUSH1 0x40 2DCF 80 DUP1 2DD0 51 MLOAD 2DD1 62 PUSH3 0x461bcd 2DD5 60 PUSH1 0xe5 2DD7 1B SHL 2DD8 81 DUP2 2DD9 52 MSTORE 2DDA 60 PUSH1 0x20 2DDC 60 PUSH1 0x04 2DDE 80 DUP1 2DDF 83 DUP4 2DE0 01 ADD 2DE1 91 SWAP2 2DE2 90 SWAP1 2DE3 91 SWAP2 2DE4 52 MSTORE 2DE5 60 PUSH1 0x24 2DE7 82 DUP3 2DE8 01 ADD 2DE9 52 MSTORE 2DEA 63 PUSH4 0x50523031 2DEF 60 PUSH1 0xe0 2DF1 1B SHL 2DF2 60 PUSH1 0x44 2DF4 82 DUP3 2DF5 01 ADD 2DF6 52 MSTORE 2DF7 90 SWAP1 2DF8 51 MLOAD 2DF9 90 SWAP1 2DFA 81 DUP2 2DFB 90 SWAP1 2DFC 03 SUB 2DFD 60 PUSH1 0x64 2DFF 01 ADD 2E00 90 SWAP1 2E01 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2DD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2DE4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2DE9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2DF6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @2E01 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2E02: // Incoming jump from 0x2DCC, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @2E08 storage[0x97] // @2E29 memory[0x40:0x60] // @2E3D memory[0x40:0x60] // @2E44 address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } 2E02 5B JUMPDEST 2E03 60 PUSH1 0x97 2E05 60 PUSH1 0x00 2E07 90 SWAP1 2E08 54 SLOAD 2E09 90 SWAP1 2E0A 61 PUSH2 0x0100 2E0D 0A EXP 2E0E 90 SWAP1 2E0F 04 DIV 2E10 60 PUSH1 0x01 2E12 60 PUSH1 0x01 2E14 60 PUSH1 0xa0 2E16 1B SHL 2E17 03 SUB 2E18 16 AND 2E19 60 PUSH1 0x01 2E1B 60 PUSH1 0x01 2E1D 60 PUSH1 0xa0 2E1F 1B SHL 2E20 03 SUB 2E21 16 AND 2E22 63 PUSH4 0x95d89b41 2E27 60 PUSH1 0x40 2E29 51 MLOAD 2E2A 81 DUP2 2E2B 63 PUSH4 0xffffffff 2E30 16 AND 2E31 60 PUSH1 0xe0 2E33 1B SHL 2E34 81 DUP2 2E35 52 MSTORE 2E36 60 PUSH1 0x04 2E38 01 ADD 2E39 60 PUSH1 0x00 2E3B 60 PUSH1 0x40 2E3D 51 MLOAD 2E3E 80 DUP1 2E3F 83 DUP4 2E40 03 SUB 2E41 81 DUP2 2E42 86 DUP7 2E43 80 DUP1 2E44 3B EXTCODESIZE 2E45 15 ISZERO 2E46 80 DUP1 2E47 15 ISZERO 2E48 61 PUSH2 0x13a0 2E4B 57 *JUMPI // Stack delta = +9 // Outputs[10] // { // @2E21 stack[0] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @2E22 stack[1] = 0x95d89b41 // @2E35 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x95d89b41) << 0xe0 // @2E38 stack[2] = 0x04 + memory[0x40:0x60] // @2E39 stack[3] = 0x00 // @2E3D stack[4] = memory[0x40:0x60] // @2E40 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2E41 stack[6] = memory[0x40:0x60] // @2E42 stack[7] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00 // @2E45 stack[8] = !address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x13a0, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length label_2E4C: // Incoming jump from 0x2E4B, if not !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x97] / 0x0100 ** 0x00).code.length // Inputs[1] { @2E4F memory[0x00:0x00] } 2E4C 60 PUSH1 0x00 2E4E 80 DUP1 2E4F FD *REVERT // Stack delta = +0 // Outputs[1] { @2E4F revert(memory[0x00:0x00]); } // Block terminates label_2E50: // Incoming call from 0x0C01, returns to 0x0543 // Inputs[1] { @2E72 stack[-1] } 2E50 5B JUMPDEST 2E51 7F PUSH32 0x9a42d39fe98978ff30e5bb6104a6ce6f70ac074c10013f1bce9743e2dccce41b 2E72 81 DUP2 2E73 56 *JUMP // Stack delta = +1 // Outputs[1] { @2E51 stack[0] = 0x9a42d39fe98978ff30e5bb6104a6ce6f70ac074c10013f1bce9743e2dccce41b } // Block ends with unconditional jump to stack[-1] label_2E74: // Incoming jump from 0x0C27 2E74 5B JUMPDEST 2E75 61 PUSH2 0x2e7c 2E78 61 PUSH2 0x4380 2E7B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2E75 stack[0] = 0x2e7c } // Block ends with call to 0x4380, returns to 0x2E7C label_2E7C: // Incoming return from call to 0x4380 at 0x2E7B // Inputs[1] { @2E85 stack[-1] } 2E7C 5B JUMPDEST 2E7D 60 PUSH1 0x01 2E7F 60 PUSH1 0x01 2E81 60 PUSH1 0xa0 2E83 1B SHL 2E84 03 SUB 2E85 16 AND 2E86 61 PUSH2 0x2e8d 2E89 61 PUSH2 0x2daa 2E8C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2E85 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2E86 stack[0] = 0x2e8d // } // Block ends with call to 0x2daa, returns to 0x2E8D label_2E8D: // Incoming return from call to 0x2DAA at 0x2E8C // Inputs[2] // { // @2E96 stack[-1] // @2E97 stack[-2] // } 2E8D 5B JUMPDEST 2E8E 60 PUSH1 0x01 2E90 60 PUSH1 0x01 2E92 60 PUSH1 0xa0 2E94 1B SHL 2E95 03 SUB 2E96 16 AND 2E97 14 EQ 2E98 80 DUP1 2E99 61 PUSH2 0x2ea8 2E9C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2E97 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x2ea8, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_2E9D: // Incoming jump from 0x2E9C, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 2E9D 50 POP 2E9E 61 PUSH2 0x2ea8 2EA1 61 PUSH2 0x153d 2EA4 61 PUSH2 0x4380 2EA7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2E9E stack[-1] = 0x2ea8 // @2EA1 stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_2EA8: // Incoming jump from 0x2E9C, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @2EAC stack[-1] } 2EA8 5B JUMPDEST 2EA9 61 PUSH2 0x2ee2 2EAC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2ee2, if stack[-1] label_2EAD: // Incoming jump from 0x2EAC, if not stack[-1] // Inputs[3] // { // @2EB0 memory[0x40:0x60] // @2ED8 memory[0x40:0x60] // @2EE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2EAD 60 PUSH1 0x40 2EAF 80 DUP1 2EB0 51 MLOAD 2EB1 62 PUSH3 0x461bcd 2EB5 60 PUSH1 0xe5 2EB7 1B SHL 2EB8 81 DUP2 2EB9 52 MSTORE 2EBA 60 PUSH1 0x20 2EBC 60 PUSH1 0x04 2EBE 80 DUP1 2EBF 83 DUP4 2EC0 01 ADD 2EC1 91 SWAP2 2EC2 90 SWAP1 2EC3 91 SWAP2 2EC4 52 MSTORE 2EC5 60 PUSH1 0x24 2EC7 82 DUP3 2EC8 01 ADD 2EC9 52 MSTORE 2ECA 63 PUSH4 0x41443031 2ECF 60 PUSH1 0xe0 2ED1 1B SHL 2ED2 60 PUSH1 0x44 2ED4 82 DUP3 2ED5 01 ADD 2ED6 52 MSTORE 2ED7 90 SWAP1 2ED8 51 MLOAD 2ED9 90 SWAP1 2EDA 81 DUP2 2EDB 90 SWAP1 2EDC 03 SUB 2EDD 60 PUSH1 0x64 2EDF 01 ADD 2EE0 90 SWAP1 2EE1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2EB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2EC4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2EC9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @2ED6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @2EE1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2EE2: // Incoming jump from 0x2EAC, if stack[-1] // Inputs[1] { @2EE8 stack[-1] } 2EE2 5B JUMPDEST 2EE3 61 PUSH2 0x2ef3 2EE6 60 PUSH1 0x99 2EE8 82 DUP3 2EE9 63 PUSH4 0xffffffff 2EEE 61 PUSH2 0x44a7 2EF1 16 AND 2EF2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2EE3 stack[0] = 0x2ef3 // @2EE6 stack[1] = 0x99 // @2EE8 stack[2] = stack[-1] // } // Block ends with call to 0x44a7 & 0xffffffff, returns to 0x2EF3 label_2EF3: // Incoming return from call to 0x44A7 at 0x2EF2 // Inputs[4] // { // @2EF6 memory[0x40:0x60] // @2EFF stack[-1] // @2F27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2F29 stack[-2] // } 2EF3 5B JUMPDEST 2EF4 60 PUSH1 0x40 2EF6 51 MLOAD 2EF7 60 PUSH1 0x01 2EF9 60 PUSH1 0x01 2EFB 60 PUSH1 0xa0 2EFD 1B SHL 2EFE 03 SUB 2EFF 82 DUP3 2F00 16 AND 2F01 90 SWAP1 2F02 7F PUSH32 0x8a9fdef46f258b6423e7eb8be61cbbb7375a5d65e932083b7b1267982fcd3520 2F23 90 SWAP1 2F24 60 PUSH1 0x00 2F26 90 SWAP1 2F27 A2 LOG2 2F28 50 POP 2F29 56 *JUMP // Stack delta = -2 // Outputs[1] { @2F27 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8a9fdef46f258b6423e7eb8be61cbbb7375a5d65e932083b7b1267982fcd3520, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_2F2A: // Incoming jump from 0x0C53 2F2A 5B JUMPDEST 2F2B 61 PUSH2 0x2f35 2F2E 61 PUSH2 0x1e70 2F31 61 PUSH2 0x4380 2F34 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2F2B stack[0] = 0x2f35 // @2F2E stack[1] = 0x1e70 // } // Block ends with call to 0x4380, returns to 0x1E70 2F35 5B JUMPDEST 2F36 61 PUSH2 0x2f6f 2F39 57 *JUMPI 2F3A 60 PUSH1 0x40 2F3C 80 DUP1 2F3D 51 MLOAD 2F3E 62 PUSH3 0x461bcd 2F42 60 PUSH1 0xe5 2F44 1B SHL 2F45 81 DUP2 2F46 52 MSTORE 2F47 60 PUSH1 0x20 2F49 60 PUSH1 0x04 2F4B 80 DUP1 2F4C 83 DUP4 2F4D 01 ADD 2F4E 91 SWAP2 2F4F 90 SWAP1 2F50 91 SWAP2 2F51 52 MSTORE 2F52 60 PUSH1 0x24 2F54 82 DUP3 2F55 01 ADD 2F56 52 MSTORE 2F57 63 PUSH4 0x53553031 2F5C 60 PUSH1 0xe0 2F5E 1B SHL 2F5F 60 PUSH1 0x44 2F61 82 DUP3 2F62 01 ADD 2F63 52 MSTORE 2F64 90 SWAP1 2F65 51 MLOAD 2F66 90 SWAP1 2F67 81 DUP2 2F68 90 SWAP1 2F69 03 SUB 2F6A 60 PUSH1 0x64 2F6C 01 ADD 2F6D 90 SWAP1 2F6E FD *REVERT 2F6F 5B JUMPDEST 2F70 60 PUSH1 0x97 2F72 54 SLOAD 2F73 60 PUSH1 0x01 2F75 60 PUSH1 0x01 2F77 60 PUSH1 0xa0 2F79 1B SHL 2F7A 03 SUB 2F7B 16 AND 2F7C 61 PUSH2 0x2fb5 2F7F 57 *JUMPI 2F80 60 PUSH1 0x40 2F82 80 DUP1 2F83 51 MLOAD 2F84 62 PUSH3 0x461bcd 2F88 60 PUSH1 0xe5 2F8A 1B SHL 2F8B 81 DUP2 2F8C 52 MSTORE 2F8D 60 PUSH1 0x20 2F8F 60 PUSH1 0x04 2F91 80 DUP1 2F92 83 DUP4 2F93 01 ADD 2F94 91 SWAP2 2F95 90 SWAP1 2F96 91 SWAP2 2F97 52 MSTORE 2F98 60 PUSH1 0x24 2F9A 82 DUP3 2F9B 01 ADD 2F9C 52 MSTORE 2F9D 63 PUSH4 0x50523031 2FA2 60 PUSH1 0xe0 2FA4 1B SHL 2FA5 60 PUSH1 0x44 2FA7 82 DUP3 2FA8 01 ADD 2FA9 52 MSTORE 2FAA 90 SWAP1 2FAB 51 MLOAD 2FAC 90 SWAP1 2FAD 81 DUP2 2FAE 90 SWAP1 2FAF 03 SUB 2FB0 60 PUSH1 0x64 2FB2 01 ADD 2FB3 90 SWAP1 2FB4 FD *REVERT 2FB5 5B JUMPDEST 2FB6 60 PUSH1 0x97 2FB8 54 SLOAD 2FB9 60 PUSH1 0x01 2FBB 60 PUSH1 0x01 2FBD 60 PUSH1 0xa0 2FBF 1B SHL 2FC0 03 SUB 2FC1 16 AND 2FC2 63 PUSH4 0xf6b911bc 2FC7 61 PUSH2 0x2fce 2FCA 61 PUSH2 0x4380 2FCD 56 *JUMP 2FCE 5B JUMPDEST 2FCF 60 PUSH1 0x40 2FD1 80 DUP1 2FD2 51 MLOAD 2FD3 60 PUSH1 0x01 2FD5 60 PUSH1 0x01 2FD7 60 PUSH1 0xe0 2FD9 1B SHL 2FDA 03 SUB 2FDB 19 NOT 2FDC 60 PUSH1 0xe0 2FDE 85 DUP6 2FDF 90 SWAP1 2FE0 1B SHL 2FE1 16 AND 2FE2 81 DUP2 2FE3 52 MSTORE 2FE4 60 PUSH1 0x01 2FE6 60 PUSH1 0x01 2FE8 60 PUSH1 0xa0 2FEA 1B SHL 2FEB 03 SUB 2FEC 92 SWAP3 2FED 83 DUP4 2FEE 16 AND 2FEF 60 PUSH1 0x04 2FF1 82 DUP3 2FF2 01 ADD 2FF3 52 MSTORE 2FF4 91 SWAP2 2FF5 86 DUP7 2FF6 16 AND 2FF7 60 PUSH1 0x24 2FF9 83 DUP4 2FFA 01 ADD 2FFB 52 MSTORE 2FFC 60 PUSH1 0x44 2FFE 82 DUP3 2FFF 01 ADD 3000 85 DUP6 3001 90 SWAP1 3002 52 MSTORE 3003 51 MLOAD 3004 60 PUSH1 0x64 3006 80 DUP1 3007 83 DUP4 3008 01 ADD 3009 92 SWAP3 300A 60 PUSH1 0x00 300C 92 SWAP3 300D 91 SWAP2 300E 90 SWAP1 300F 82 DUP3 3010 90 SWAP1 3011 03 SUB 3012 01 ADD 3013 81 DUP2 3014 83 DUP4 3015 87 DUP8 3016 80 DUP1 3017 3B EXTCODESIZE 3018 15 ISZERO 3019 80 DUP1 301A 15 ISZERO 301B 61 PUSH2 0x3023 301E 57 *JUMPI 301F 60 PUSH1 0x00 3021 80 DUP1 3022 FD *REVERT 3023 5B JUMPDEST 3024 50 POP 3025 5A GAS 3026 F1 CALL 3027 15 ISZERO 3028 80 DUP1 3029 15 ISZERO 302A 61 PUSH2 0x3037 302D 57 *JUMPI 302E 3D RETURNDATASIZE 302F 60 PUSH1 0x00 3031 80 DUP1 3032 3E RETURNDATACOPY 3033 3D RETURNDATASIZE 3034 60 PUSH1 0x00 3036 FD *REVERT 3037 5B JUMPDEST 3038 50 POP 3039 50 POP 303A 60 PUSH1 0x40 303C 80 DUP1 303D 51 MLOAD 303E 84 DUP5 303F 81 DUP2 3040 52 MSTORE 3041 90 SWAP1 3042 51 MLOAD 3043 60 PUSH1 0x01 3045 60 PUSH1 0x01 3047 60 PUSH1 0xa0 3049 1B SHL 304A 03 SUB 304B 86 DUP7 304C 16 AND 304D 93 SWAP4 304E 50 POP 304F 7F PUSH32 0xcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5 3070 92 SWAP3 3071 50 POP 3072 90 SWAP1 3073 81 DUP2 3074 90 SWAP1 3075 03 SUB 3076 60 PUSH1 0x20 3078 01 ADD 3079 90 SWAP1 307A A2 LOG2 307B 60 PUSH1 0x40 307D 80 DUP1 307E 51 MLOAD 307F 82 DUP3 3080 81 DUP2 3081 52 MSTORE 3082 90 SWAP1 3083 51 MLOAD 3084 60 PUSH1 0x00 3086 91 SWAP2 3087 60 PUSH1 0x01 3089 60 PUSH1 0x01 308B 60 PUSH1 0xa0 308D 1B SHL 308E 03 SUB 308F 85 DUP6 3090 16 AND 3091 91 SWAP2 3092 60 PUSH1 0x00 3094 80 DUP1 3095 51 MLOAD 3096 60 PUSH1 0x20 3098 61 PUSH2 0x5729 309B 83 DUP4 309C 39 CODECOPY 309D 81 DUP2 309E 51 MLOAD 309F 91 SWAP2 30A0 52 MSTORE 30A1 91 SWAP2 30A2 81 DUP2 30A3 90 SWAP1 30A4 03 SUB 30A5 60 PUSH1 0x20 30A7 01 ADD 30A8 90 SWAP1 30A9 A3 LOG3 30AA 50 POP 30AB 50 POP 30AC 56 *JUMP label_30AD: // Incoming jump from 0x0CB2 // Inputs[1] { @30B0 storage[0x97] } 30AD 5B JUMPDEST 30AE 60 PUSH1 0x97 30B0 54 SLOAD 30B1 60 PUSH1 0x01 30B3 60 PUSH1 0x01 30B5 60 PUSH1 0xa0 30B7 1B SHL 30B8 03 SUB 30B9 16 AND 30BA 61 PUSH2 0x30f3 30BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x30f3, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_30BE: // Incoming jump from 0x30BD, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @30C1 memory[0x40:0x60] // @30E9 memory[0x40:0x60] // @30F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 30BE 60 PUSH1 0x40 30C0 80 DUP1 30C1 51 MLOAD 30C2 62 PUSH3 0x461bcd 30C6 60 PUSH1 0xe5 30C8 1B SHL 30C9 81 DUP2 30CA 52 MSTORE 30CB 60 PUSH1 0x20 30CD 60 PUSH1 0x04 30CF 80 DUP1 30D0 83 DUP4 30D1 01 ADD 30D2 91 SWAP2 30D3 90 SWAP1 30D4 91 SWAP2 30D5 52 MSTORE 30D6 60 PUSH1 0x24 30D8 82 DUP3 30D9 01 ADD 30DA 52 MSTORE 30DB 63 PUSH4 0x50523031 30E0 60 PUSH1 0xe0 30E2 1B SHL 30E3 60 PUSH1 0x44 30E5 82 DUP3 30E6 01 ADD 30E7 52 MSTORE 30E8 90 SWAP1 30E9 51 MLOAD 30EA 90 SWAP1 30EB 81 DUP2 30EC 90 SWAP1 30ED 03 SUB 30EE 60 PUSH1 0x64 30F0 01 ADD 30F1 90 SWAP1 30F2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @30CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @30D5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @30DA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @30E7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @30F2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_30F3: // Incoming jump from 0x30BD, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @30F7 stack[-9] // @30F8 stack[-4] // @30F9 stack[-6] // @30FA stack[-5] // } 30F3 5B JUMPDEST 30F4 61 PUSH2 0x30ff 30F7 89 DUP10 30F8 85 DUP6 30F9 88 DUP9 30FA 88 DUP9 30FB 61 PUSH2 0x466c 30FE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @30F4 stack[0] = 0x30ff // @30F7 stack[1] = stack[-9] // @30F8 stack[2] = stack[-4] // @30F9 stack[3] = stack[-6] // @30FA stack[4] = stack[-5] // } // Block ends with call to 0x466c, returns to 0x30FF label_30FF: // Incoming return from call to 0x466C at 0x30FE // Inputs[12] // { // @3103 memory[0x40:0x60] // @3133 stack[-9] // @313C stack[-8] // @3147 stack[-7] // @314E stack[-6] // @3155 stack[-5] // @315D stack[-4] // @3161 memory[0x40:0x60] // @3176 storage[0x0105] // @317E stack[-3] // @317F stack[-2] // @3180 stack[-1] // } 30FF 5B JUMPDEST 3100 60 PUSH1 0x40 3102 80 DUP1 3103 51 MLOAD 3104 7F PUSH32 0x9a42d39fe98978ff30e5bb6104a6ce6f70ac074c10013f1bce9743e2dccce41b 3125 60 PUSH1 0x20 3127 82 DUP3 3128 01 ADD 3129 52 MSTORE 312A 60 PUSH1 0x01 312C 60 PUSH1 0x01 312E 60 PUSH1 0xa0 3130 1B SHL 3131 03 SUB 3132 80 DUP1 3133 8C DUP13 3134 16 AND 3135 82 DUP3 3136 84 DUP5 3137 01 ADD 3138 81 DUP2 3139 90 SWAP1 313A 52 MSTORE 313B 90 SWAP1 313C 8B DUP12 313D 16 AND 313E 60 PUSH1 0x60 3140 83 DUP4 3141 01 ADD 3142 52 MSTORE 3143 60 PUSH1 0x80 3145 82 DUP3 3146 01 ADD 3147 8A DUP11 3148 90 SWAP1 3149 52 MSTORE 314A 60 PUSH1 0xa0 314C 82 DUP3 314D 01 ADD 314E 89 DUP10 314F 90 SWAP1 3150 52 MSTORE 3151 60 PUSH1 0xc0 3153 82 DUP3 3154 01 ADD 3155 88 DUP9 3156 90 SWAP1 3157 52 MSTORE 3158 60 PUSH1 0xe0 315A 80 DUP1 315B 83 DUP4 315C 01 ADD 315D 88 DUP9 315E 90 SWAP1 315F 52 MSTORE 3160 83 DUP4 3161 51 MLOAD 3162 80 DUP1 3163 84 DUP5 3164 03 SUB 3165 90 SWAP1 3166 91 SWAP2 3167 01 ADD 3168 81 DUP2 3169 52 MSTORE 316A 61 PUSH2 0x0100 316D 90 SWAP1 316E 92 SWAP3 316F 01 ADD 3170 90 SWAP1 3171 92 SWAP3 3172 52 MSTORE 3173 61 PUSH2 0x0105 3176 54 SLOAD 3177 90 SWAP1 3178 91 SWAP2 3179 90 SWAP1 317A 61 PUSH2 0x3186 317D 90 SWAP1 317E 86 DUP7 317F 86 DUP7 3180 86 DUP7 3181 86 DUP7 3182 61 PUSH2 0x46f6 3185 56 *JUMP // Stack delta = +8 // Outputs[17] // { // @3129 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x9a42d39fe98978ff30e5bb6104a6ce6f70ac074c10013f1bce9743e2dccce41b // @313A memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @3142 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3149 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-7] // @3150 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-6] // @3157 memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-5] // @315F memory[memory[0x40:0x60] + 0xe0:memory[0x40:0x60] + 0xe0 + 0x20] = stack[-4] // @3169 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @3172 memory[0x40:0x60] = memory[0x40:0x60] + 0x0100 // @3178 stack[0] = memory[0x40:0x60] // @3179 stack[1] = stack[-9] & (0x01 << 0xa0) - 0x01 // @317D stack[2] = 0x3186 // @317D stack[3] = storage[0x0105] // @317E stack[4] = stack[-3] // @317F stack[5] = stack[-2] // @3180 stack[6] = stack[-1] // @3181 stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x46f6, returns to 0x3186 label_3186: // Incoming return from call to 0x46F6 at 0x3185 // Inputs[2] // { // @318F stack[-1] // @3190 stack[-2] // } 3186 5B JUMPDEST 3187 60 PUSH1 0x01 3189 60 PUSH1 0x01 318B 60 PUSH1 0xa0 318D 1B SHL 318E 03 SUB 318F 16 AND 3190 14 EQ 3191 61 PUSH2 0x31ca 3194 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x31ca, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_3195: // Incoming jump from 0x3194, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @3198 memory[0x40:0x60] // @31C0 memory[0x40:0x60] // @31C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3195 60 PUSH1 0x40 3197 80 DUP1 3198 51 MLOAD 3199 62 PUSH3 0x461bcd 319D 60 PUSH1 0xe5 319F 1B SHL 31A0 81 DUP2 31A1 52 MSTORE 31A2 60 PUSH1 0x20 31A4 60 PUSH1 0x04 31A6 80 DUP1 31A7 83 DUP4 31A8 01 ADD 31A9 91 SWAP2 31AA 90 SWAP1 31AB 91 SWAP2 31AC 52 MSTORE 31AD 60 PUSH1 0x24 31AF 82 DUP3 31B0 01 ADD 31B1 52 MSTORE 31B2 63 PUSH4 0x53493031 31B7 60 PUSH1 0xe0 31B9 1B SHL 31BA 60 PUSH1 0x44 31BC 82 DUP3 31BD 01 ADD 31BE 52 MSTORE 31BF 90 SWAP1 31C0 51 MLOAD 31C1 90 SWAP1 31C2 81 DUP2 31C3 90 SWAP1 31C4 03 SUB 31C5 60 PUSH1 0x64 31C7 01 ADD 31C8 90 SWAP1 31C9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @31A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @31AC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @31B1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @31BE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53493031 << 0xe0 // @31C9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_31CA: // Incoming jump from 0x3194, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @31CE stack[-10] // @31CF stack[-5] // } 31CA 5B JUMPDEST 31CB 61 PUSH2 0x31d4 31CE 8A DUP11 31CF 86 DUP7 31D0 61 PUSH2 0x474d 31D3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @31CB stack[0] = 0x31d4 // @31CE stack[1] = stack[-10] // @31CF stack[2] = stack[-5] // } // Block ends with call to 0x474d, returns to 0x31D4 label_31D4: // Incoming return from call to 0x474D at 0x31D3 // Inputs[3] // { // @31D8 stack[-10] // @31D9 stack[-9] // @31DA stack[-8] // } 31D4 5B JUMPDEST 31D5 61 PUSH2 0x1a50 31D8 8A DUP11 31D9 8A DUP11 31DA 8A DUP11 31DB 61 PUSH2 0x4b3f 31DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @31D5 stack[0] = 0x1a50 // @31D8 stack[1] = stack[-10] // @31D9 stack[2] = stack[-9] // @31DA stack[3] = stack[-8] // } // Block ends with call to 0x4b3f, returns to 0x1A50 label_31DF: // Incoming call from 0x0CBA, returns to 0x0543 // Inputs[1] { @3201 stack[-1] } 31DF 5B JUMPDEST 31E0 7F PUSH32 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267 3201 81 DUP2 3202 56 *JUMP // Stack delta = +1 // Outputs[1] { @31E0 stack[0] = 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267 } // Block ends with unconditional jump to stack[-1] label_3203: // Incoming jump from 0x0CE6 // Inputs[1] { @3206 storage[0x97] } 3203 5B JUMPDEST 3204 60 PUSH1 0x97 3206 54 SLOAD 3207 60 PUSH1 0x00 3209 90 SWAP1 320A 60 PUSH1 0x01 320C 60 PUSH1 0x01 320E 60 PUSH1 0xa0 3210 1B SHL 3211 03 SUB 3212 16 AND 3213 61 PUSH2 0x324c 3216 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3209 stack[0] = 0x00 } // Block ends with conditional jump to 0x324c, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_3217: // Incoming jump from 0x3216, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @321A memory[0x40:0x60] // @3242 memory[0x40:0x60] // @324B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3217 60 PUSH1 0x40 3219 80 DUP1 321A 51 MLOAD 321B 62 PUSH3 0x461bcd 321F 60 PUSH1 0xe5 3221 1B SHL 3222 81 DUP2 3223 52 MSTORE 3224 60 PUSH1 0x20 3226 60 PUSH1 0x04 3228 80 DUP1 3229 83 DUP4 322A 01 ADD 322B 91 SWAP2 322C 90 SWAP1 322D 91 SWAP2 322E 52 MSTORE 322F 60 PUSH1 0x24 3231 82 DUP3 3232 01 ADD 3233 52 MSTORE 3234 63 PUSH4 0x50523031 3239 60 PUSH1 0xe0 323B 1B SHL 323C 60 PUSH1 0x44 323E 82 DUP3 323F 01 ADD 3240 52 MSTORE 3241 90 SWAP1 3242 51 MLOAD 3243 90 SWAP1 3244 81 DUP2 3245 90 SWAP1 3246 03 SUB 3247 60 PUSH1 0x64 3249 01 ADD 324A 90 SWAP1 324B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3223 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @322E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3233 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3240 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @324B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_324C: // Incoming jump from 0x3216, if (0x01 << 0xa0) - 0x01 & storage[0x97] 324C 5B JUMPDEST 324D 60 PUSH1 0x00 324F 80 DUP1 3250 60 PUSH1 0x00 3252 61 PUSH2 0x3263 3255 61 PUSH2 0x325c 3258 61 PUSH2 0x4380 325B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @324D stack[0] = 0x00 // @324F stack[1] = 0x00 // @3250 stack[2] = 0x00 // @3252 stack[3] = 0x3263 // @3255 stack[4] = 0x325c // } // Block ends with call to 0x4380, returns to 0x325C label_325C: // Incoming return from call to 0x4380 at 0x325B // Inputs[2] // { // @325D stack[-8] // @325E stack[-7] // } 325C 5B JUMPDEST 325D 87 DUP8 325E 87 DUP8 325F 61 PUSH2 0x450e 3262 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @325D stack[0] = stack[-8] // @325E stack[1] = stack[-7] // } // Block ends with unconditional jump to 0x450e label_3263: // Incoming return from call to 0x325C at 0x325B // Inputs[2] // { // @3267 stack[-10] // @3268 stack[-9] // } 3263 5B JUMPDEST 3264 50 POP 3265 60 PUSH1 0x01 3267 98 SWAP9 3268 97 SWAP8 3269 50 POP 326A 50 POP 326B 50 POP 326C 50 POP 326D 50 POP 326E 50 POP 326F 50 POP 3270 50 POP 3271 56 *JUMP // Stack delta = -9 // Outputs[1] { @3267 stack[-10] = 0x01 } // Block ends with unconditional jump to stack[-10] label_3272: // Incoming call from 0x0CEE, returns to 0x0704 // Inputs[2] // { // @3275 storage[0x9b] // @327F stack[-1] // } 3272 5B JUMPDEST 3273 60 PUSH1 0x9b 3275 54 SLOAD 3276 60 PUSH1 0x01 3278 60 PUSH1 0x01 327A 60 PUSH1 0xa0 327C 1B SHL 327D 03 SUB 327E 16 AND 327F 90 SWAP1 3280 56 *JUMP // Stack delta = +0 // Outputs[1] { @327F stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x9b] } // Block ends with unconditional jump to stack[-1] label_3281: // Incoming jump from 0x0D14 3281 5B JUMPDEST 3282 61 PUSH2 0x3289 3285 61 PUSH2 0x4380 3288 56 *JUMP // Stack delta = +1 // Outputs[1] { @3282 stack[0] = 0x3289 } // Block ends with call to 0x4380, returns to 0x3289 label_3289: // Incoming return from call to 0x4380 at 0x3288 // Inputs[1] { @3292 stack[-1] } 3289 5B JUMPDEST 328A 60 PUSH1 0x01 328C 60 PUSH1 0x01 328E 60 PUSH1 0xa0 3290 1B SHL 3291 03 SUB 3292 16 AND 3293 61 PUSH2 0x329a 3296 61 PUSH2 0x2daa 3299 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @3292 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @3293 stack[0] = 0x329a // } // Block ends with call to 0x2daa, returns to 0x329A label_329A: // Incoming return from call to 0x2DAA at 0x3299 // Inputs[2] // { // @32A3 stack[-1] // @32A4 stack[-2] // } 329A 5B JUMPDEST 329B 60 PUSH1 0x01 329D 60 PUSH1 0x01 329F 60 PUSH1 0xa0 32A1 1B SHL 32A2 03 SUB 32A3 16 AND 32A4 14 EQ 32A5 80 DUP1 32A6 61 PUSH2 0x32b5 32A9 57 *JUMPI // Stack delta = -1 // Outputs[1] { @32A4 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x32b5, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_32AA: // Incoming jump from 0x32A9, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 32AA 50 POP 32AB 61 PUSH2 0x32b5 32AE 61 PUSH2 0x153d 32B1 61 PUSH2 0x4380 32B4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @32AB stack[-1] = 0x32b5 // @32AE stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_32B5: // Incoming jump from 0x32A9, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @32B9 stack[-1] } 32B5 5B JUMPDEST 32B6 61 PUSH2 0x32ef 32B9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x32ef, if stack[-1] label_32BA: // Incoming jump from 0x32B9, if not stack[-1] // Inputs[3] // { // @32BD memory[0x40:0x60] // @32E5 memory[0x40:0x60] // @32EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 32BA 60 PUSH1 0x40 32BC 80 DUP1 32BD 51 MLOAD 32BE 62 PUSH3 0x461bcd 32C2 60 PUSH1 0xe5 32C4 1B SHL 32C5 81 DUP2 32C6 52 MSTORE 32C7 60 PUSH1 0x20 32C9 60 PUSH1 0x04 32CB 80 DUP1 32CC 83 DUP4 32CD 01 ADD 32CE 91 SWAP2 32CF 90 SWAP1 32D0 91 SWAP2 32D1 52 MSTORE 32D2 60 PUSH1 0x24 32D4 82 DUP3 32D5 01 ADD 32D6 52 MSTORE 32D7 63 PUSH4 0x41443031 32DC 60 PUSH1 0xe0 32DE 1B SHL 32DF 60 PUSH1 0x44 32E1 82 DUP3 32E2 01 ADD 32E3 52 MSTORE 32E4 90 SWAP1 32E5 51 MLOAD 32E6 90 SWAP1 32E7 81 DUP2 32E8 90 SWAP1 32E9 03 SUB 32EA 60 PUSH1 0x64 32EC 01 ADD 32ED 90 SWAP1 32EE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @32C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @32D1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @32D6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @32E3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @32EE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_32EF: // Incoming jump from 0x32B9, if stack[-1] // Inputs[1] { @32F0 stack[-1] } 32EF 5B JUMPDEST 32F0 80 DUP1 32F1 61 PUSH2 0x32f8 32F4 61 PUSH2 0x4380 32F7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @32F0 stack[0] = stack[-1] // @32F1 stack[1] = 0x32f8 // } // Block ends with call to 0x4380, returns to 0x32F8 label_32F8: // Incoming return from call to 0x4380 at 0x32F7 // Inputs[5] // { // @3301 stack[-1] // @3302 stack[-2] // @3313 memory[0x40:0x60] // @3327 memory[0x40:0x60] // @332E address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // } 32F8 5B JUMPDEST 32F9 60 PUSH1 0x01 32FB 60 PUSH1 0x01 32FD 60 PUSH1 0xa0 32FF 1B SHL 3300 03 SUB 3301 16 AND 3302 81 DUP2 3303 60 PUSH1 0x01 3305 60 PUSH1 0x01 3307 60 PUSH1 0xa0 3309 1B SHL 330A 03 SUB 330B 16 AND 330C 63 PUSH4 0x8da5cb5b 3311 60 PUSH1 0x40 3313 51 MLOAD 3314 81 DUP2 3315 63 PUSH4 0xffffffff 331A 16 AND 331B 60 PUSH1 0xe0 331D 1B SHL 331E 81 DUP2 331F 52 MSTORE 3320 60 PUSH1 0x04 3322 01 ADD 3323 60 PUSH1 0x20 3325 60 PUSH1 0x40 3327 51 MLOAD 3328 80 DUP1 3329 83 DUP4 332A 03 SUB 332B 81 DUP2 332C 86 DUP7 332D 80 DUP1 332E 3B EXTCODESIZE 332F 15 ISZERO 3330 80 DUP1 3331 15 ISZERO 3332 61 PUSH2 0x333a 3335 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @3301 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @330B stack[0] = (0x01 << 0xa0) - 0x01 & stack[-2] // @330C stack[1] = 0x8da5cb5b // @331F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x8da5cb5b) << 0xe0 // @3322 stack[2] = 0x04 + memory[0x40:0x60] // @3323 stack[3] = 0x20 // @3327 stack[4] = memory[0x40:0x60] // @332A stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @332B stack[6] = memory[0x40:0x60] // @332C stack[7] = (0x01 << 0xa0) - 0x01 & stack[-2] // @332F stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // } // Block ends with conditional jump to 0x333a, if !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length label_3336: // Incoming jump from 0x3335, if not !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[1] { @3339 memory[0x00:0x00] } 3336 60 PUSH1 0x00 3338 80 DUP1 3339 FD *REVERT // Stack delta = +0 // Outputs[1] { @3339 revert(memory[0x00:0x00]); } // Block terminates label_333A: // Incoming jump from 0x3335, if !!address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // Inputs[8] // { // @333C msg.gas // @333D address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @333D stack[-5] // @333D stack[-6] // @333D stack[-2] // @333D stack[-3] // @333D stack[-4] // @333D memory[stack[-3]:stack[-3] + stack[-4]] // } 333A 5B JUMPDEST 333B 50 POP 333C 5A GAS 333D FA STATICCALL 333E 15 ISZERO 333F 80 DUP1 3340 15 ISZERO 3341 61 PUSH2 0x334e 3344 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @333D memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @333E stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x334e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3345: // Incoming jump from 0x3344, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3345 returndata.length // @3349 returndata[0x00:0x00 + returndata.length] // @334A returndata.length // @334D memory[0x00:0x00 + returndata.length] // } 3345 3D RETURNDATASIZE 3346 60 PUSH1 0x00 3348 80 DUP1 3349 3E RETURNDATACOPY 334A 3D RETURNDATASIZE 334B 60 PUSH1 0x00 334D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3349 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @334D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_334E: // Incoming jump from 0x3344, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3355 memory[0x40:0x60] // @3356 returndata.length // } 334E 5B JUMPDEST 334F 50 POP 3350 50 POP 3351 50 POP 3352 50 POP 3353 60 PUSH1 0x40 3355 51 MLOAD 3356 3D RETURNDATASIZE 3357 60 PUSH1 0x20 3359 81 DUP2 335A 10 LT 335B 15 ISZERO 335C 61 PUSH2 0x3364 335F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3355 stack[-4] = memory[0x40:0x60] // @3356 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3364, if !(returndata.length < 0x20) label_3360: // Incoming jump from 0x335F, if not !(returndata.length < 0x20) // Inputs[1] { @3363 memory[0x00:0x00] } 3360 60 PUSH1 0x00 3362 80 DUP1 3363 FD *REVERT // Stack delta = +0 // Outputs[1] { @3363 revert(memory[0x00:0x00]); } // Block terminates label_3364: // Incoming jump from 0x335F, if !(returndata.length < 0x20) // Inputs[3] // { // @3366 stack[-2] // @3366 memory[stack[-2]:stack[-2] + 0x20] // @3370 stack[-3] // } 3364 5B JUMPDEST 3365 50 POP 3366 51 MLOAD 3367 60 PUSH1 0x01 3369 60 PUSH1 0x01 336B 60 PUSH1 0xa0 336D 1B SHL 336E 03 SUB 336F 16 AND 3370 14 EQ 3371 80 DUP1 3372 61 PUSH2 0x3400 3375 57 *JUMPI // Stack delta = -2 // Outputs[1] { @3370 stack[-3] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] } // Block ends with conditional jump to 0x3400, if (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] label_3376: // Incoming jump from 0x3375, if not (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[1] { @3377 stack[-2] } 3376 50 POP 3377 80 DUP1 3378 60 PUSH1 0x01 337A 60 PUSH1 0x01 337C 60 PUSH1 0xa0 337E 1B SHL 337F 03 SUB 3380 16 AND 3381 63 PUSH4 0xda2f030f 3386 61 PUSH2 0x338d 3389 61 PUSH2 0x4380 338C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3380 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @3381 stack[0] = 0xda2f030f // @3386 stack[1] = 0x338d // } // Block ends with call to 0x4380, returns to 0x338D label_338D: // Incoming return from call to 0x4380 at 0x338C // Inputs[6] // { // @3390 memory[0x40:0x60] // @3391 stack[-2] // @33A1 stack[-1] // @33C0 memory[0x40:0x60] // @33C5 stack[-3] // @33C7 address(stack[-3]).code.length // } 338D 5B JUMPDEST 338E 60 PUSH1 0x40 3390 51 MLOAD 3391 82 DUP3 3392 63 PUSH4 0xffffffff 3397 16 AND 3398 60 PUSH1 0xe0 339A 1B SHL 339B 81 DUP2 339C 52 MSTORE 339D 60 PUSH1 0x04 339F 01 ADD 33A0 80 DUP1 33A1 82 DUP3 33A2 60 PUSH1 0x01 33A4 60 PUSH1 0x01 33A6 60 PUSH1 0xa0 33A8 1B SHL 33A9 03 SUB 33AA 16 AND 33AB 60 PUSH1 0x01 33AD 60 PUSH1 0x01 33AF 60 PUSH1 0xa0 33B1 1B SHL 33B2 03 SUB 33B3 16 AND 33B4 81 DUP2 33B5 52 MSTORE 33B6 60 PUSH1 0x20 33B8 01 ADD 33B9 91 SWAP2 33BA 50 POP 33BB 50 POP 33BC 60 PUSH1 0x20 33BE 60 PUSH1 0x40 33C0 51 MLOAD 33C1 80 DUP1 33C2 83 DUP4 33C3 03 SUB 33C4 81 DUP2 33C5 86 DUP7 33C6 80 DUP1 33C7 3B EXTCODESIZE 33C8 15 ISZERO 33C9 80 DUP1 33CA 15 ISZERO 33CB 61 PUSH2 0x33d3 33CE 57 *JUMPI // Stack delta = +6 // Outputs[9] // { // @339C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @33B5 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-1] // @33B9 stack[-1] = 0x20 + 0x04 + memory[0x40:0x60] // @33BC stack[0] = 0x20 // @33C0 stack[1] = memory[0x40:0x60] // @33C3 stack[2] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @33C4 stack[3] = memory[0x40:0x60] // @33C5 stack[4] = stack[-3] // @33C8 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x33d3, if !!address(stack[-3]).code.length label_33CF: // Incoming jump from 0x33CE, if not !!address(stack[-3]).code.length // Inputs[1] { @33D2 memory[0x00:0x00] } 33CF 60 PUSH1 0x00 33D1 80 DUP1 33D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @33D2 revert(memory[0x00:0x00]); } // Block terminates label_33D3: // Incoming jump from 0x33CE, if !!address(stack[-3]).code.length // Inputs[8] // { // @33D5 msg.gas // @33D6 stack[-6] // @33D6 stack[-3] // @33D6 memory[stack[-3]:stack[-3] + stack[-4]] // @33D6 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @33D6 stack[-2] // @33D6 stack[-4] // @33D6 stack[-5] // } 33D3 5B JUMPDEST 33D4 50 POP 33D5 5A GAS 33D6 FA STATICCALL 33D7 15 ISZERO 33D8 80 DUP1 33D9 15 ISZERO 33DA 61 PUSH2 0x33e7 33DD 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @33D6 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @33D7 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x33e7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_33DE: // Incoming jump from 0x33DD, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @33DE returndata.length // @33E2 returndata[0x00:0x00 + returndata.length] // @33E3 returndata.length // @33E6 memory[0x00:0x00 + returndata.length] // } 33DE 3D RETURNDATASIZE 33DF 60 PUSH1 0x00 33E1 80 DUP1 33E2 3E RETURNDATACOPY 33E3 3D RETURNDATASIZE 33E4 60 PUSH1 0x00 33E6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @33E2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @33E6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_33E7: // Incoming jump from 0x33DD, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @33EE memory[0x40:0x60] // @33EF returndata.length // } 33E7 5B JUMPDEST 33E8 50 POP 33E9 50 POP 33EA 50 POP 33EB 50 POP 33EC 60 PUSH1 0x40 33EE 51 MLOAD 33EF 3D RETURNDATASIZE 33F0 60 PUSH1 0x20 33F2 81 DUP2 33F3 10 LT 33F4 15 ISZERO 33F5 61 PUSH2 0x33fd 33F8 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @33EE stack[-4] = memory[0x40:0x60] // @33EF stack[-3] = returndata.length // } // Block ends with conditional jump to 0x33fd, if !(returndata.length < 0x20) label_33F9: // Incoming jump from 0x33F8, if not !(returndata.length < 0x20) // Inputs[1] { @33FC memory[0x00:0x00] } 33F9 60 PUSH1 0x00 33FB 80 DUP1 33FC FD *REVERT // Stack delta = +0 // Outputs[1] { @33FC revert(memory[0x00:0x00]); } // Block terminates label_33FD: // Incoming jump from 0x33F8, if !(returndata.length < 0x20) // Inputs[2] // { // @33FF memory[stack[-2]:stack[-2] + 0x20] // @33FF stack[-2] // } 33FD 5B JUMPDEST 33FE 50 POP 33FF 51 MLOAD // Stack delta = -1 // Outputs[1] { @33FF stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_3400: // Incoming jump from 0x3375, if (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Incoming jump from 0x33FF // Inputs[1] { @3404 stack[-1] } 3400 5B JUMPDEST 3401 61 PUSH2 0x343a 3404 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x343a, if stack[-1] label_3405: // Incoming jump from 0x3404, if not stack[-1] // Inputs[3] // { // @3408 memory[0x40:0x60] // @3430 memory[0x40:0x60] // @3439 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3405 60 PUSH1 0x40 3407 80 DUP1 3408 51 MLOAD 3409 62 PUSH3 0x461bcd 340D 60 PUSH1 0xe5 340F 1B SHL 3410 81 DUP2 3411 52 MSTORE 3412 60 PUSH1 0x20 3414 60 PUSH1 0x04 3416 80 DUP1 3417 83 DUP4 3418 01 ADD 3419 91 SWAP2 341A 90 SWAP1 341B 91 SWAP2 341C 52 MSTORE 341D 60 PUSH1 0x24 341F 82 DUP3 3420 01 ADD 3421 52 MSTORE 3422 63 PUSH4 0x4b493031 3427 60 PUSH1 0xe0 3429 1B SHL 342A 60 PUSH1 0x44 342C 82 DUP3 342D 01 ADD 342E 52 MSTORE 342F 90 SWAP1 3430 51 MLOAD 3431 90 SWAP1 3432 81 DUP2 3433 90 SWAP1 3434 03 SUB 3435 60 PUSH1 0x64 3437 01 ADD 3438 90 SWAP1 3439 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3411 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @341C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3421 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @342E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4b493031 << 0xe0 // @3439 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_343A: // Incoming jump from 0x3404, if stack[-1] // Inputs[6] // { // @343E storage[0x9b] // @3447 stack[-2] // @345D memory[0x40:0x60] // @3461 memory[0x40:0x60] // @348B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @348E stack[-3] // } 343A 5B JUMPDEST 343B 60 PUSH1 0x9b 343D 80 DUP1 343E 54 SLOAD 343F 60 PUSH1 0x01 3441 60 PUSH1 0x01 3443 60 PUSH1 0xa0 3445 1B SHL 3446 03 SUB 3447 84 DUP5 3448 16 AND 3449 60 PUSH1 0x01 344B 60 PUSH1 0x01 344D 60 PUSH1 0xa0 344F 1B SHL 3450 03 SUB 3451 19 NOT 3452 90 SWAP1 3453 91 SWAP2 3454 16 AND 3455 81 DUP2 3456 17 OR 3457 90 SWAP1 3458 91 SWAP2 3459 55 SSTORE 345A 60 PUSH1 0x40 345C 80 DUP1 345D 51 MLOAD 345E 91 SWAP2 345F 82 DUP3 3460 52 MSTORE 3461 51 MLOAD 3462 7F PUSH32 0x198af0cedad0e99479f8e29795c967775c9a824402a94819578621b53864c243 3483 91 SWAP2 3484 81 DUP2 3485 90 SWAP1 3486 03 SUB 3487 60 PUSH1 0x20 3489 01 ADD 348A 90 SWAP1 348B A1 LOG1 348C 50 POP 348D 50 POP 348E 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3459 storage[0x9b] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (storage[0x9b] & ~((0x01 << 0xa0) - 0x01)) // @3460 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @348B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x198af0cedad0e99479f8e29795c967775c9a824402a94819578621b53864c243]); // } // Block ends with unconditional jump to stack[-3] label_348F: // Incoming call from 0x0D1C, returns to 0x0D1D // Inputs[3] // { // @3495 storage[0x9a] // @349F memory[0x40:0x60] // @34B2 storage[0x9a] // } 348F 5B JUMPDEST 3490 60 PUSH1 0x60 3492 60 PUSH1 0x9a 3494 80 DUP1 3495 54 SLOAD 3496 80 DUP1 3497 60 PUSH1 0x20 3499 02 MUL 349A 60 PUSH1 0x20 349C 01 ADD 349D 60 PUSH1 0x40 349F 51 MLOAD 34A0 90 SWAP1 34A1 81 DUP2 34A2 01 ADD 34A3 60 PUSH1 0x40 34A5 52 MSTORE 34A6 80 DUP1 34A7 92 SWAP3 34A8 91 SWAP2 34A9 90 SWAP1 34AA 81 DUP2 34AB 81 DUP2 34AC 52 MSTORE 34AD 60 PUSH1 0x20 34AF 01 ADD 34B0 82 DUP3 34B1 80 DUP1 34B2 54 SLOAD 34B3 80 DUP1 34B4 15 ISZERO 34B5 61 PUSH2 0x1d9e 34B8 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @3490 stack[0] = 0x60 // @34A5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x9a] // @34A7 stack[1] = memory[0x40:0x60] // @34A8 stack[2] = 0x9a // @34A9 stack[3] = storage[0x9a] // @34AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x9a] // @34AF stack[4] = 0x20 + memory[0x40:0x60] // @34B0 stack[5] = 0x9a // @34B2 stack[6] = storage[0x9a] // } // Block ends with conditional jump to 0x1d9e, if !storage[0x9a] label_34B9: // Incoming jump from 0x34B8, if not !storage[0x9a] // Inputs[5] // { // @34BB stack[-1] // @34BC stack[-3] // @34BF stack[-2] // @34C7 memory[0x00:0x20] // @34CB storage[keccak256(memory[0x00:0x20])] // } 34B9 60 PUSH1 0x20 34BB 02 MUL 34BC 82 DUP3 34BD 01 ADD 34BE 91 SWAP2 34BF 90 SWAP1 34C0 60 PUSH1 0x00 34C2 52 MSTORE 34C3 60 PUSH1 0x20 34C5 60 PUSH1 0x00 34C7 20 SHA3 34C8 90 SWAP1 34C9 5B JUMPDEST 34CA 81 DUP2 34CB 54 SLOAD 34CC 60 PUSH1 0x01 34CE 60 PUSH1 0x01 34D0 60 PUSH1 0xa0 34D2 1B SHL 34D3 03 SUB 34D4 16 AND 34D5 81 DUP2 34D6 52 MSTORE 34D7 60 PUSH1 0x01 34D9 90 SWAP1 34DA 91 SWAP2 34DB 01 ADD 34DC 90 SWAP1 34DD 60 PUSH1 0x20 34DF 01 ADD 34E0 80 DUP1 34E1 83 DUP4 34E2 11 GT 34E3 61 PUSH2 0x34c9 34E6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @34BE stack[-3] = stack[-3] + 0x20 * stack[-1] // @34C2 memory[0x00:0x20] = stack[-2] // @34D6 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20])] // @34DC stack[-2] = keccak256(memory[0x00:0x20]) + 0x01 // @34DF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x34c9, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_34E7: // Incoming jump from 0x34E6, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x34E6, if not stack[-3] > 0x20 + stack[-1] // Inputs[3] // { // @34EC stack[-7] // @34EC stack[-6] // @34EE stack[-8] // } 34E7 50 POP 34E8 50 POP 34E9 50 POP 34EA 50 POP 34EB 50 POP 34EC 90 SWAP1 34ED 50 POP 34EE 90 SWAP1 34EF 56 *JUMP // Stack delta = -7 // Outputs[1] { @34EE stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_34F0: // Incoming jump from 0x0E3A // Inputs[1] { @34F3 storage[0x97] } 34F0 5B JUMPDEST 34F1 60 PUSH1 0x97 34F3 54 SLOAD 34F4 60 PUSH1 0x01 34F6 60 PUSH1 0x01 34F8 60 PUSH1 0xa0 34FA 1B SHL 34FB 03 SUB 34FC 16 AND 34FD 61 PUSH2 0x3536 3500 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3536, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_3501: // Incoming jump from 0x3500, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @3504 memory[0x40:0x60] // @352C memory[0x40:0x60] // @3535 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3501 60 PUSH1 0x40 3503 80 DUP1 3504 51 MLOAD 3505 62 PUSH3 0x461bcd 3509 60 PUSH1 0xe5 350B 1B SHL 350C 81 DUP2 350D 52 MSTORE 350E 60 PUSH1 0x20 3510 60 PUSH1 0x04 3512 80 DUP1 3513 83 DUP4 3514 01 ADD 3515 91 SWAP2 3516 90 SWAP1 3517 91 SWAP2 3518 52 MSTORE 3519 60 PUSH1 0x24 351B 82 DUP3 351C 01 ADD 351D 52 MSTORE 351E 63 PUSH4 0x50523031 3523 60 PUSH1 0xe0 3525 1B SHL 3526 60 PUSH1 0x44 3528 82 DUP3 3529 01 ADD 352A 52 MSTORE 352B 90 SWAP1 352C 51 MLOAD 352D 90 SWAP1 352E 81 DUP2 352F 90 SWAP1 3530 03 SUB 3531 60 PUSH1 0x64 3533 01 ADD 3534 90 SWAP1 3535 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @350D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3518 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @351D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @352A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @3535 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3536: // Incoming jump from 0x3500, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[2] // { // @3537 stack[-3] // @3538 stack[-1] // } 3536 5B JUMPDEST 3537 82 DUP3 3538 81 DUP2 3539 14 EQ 353A 61 PUSH2 0x3573 353D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3573, if stack[-1] == stack[-3] label_353E: // Incoming jump from 0x353D, if not stack[-1] == stack[-3] // Inputs[3] // { // @3541 memory[0x40:0x60] // @3569 memory[0x40:0x60] // @3572 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 353E 60 PUSH1 0x40 3540 80 DUP1 3541 51 MLOAD 3542 62 PUSH3 0x461bcd 3546 60 PUSH1 0xe5 3548 1B SHL 3549 81 DUP2 354A 52 MSTORE 354B 60 PUSH1 0x20 354D 60 PUSH1 0x04 354F 80 DUP1 3550 83 DUP4 3551 01 ADD 3552 91 SWAP2 3553 90 SWAP1 3554 91 SWAP2 3555 52 MSTORE 3556 60 PUSH1 0x24 3558 82 DUP3 3559 01 ADD 355A 52 MSTORE 355B 63 PUSH4 0x424b3031 3560 60 PUSH1 0xe0 3562 1B SHL 3563 60 PUSH1 0x44 3565 82 DUP3 3566 01 ADD 3567 52 MSTORE 3568 90 SWAP1 3569 51 MLOAD 356A 90 SWAP1 356B 81 DUP2 356C 90 SWAP1 356D 03 SUB 356E 60 PUSH1 0x64 3570 01 ADD 3571 90 SWAP1 3572 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @354A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3555 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @355A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3567 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x424b3031 << 0xe0 // @3572 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3573: // Incoming jump from 0x353D, if stack[-1] == stack[-3] // Inputs[1] { @3579 stack[-3] } 3573 5B JUMPDEST 3574 60 PUSH1 0x00 3576 80 DUP1 3577 80 DUP1 3578 5B JUMPDEST 3579 85 DUP6 357A 81 DUP2 357B 10 LT 357C 15 ISZERO 357D 61 PUSH2 0x35af 3580 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3574 stack[0] = 0x00 // @3576 stack[1] = 0x00 // @3577 stack[2] = 0x00 // } // Block ends with conditional jump to 0x35af, if !(0x00 < stack[-3]) label_3581: // Incoming jump from 0x3580, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x3580, if not !(0x00 < stack[-3]) // Inputs[3] // { // @3584 stack[-5] // @3585 stack[-4] // @3586 stack[-1] // } 3581 61 PUSH2 0x35a5 3584 85 DUP6 3585 85 DUP6 3586 83 DUP4 3587 81 DUP2 3588 81 DUP2 3589 10 LT 358A 61 PUSH2 0x358f 358D 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @3581 stack[0] = 0x35a5 // @3584 stack[1] = stack[-5] // @3585 stack[2] = stack[-4] // @3586 stack[3] = stack[-1] // } // Block ends with conditional call to 0x358f, returns to 0x35A5, if stack[-1] < stack[-4] label_358E: // Incoming jump from 0x358D, if not stack[-1] < stack[-4] 358E FE *ASSERT // Stack delta = +0 // Outputs[1] { @358E assert(); } // Block terminates label_358F: // Incoming call from 0x358D, returns to 0x35A5, if stack[-1] < stack[-4] // Inputs[5] // { // @3590 stack[-1] // @3590 stack[-2] // @3595 stack[-3] // @3596 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @3597 stack[-7] // } 358F 5B JUMPDEST 3590 90 SWAP1 3591 50 POP 3592 60 PUSH1 0x20 3594 02 MUL 3595 01 ADD 3596 35 CALLDATALOAD 3597 84 DUP5 3598 61 PUSH2 0x4b9c 359B 90 SWAP1 359C 91 SWAP2 359D 90 SWAP1 359E 63 PUSH4 0xffffffff 35A3 16 AND 35A4 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @359C stack[-3] = stack[-7] // @359D stack[-2] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } // Block ends with unconditional jump to 0xffffffff & 0x4b9c label_35A5: // Incoming return from call to 0x358F at 0x358D // Inputs[3] // { // @35A6 stack[-4] // @35A6 stack[-1] // @35AA stack[-2] // } 35A5 5B JUMPDEST 35A6 92 SWAP3 35A7 50 POP 35A8 60 PUSH1 0x01 35AA 01 ADD 35AB 61 PUSH2 0x3578 35AE 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @35A6 stack[-4] = stack[-1] // @35AA stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x3578 label_35AF: // Incoming jump from 0x3580, if !(stack[-1] < stack[-6]) // Incoming jump from 0x3580, if !(0x00 < stack[-3]) // Inputs[2] // { // @35B3 storage[0x97] // @35C2 stack[-8] // } 35AF 5B JUMPDEST 35B0 50 POP 35B1 60 PUSH1 0x97 35B3 54 SLOAD 35B4 60 PUSH1 0x01 35B6 60 PUSH1 0x01 35B8 60 PUSH1 0xa0 35BA 1B SHL 35BB 03 SUB 35BC 16 AND 35BD 63 PUSH4 0xdd62ed3e 35C2 88 DUP9 35C3 61 PUSH2 0x35ca 35C6 61 PUSH2 0x4380 35C9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @35BC stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @35BD stack[0] = 0xdd62ed3e // @35C2 stack[1] = stack[-8] // @35C3 stack[2] = 0x35ca // } // Block ends with call to 0x4380, returns to 0x35CA label_35CA: // Incoming return from call to 0x4380 at 0x35C9 // Inputs[7] // { // @35CD memory[0x40:0x60] // @35CE stack[-3] // @35DE stack[-2] // @35F6 stack[-1] // @3616 memory[0x40:0x60] // @361B stack[-4] // @361D address(stack[-4]).code.length // } 35CA 5B JUMPDEST 35CB 60 PUSH1 0x40 35CD 51 MLOAD 35CE 83 DUP4 35CF 63 PUSH4 0xffffffff 35D4 16 AND 35D5 60 PUSH1 0xe0 35D7 1B SHL 35D8 81 DUP2 35D9 52 MSTORE 35DA 60 PUSH1 0x04 35DC 01 ADD 35DD 80 DUP1 35DE 83 DUP4 35DF 60 PUSH1 0x01 35E1 60 PUSH1 0x01 35E3 60 PUSH1 0xa0 35E5 1B SHL 35E6 03 SUB 35E7 16 AND 35E8 60 PUSH1 0x01 35EA 60 PUSH1 0x01 35EC 60 PUSH1 0xa0 35EE 1B SHL 35EF 03 SUB 35F0 16 AND 35F1 81 DUP2 35F2 52 MSTORE 35F3 60 PUSH1 0x20 35F5 01 ADD 35F6 82 DUP3 35F7 60 PUSH1 0x01 35F9 60 PUSH1 0x01 35FB 60 PUSH1 0xa0 35FD 1B SHL 35FE 03 SUB 35FF 16 AND 3600 60 PUSH1 0x01 3602 60 PUSH1 0x01 3604 60 PUSH1 0xa0 3606 1B SHL 3607 03 SUB 3608 16 AND 3609 81 DUP2 360A 52 MSTORE 360B 60 PUSH1 0x20 360D 01 ADD 360E 92 SWAP3 360F 50 POP 3610 50 POP 3611 50 POP 3612 60 PUSH1 0x20 3614 60 PUSH1 0x40 3616 51 MLOAD 3617 80 DUP1 3618 83 DUP4 3619 03 SUB 361A 81 DUP2 361B 86 DUP7 361C 80 DUP1 361D 3B EXTCODESIZE 361E 15 ISZERO 361F 80 DUP1 3620 15 ISZERO 3621 61 PUSH2 0x3629 3624 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @35D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-3]) << 0xe0 // @35F2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-2] // @360A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-1] // @360E stack[-2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @3612 stack[-1] = 0x20 // @3616 stack[0] = memory[0x40:0x60] // @3619 stack[1] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @361A stack[2] = memory[0x40:0x60] // @361B stack[3] = stack[-4] // @361E stack[4] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x3629, if !!address(stack[-4]).code.length label_3625: // Incoming jump from 0x3624, if not !!address(stack[-4]).code.length // Inputs[1] { @3628 memory[0x00:0x00] } 3625 60 PUSH1 0x00 3627 80 DUP1 3628 FD *REVERT // Stack delta = +0 // Outputs[1] { @3628 revert(memory[0x00:0x00]); } // Block terminates label_3629: // Incoming jump from 0x3624, if !!address(stack[-4]).code.length // Inputs[8] // { // @362B msg.gas // @362C stack[-6] // @362C stack[-3] // @362C stack[-4] // @362C memory[stack[-3]:stack[-3] + stack[-4]] // @362C stack[-5] // @362C address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @362C stack[-2] // } 3629 5B JUMPDEST 362A 50 POP 362B 5A GAS 362C FA STATICCALL 362D 15 ISZERO 362E 80 DUP1 362F 15 ISZERO 3630 61 PUSH2 0x363d 3633 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @362C memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @362D stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x363d, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3634: // Incoming jump from 0x3633, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3634 returndata.length // @3638 returndata[0x00:0x00 + returndata.length] // @3639 returndata.length // @363C memory[0x00:0x00 + returndata.length] // } 3634 3D RETURNDATASIZE 3635 60 PUSH1 0x00 3637 80 DUP1 3638 3E RETURNDATACOPY 3639 3D RETURNDATASIZE 363A 60 PUSH1 0x00 363C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3638 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @363C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_363D: // Incoming jump from 0x3633, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3644 memory[0x40:0x60] // @3645 returndata.length // } 363D 5B JUMPDEST 363E 50 POP 363F 50 POP 3640 50 POP 3641 50 POP 3642 60 PUSH1 0x40 3644 51 MLOAD 3645 3D RETURNDATASIZE 3646 60 PUSH1 0x20 3648 81 DUP2 3649 10 LT 364A 15 ISZERO 364B 61 PUSH2 0x3653 364E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3644 stack[-4] = memory[0x40:0x60] // @3645 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3653, if !(returndata.length < 0x20) label_364F: // Incoming jump from 0x364E, if not !(returndata.length < 0x20) // Inputs[1] { @3652 memory[0x00:0x00] } 364F 60 PUSH1 0x00 3651 80 DUP1 3652 FD *REVERT // Stack delta = +0 // Outputs[1] { @3652 revert(memory[0x00:0x00]); } // Block terminates label_3653: // Incoming jump from 0x364E, if !(returndata.length < 0x20) // Inputs[3] // { // @3655 stack[-2] // @3655 memory[stack[-2]:stack[-2] + 0x20] // @3656 stack[-4] // } 3653 5B JUMPDEST 3654 50 POP 3655 51 MLOAD 3656 82 DUP3 3657 11 GT 3658 15 ISZERO 3659 61 PUSH2 0x3692 365C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3692, if !(stack[-4] > memory[stack[-2]:stack[-2] + 0x20]) label_365D: // Incoming jump from 0x365C, if not !(stack[-4] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @3660 memory[0x40:0x60] // @3688 memory[0x40:0x60] // @3691 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 365D 60 PUSH1 0x40 365F 80 DUP1 3660 51 MLOAD 3661 62 PUSH3 0x461bcd 3665 60 PUSH1 0xe5 3667 1B SHL 3668 81 DUP2 3669 52 MSTORE 366A 60 PUSH1 0x20 366C 60 PUSH1 0x04 366E 80 DUP1 366F 83 DUP4 3670 01 ADD 3671 91 SWAP2 3672 90 SWAP1 3673 91 SWAP2 3674 52 MSTORE 3675 60 PUSH1 0x24 3677 82 DUP3 3678 01 ADD 3679 52 MSTORE 367A 63 PUSH4 0x414c3031 367F 60 PUSH1 0xe0 3681 1B SHL 3682 60 PUSH1 0x44 3684 82 DUP3 3685 01 ADD 3686 52 MSTORE 3687 90 SWAP1 3688 51 MLOAD 3689 90 SWAP1 368A 81 DUP2 368B 90 SWAP1 368C 03 SUB 368D 60 PUSH1 0x64 368F 01 ADD 3690 90 SWAP1 3691 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3669 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3674 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3679 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3686 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x414c3031 << 0xe0 // @3691 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3692: // Incoming jump from 0x365C, if !(stack[-4] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @3696 stack[-5] } 3692 5B JUMPDEST 3693 60 PUSH1 0x00 3695 5B JUMPDEST 3696 85 DUP6 3697 81 DUP2 3698 10 LT 3699 15 ISZERO 369A 61 PUSH2 0x36f6 369D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3693 stack[0] = 0x00 } // Block ends with conditional jump to 0x36f6, if !(0x00 < stack[-5]) label_369E: // Incoming jump from 0x369D, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x369D, if not !(0x00 < stack[-5]) // Inputs[4] // { // @36A6 stack[-8] // @36A7 stack[-7] // @36A8 stack[-6] // @36A9 stack[-1] // } 369E 60 PUSH1 0x00 36A0 80 DUP1 36A1 60 PUSH1 0x00 36A3 61 PUSH2 0x36ce 36A6 8B DUP12 36A7 8B DUP12 36A8 8B DUP12 36A9 87 DUP8 36AA 81 DUP2 36AB 81 DUP2 36AC 10 LT 36AD 61 PUSH2 0x36b2 36B0 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @369E stack[0] = 0x00 // @36A0 stack[1] = 0x00 // @36A1 stack[2] = 0x00 // @36A3 stack[3] = 0x36ce // @36A6 stack[4] = stack[-8] // @36A7 stack[5] = stack[-7] // @36A8 stack[6] = stack[-6] // @36A9 stack[7] = stack[-1] // } // Block ends with conditional call to 0x36b2, returns to 0x36CE, if stack[-1] < stack[-6] label_36B1: // Incoming jump from 0x36B0, if not stack[-1] < stack[-6] 36B1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @36B1 assert(); } // Block terminates label_36B2: // Incoming call from 0x36B0, returns to 0x36CE, if stack[-1] < stack[-6] // Inputs[7] // { // @36B3 stack[-1] // @36B3 stack[-2] // @36B8 stack[-3] // @36B9 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @36C3 stack[-13] // @36C4 stack[-12] // @36C5 stack[-9] // } 36B2 5B JUMPDEST 36B3 90 SWAP1 36B4 50 POP 36B5 60 PUSH1 0x20 36B7 02 MUL 36B8 01 ADD 36B9 35 CALLDATALOAD 36BA 60 PUSH1 0x01 36BC 60 PUSH1 0x01 36BE 60 PUSH1 0xa0 36C0 1B SHL 36C1 03 SUB 36C2 16 AND 36C3 8A DUP11 36C4 8A DUP11 36C5 88 DUP9 36C6 81 DUP2 36C7 81 DUP2 36C8 10 LT 36C9 61 PUSH2 0x16cb 36CC 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @36C2 stack[-3] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @36C3 stack[-2] = stack[-13] // @36C4 stack[-1] = stack[-12] // @36C5 stack[0] = stack[-9] // } // Block ends with conditional jump to 0x16cb, if stack[-9] < stack[-12] label_36CD: // Incoming jump from 0x36CC, if not stack[-9] < stack[-12] 36CD FE *ASSERT // Stack delta = +0 // Outputs[1] { @36CD assert(); } // Block terminates label_36CE: // Incoming return from call to 0x36B2 at 0x36B0 // Inputs[7] // { // @36CF stack[-1] // @36CF stack[-3] // @36D0 stack[-6] // @36D2 stack[-5] // @36D2 stack[-2] // @36D4 stack[-4] // @36D9 stack[-8] // } 36CE 5B JUMPDEST 36CF 91 SWAP2 36D0 94 SWAP5 36D1 50 POP 36D2 92 SWAP3 36D3 50 POP 36D4 90 SWAP1 36D5 50 POP 36D6 61 PUSH2 0x36e5 36D9 85 DUP6 36DA 82 DUP3 36DB 63 PUSH4 0xffffffff 36E0 61 PUSH2 0x4b9c 36E3 16 AND 36E4 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @36D0 stack[-6] = stack[-3] // @36D2 stack[-5] = stack[-2] // @36D4 stack[-4] = stack[-1] // @36D6 stack[-3] = 0x36e5 // @36D9 stack[-2] = stack[-8] // @36DA stack[-1] = stack[-1] // } // Block ends with call to 0x4b9c & 0xffffffff, returns to 0x36E5 label_36E5: // Incoming return from call to 0x4B9C at 0x36E4 // Inputs[5] // { // @36E6 stack[-6] // @36E6 stack[-1] // @36EB stack[-3] // @36EC stack[-5] // @36F3 stack[-4] // } 36E5 5B JUMPDEST 36E6 94 SWAP5 36E7 50 POP 36E8 50 POP 36E9 60 PUSH1 0x01 36EB 90 SWAP1 36EC 92 SWAP3 36ED 01 ADD 36EE 91 SWAP2 36EF 50 POP 36F0 61 PUSH2 0x3695 36F3 90 SWAP1 36F4 50 POP 36F5 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @36E6 stack[-6] = stack[-1] // @36EE stack[-5] = stack[-5] + 0x01 // } // Block ends with unconditional jump to 0x3695 label_36F6: // Incoming jump from 0x369D, if !(stack[-1] < stack[-6]) // Incoming jump from 0x369D, if !(0x00 < stack[-5]) // Inputs[2] // { // @36FA storage[0x97] // @3709 stack[-8] // } 36F6 5B JUMPDEST 36F7 50 POP 36F8 60 PUSH1 0x97 36FA 54 SLOAD 36FB 60 PUSH1 0x01 36FD 60 PUSH1 0x01 36FF 60 PUSH1 0xa0 3701 1B SHL 3702 03 SUB 3703 16 AND 3704 63 PUSH4 0xf019c267 3709 88 DUP9 370A 61 PUSH2 0x3711 370D 61 PUSH2 0x4380 3710 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @3703 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @3704 stack[0] = 0xf019c267 // @3709 stack[1] = stack[-8] // @370A stack[2] = 0x3711 // } // Block ends with call to 0x4380, returns to 0x3711 label_3711: // Incoming return from call to 0x4380 at 0x3710 // Inputs[8] // { // @3712 stack[-5] // @3715 memory[0x40:0x60] // @3716 stack[-3] // @3726 stack[-2] // @373E stack[-1] // @3765 memory[0x40:0x60] // @376C stack[-4] // @376E address(stack[-4]).code.length // } 3711 5B JUMPDEST 3712 84 DUP5 3713 60 PUSH1 0x40 3715 51 MLOAD 3716 84 DUP5 3717 63 PUSH4 0xffffffff 371C 16 AND 371D 60 PUSH1 0xe0 371F 1B SHL 3720 81 DUP2 3721 52 MSTORE 3722 60 PUSH1 0x04 3724 01 ADD 3725 80 DUP1 3726 84 DUP5 3727 60 PUSH1 0x01 3729 60 PUSH1 0x01 372B 60 PUSH1 0xa0 372D 1B SHL 372E 03 SUB 372F 16 AND 3730 60 PUSH1 0x01 3732 60 PUSH1 0x01 3734 60 PUSH1 0xa0 3736 1B SHL 3737 03 SUB 3738 16 AND 3739 81 DUP2 373A 52 MSTORE 373B 60 PUSH1 0x20 373D 01 ADD 373E 83 DUP4 373F 60 PUSH1 0x01 3741 60 PUSH1 0x01 3743 60 PUSH1 0xa0 3745 1B SHL 3746 03 SUB 3747 16 AND 3748 60 PUSH1 0x01 374A 60 PUSH1 0x01 374C 60 PUSH1 0xa0 374E 1B SHL 374F 03 SUB 3750 16 AND 3751 81 DUP2 3752 52 MSTORE 3753 60 PUSH1 0x20 3755 01 ADD 3756 82 DUP3 3757 81 DUP2 3758 52 MSTORE 3759 60 PUSH1 0x20 375B 01 ADD 375C 93 SWAP4 375D 50 POP 375E 50 POP 375F 50 POP 3760 50 POP 3761 60 PUSH1 0x00 3763 60 PUSH1 0x40 3765 51 MLOAD 3766 80 DUP1 3767 83 DUP4 3768 03 SUB 3769 81 DUP2 376A 60 PUSH1 0x00 376C 87 DUP8 376D 80 DUP1 376E 3B EXTCODESIZE 376F 15 ISZERO 3770 80 DUP1 3771 15 ISZERO 3772 61 PUSH2 0x377a 3775 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @3721 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-3]) << 0xe0 // @373A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-2] // @3752 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-1] // @3758 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @375C stack[-2] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @3761 stack[-1] = 0x00 // @3765 stack[0] = memory[0x40:0x60] // @3768 stack[1] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3769 stack[2] = memory[0x40:0x60] // @376A stack[3] = 0x00 // @376C stack[4] = stack[-4] // @376F stack[5] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x377a, if !!address(stack[-4]).code.length label_3776: // Incoming jump from 0x3775, if not !!address(stack[-4]).code.length // Inputs[1] { @3779 memory[0x00:0x00] } 3776 60 PUSH1 0x00 3778 80 DUP1 3779 FD *REVERT // Stack delta = +0 // Outputs[1] { @3779 revert(memory[0x00:0x00]); } // Block terminates label_377A: // Incoming jump from 0x3775, if !!address(stack[-4]).code.length // Inputs[9] // { // @377C msg.gas // @377D stack[-5] // @377D address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @377D stack[-4] // @377D stack[-2] // @377D stack[-7] // @377D stack[-3] // @377D stack[-6] // @377D memory[stack[-4]:stack[-4] + stack[-5]] // } 377A 5B JUMPDEST 377B 50 POP 377C 5A GAS 377D F1 CALL 377E 15 ISZERO 377F 80 DUP1 3780 15 ISZERO 3781 61 PUSH2 0x378e 3784 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @377D memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @377E 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 0x378e, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3785: // Incoming jump from 0x3784, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3785 returndata.length // @3789 returndata[0x00:0x00 + returndata.length] // @378A returndata.length // @378D memory[0x00:0x00 + returndata.length] // } 3785 3D RETURNDATASIZE 3786 60 PUSH1 0x00 3788 80 DUP1 3789 3E RETURNDATACOPY 378A 3D RETURNDATASIZE 378B 60 PUSH1 0x00 378D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3789 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @378D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_378E: // Incoming jump from 0x3784, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @379A stack[-12] } 378E 5B JUMPDEST 378F 50 POP 3790 50 POP 3791 50 POP 3792 50 POP 3793 50 POP 3794 50 POP 3795 50 POP 3796 50 POP 3797 50 POP 3798 50 POP 3799 50 POP 379A 56 *JUMP // Stack delta = -12 // Block ends with unconditional jump to stack[-12] label_379B: // Incoming jump from 0x0E60 379B 5B JUMPDEST 379C 61 PUSH2 0x37a3 379F 61 PUSH2 0x4380 37A2 56 *JUMP // Stack delta = +1 // Outputs[1] { @379C stack[0] = 0x37a3 } // Block ends with call to 0x4380, returns to 0x37A3 label_37A3: // Incoming return from call to 0x4380 at 0x37A2 // Inputs[2] // { // @37A6 storage[0x65] // @37B2 stack[-1] // } 37A3 5B JUMPDEST 37A4 60 PUSH1 0x65 37A6 54 SLOAD 37A7 60 PUSH1 0x01 37A9 60 PUSH1 0x01 37AB 60 PUSH1 0xa0 37AD 1B SHL 37AE 03 SUB 37AF 90 SWAP1 37B0 81 DUP2 37B1 16 AND 37B2 91 SWAP2 37B3 16 AND 37B4 14 EQ 37B5 61 PUSH2 0x37f3 37B8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x37f3, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] label_37B9: // Incoming jump from 0x37B8, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[5] // { // @37BC memory[0x40:0x60] // @37D7 memory[0x00:0x20] // @37E0 memory[0x00:0x20] // @37E9 memory[0x40:0x60] // @37F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 37B9 60 PUSH1 0x40 37BB 80 DUP1 37BC 51 MLOAD 37BD 62 PUSH3 0x461bcd 37C1 60 PUSH1 0xe5 37C3 1B SHL 37C4 81 DUP2 37C5 52 MSTORE 37C6 60 PUSH1 0x20 37C8 60 PUSH1 0x04 37CA 82 DUP3 37CB 01 ADD 37CC 81 DUP2 37CD 90 SWAP1 37CE 52 MSTORE 37CF 60 PUSH1 0x24 37D1 82 DUP3 37D2 01 ADD 37D3 52 MSTORE 37D4 60 PUSH1 0x00 37D6 80 DUP1 37D7 51 MLOAD 37D8 60 PUSH1 0x20 37DA 61 PUSH2 0x56b9 37DD 83 DUP4 37DE 39 CODECOPY 37DF 81 DUP2 37E0 51 MLOAD 37E1 91 SWAP2 37E2 52 MSTORE 37E3 60 PUSH1 0x44 37E5 82 DUP3 37E6 01 ADD 37E7 52 MSTORE 37E8 90 SWAP1 37E9 51 MLOAD 37EA 90 SWAP1 37EB 81 DUP2 37EC 90 SWAP1 37ED 03 SUB 37EE 60 PUSH1 0x64 37F0 01 ADD 37F1 90 SWAP1 37F2 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @37C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @37CE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @37D3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @37DE memory[0x00:0x20] = code[0x56b9:0x56d9] // @37E2 memory[0x00:0x20] = memory[0x00:0x20] // @37E7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @37F2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_37F3: // Incoming jump from 0x37B8, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[1] { @37F9 stack[-1] } 37F3 5B JUMPDEST 37F4 61 PUSH2 0x3804 37F7 60 PUSH1 0x98 37F9 82 DUP3 37FA 63 PUSH4 0xffffffff 37FF 61 PUSH2 0x45eb 3802 16 AND 3803 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @37F4 stack[0] = 0x3804 // @37F7 stack[1] = 0x98 // @37F9 stack[2] = stack[-1] // } // Block ends with call to 0x45eb & 0xffffffff, returns to 0x3804 label_3804: // Incoming return from call to 0x45EB at 0x3803 // Inputs[4] // { // @3807 memory[0x40:0x60] // @3810 stack[-1] // @3838 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @383A stack[-2] // } 3804 5B JUMPDEST 3805 60 PUSH1 0x40 3807 51 MLOAD 3808 60 PUSH1 0x01 380A 60 PUSH1 0x01 380C 60 PUSH1 0xa0 380E 1B SHL 380F 03 SUB 3810 82 DUP3 3811 16 AND 3812 90 SWAP1 3813 7F PUSH32 0xe78a1675a4b4d68d04fc70b93f9c37c5288e084d9b02d718103f7ad5e292b688 3834 90 SWAP1 3835 60 PUSH1 0x00 3837 90 SWAP1 3838 A2 LOG2 3839 50 POP 383A 56 *JUMP // Stack delta = -2 // Outputs[1] { @3838 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xe78a1675a4b4d68d04fc70b93f9c37c5288e084d9b02d718103f7ad5e292b688, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_383B: // Incoming call from 0x0E68, returns to 0x04E9 383B 5B JUMPDEST 383C 61 PUSH2 0x3843 383F 61 PUSH2 0x4380 3842 56 *JUMP // Stack delta = +1 // Outputs[1] { @383C stack[0] = 0x3843 } // Block ends with call to 0x4380, returns to 0x3843 label_3843: // Incoming return from call to 0x4380 at 0x3842 // Inputs[2] // { // @3846 storage[0x65] // @3852 stack[-1] // } 3843 5B JUMPDEST 3844 60 PUSH1 0x65 3846 54 SLOAD 3847 60 PUSH1 0x01 3849 60 PUSH1 0x01 384B 60 PUSH1 0xa0 384D 1B SHL 384E 03 SUB 384F 90 SWAP1 3850 81 DUP2 3851 16 AND 3852 91 SWAP2 3853 16 AND 3854 14 EQ 3855 61 PUSH2 0x3893 3858 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3893, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] label_3859: // Incoming jump from 0x3858, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[5] // { // @385C memory[0x40:0x60] // @3877 memory[0x00:0x20] // @3880 memory[0x00:0x20] // @3889 memory[0x40:0x60] // @3892 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3859 60 PUSH1 0x40 385B 80 DUP1 385C 51 MLOAD 385D 62 PUSH3 0x461bcd 3861 60 PUSH1 0xe5 3863 1B SHL 3864 81 DUP2 3865 52 MSTORE 3866 60 PUSH1 0x20 3868 60 PUSH1 0x04 386A 82 DUP3 386B 01 ADD 386C 81 DUP2 386D 90 SWAP1 386E 52 MSTORE 386F 60 PUSH1 0x24 3871 82 DUP3 3872 01 ADD 3873 52 MSTORE 3874 60 PUSH1 0x00 3876 80 DUP1 3877 51 MLOAD 3878 60 PUSH1 0x20 387A 61 PUSH2 0x56b9 387D 83 DUP4 387E 39 CODECOPY 387F 81 DUP2 3880 51 MLOAD 3881 91 SWAP2 3882 52 MSTORE 3883 60 PUSH1 0x44 3885 82 DUP3 3886 01 ADD 3887 52 MSTORE 3888 90 SWAP1 3889 51 MLOAD 388A 90 SWAP1 388B 81 DUP2 388C 90 SWAP1 388D 03 SUB 388E 60 PUSH1 0x64 3890 01 ADD 3891 90 SWAP1 3892 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @3865 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @386E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3873 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @387E memory[0x00:0x20] = code[0x56b9:0x56d9] // @3882 memory[0x00:0x20] = memory[0x00:0x20] // @3887 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @3892 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3893: // Incoming jump from 0x3858, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] 3893 5B JUMPDEST 3894 61 PUSH2 0x389b 3897 61 PUSH2 0x4bf6 389A 56 *JUMP // Stack delta = +1 // Outputs[1] { @3894 stack[0] = 0x389b } // Block ends with call to 0x4bf6, returns to 0x389B label_389B: // Incoming return from call to 0x4BF6 at 0x389A // Inputs[1] { @389C stack[-1] } 389B 5B JUMPDEST 389C 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_389D: // Incoming call from 0x0E70, returns to 0x0704 // Inputs[2] // { // @38A0 storage[0x97] // @38AA stack[-1] // } 389D 5B JUMPDEST 389E 60 PUSH1 0x97 38A0 54 SLOAD 38A1 60 PUSH1 0x01 38A3 60 PUSH1 0x01 38A5 60 PUSH1 0xa0 38A7 1B SHL 38A8 03 SUB 38A9 16 AND 38AA 90 SWAP1 38AB 56 *JUMP // Stack delta = +0 // Outputs[1] { @38AA stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x97] } // Block ends with unconditional jump to stack[-1] label_38AC: // Incoming jump from 0x0EC1 // Inputs[1] { @38AF storage[0x97] } 38AC 5B JUMPDEST 38AD 60 PUSH1 0x97 38AF 54 SLOAD 38B0 60 PUSH1 0x01 38B2 60 PUSH1 0x01 38B4 60 PUSH1 0xa0 38B6 1B SHL 38B7 03 SUB 38B8 16 AND 38B9 61 PUSH2 0x38f2 38BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x38f2, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_38BD: // Incoming jump from 0x38BC, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @38C0 memory[0x40:0x60] // @38E8 memory[0x40:0x60] // @38F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 38BD 60 PUSH1 0x40 38BF 80 DUP1 38C0 51 MLOAD 38C1 62 PUSH3 0x461bcd 38C5 60 PUSH1 0xe5 38C7 1B SHL 38C8 81 DUP2 38C9 52 MSTORE 38CA 60 PUSH1 0x20 38CC 60 PUSH1 0x04 38CE 80 DUP1 38CF 83 DUP4 38D0 01 ADD 38D1 91 SWAP2 38D2 90 SWAP1 38D3 91 SWAP2 38D4 52 MSTORE 38D5 60 PUSH1 0x24 38D7 82 DUP3 38D8 01 ADD 38D9 52 MSTORE 38DA 63 PUSH4 0x50523031 38DF 60 PUSH1 0xe0 38E1 1B SHL 38E2 60 PUSH1 0x44 38E4 82 DUP3 38E5 01 ADD 38E6 52 MSTORE 38E7 90 SWAP1 38E8 51 MLOAD 38E9 90 SWAP1 38EA 81 DUP2 38EB 90 SWAP1 38EC 03 SUB 38ED 60 PUSH1 0x64 38EF 01 ADD 38F0 90 SWAP1 38F1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @38C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @38D4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @38D9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @38E6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @38F1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_38F2: // Incoming jump from 0x38BC, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[2] // { // @38F3 block.timestamp // @38F4 stack[-4] // } 38F2 5B JUMPDEST 38F3 42 TIMESTAMP 38F4 84 DUP5 38F5 10 LT 38F6 15 ISZERO 38F7 61 PUSH2 0x3930 38FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3930, if !(stack[-4] < block.timestamp) label_38FB: // Incoming jump from 0x38FA, if not !(stack[-4] < block.timestamp) // Inputs[3] // { // @38FE memory[0x40:0x60] // @3926 memory[0x40:0x60] // @392F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 38FB 60 PUSH1 0x40 38FD 80 DUP1 38FE 51 MLOAD 38FF 62 PUSH3 0x461bcd 3903 60 PUSH1 0xe5 3905 1B SHL 3906 81 DUP2 3907 52 MSTORE 3908 60 PUSH1 0x20 390A 60 PUSH1 0x04 390C 80 DUP1 390D 83 DUP4 390E 01 ADD 390F 91 SWAP2 3910 90 SWAP1 3911 91 SWAP2 3912 52 MSTORE 3913 60 PUSH1 0x24 3915 82 DUP3 3916 01 ADD 3917 52 MSTORE 3918 63 PUSH4 0x45583031 391D 60 PUSH1 0xe0 391F 1B SHL 3920 60 PUSH1 0x44 3922 82 DUP3 3923 01 ADD 3924 52 MSTORE 3925 90 SWAP1 3926 51 MLOAD 3927 90 SWAP1 3928 81 DUP2 3929 90 SWAP1 392A 03 SUB 392B 60 PUSH1 0x64 392D 01 ADD 392E 90 SWAP1 392F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3907 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3912 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3917 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3924 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45583031 << 0xe0 // @392F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3930: // Incoming jump from 0x38FA, if !(stack[-4] < block.timestamp) // Inputs[12] // { // @393A stack[-7] // @394E memory[0x00:0x40] // @3950 storage[keccak256(memory[0x00:0x40])] // @3959 memory[0x40:0x60] // @3989 stack[-6] // @3994 stack[-5] // @39A4 stack[-4] // @39A8 memory[0x40:0x60] // @39BB storage[0x0105] // @39C0 stack[-3] // @39C1 stack[-2] // @39C2 stack[-1] // } 3930 5B JUMPDEST 3931 60 PUSH1 0x01 3933 60 PUSH1 0x01 3935 60 PUSH1 0xa0 3937 1B SHL 3938 03 SUB 3939 80 DUP1 393A 88 DUP9 393B 16 AND 393C 60 PUSH1 0x00 393E 81 DUP2 393F 81 DUP2 3940 52 MSTORE 3941 61 PUSH2 0x0106 3944 60 PUSH1 0x20 3946 90 SWAP1 3947 81 DUP2 3948 52 MSTORE 3949 60 PUSH1 0x40 394B 91 SWAP2 394C 82 DUP3 394D 90 SWAP1 394E 20 SHA3 394F 80 DUP1 3950 54 SLOAD 3951 60 PUSH1 0x01 3953 81 DUP2 3954 01 ADD 3955 90 SWAP1 3956 91 SWAP2 3957 55 SSTORE 3958 82 DUP3 3959 51 MLOAD 395A 7F PUSH32 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 397B 92 SWAP3 397C 81 DUP2 397D 01 ADD 397E 92 SWAP3 397F 90 SWAP1 3980 92 SWAP3 3981 52 MSTORE 3982 81 DUP2 3983 83 DUP4 3984 01 ADD 3985 84 DUP5 3986 90 SWAP1 3987 52 MSTORE 3988 93 SWAP4 3989 8A DUP11 398A 16 AND 398B 60 PUSH1 0x60 398D 82 DUP3 398E 01 ADD 398F 52 MSTORE 3990 60 PUSH1 0x80 3992 81 DUP2 3993 01 ADD 3994 89 DUP10 3995 90 SWAP1 3996 52 MSTORE 3997 60 PUSH1 0xa0 3999 81 DUP2 399A 01 ADD 399B 93 SWAP4 399C 90 SWAP1 399D 93 SWAP4 399E 52 MSTORE 399F 60 PUSH1 0xc0 39A1 80 DUP1 39A2 84 DUP5 39A3 01 ADD 39A4 88 DUP9 39A5 90 SWAP1 39A6 52 MSTORE 39A7 81 DUP2 39A8 51 MLOAD 39A9 80 DUP1 39AA 85 DUP6 39AB 03 SUB 39AC 90 SWAP1 39AD 91 SWAP2 39AE 01 ADD 39AF 81 DUP2 39B0 52 MSTORE 39B1 60 PUSH1 0xe0 39B3 90 SWAP1 39B4 93 SWAP4 39B5 01 ADD 39B6 90 SWAP1 39B7 52 MSTORE 39B8 61 PUSH2 0x0105 39BB 54 SLOAD 39BC 61 PUSH2 0x39c8 39BF 90 SWAP1 39C0 86 DUP7 39C1 86 DUP7 39C2 86 DUP7 39C3 86 DUP7 39C4 61 PUSH2 0x46f6 39C7 56 *JUMP // Stack delta = +8 // Outputs[19] // { // @393B stack[1] = stack[-7] & (0x01 << 0xa0) - 0x01 // @3940 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @3948 memory[0x20:0x40] = 0x0106 // @3957 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @3981 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 // @3987 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @398F memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @3996 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-5] // @399E memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = storage[keccak256(memory[0x00:0x40])] // @39A6 memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-4] // @39B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @39B4 stack[0] = memory[0x40:0x60] // @39B7 memory[0x40:0x60] = memory[0x40:0x60] + 0xe0 // @39BF stack[2] = 0x39c8 // @39BF stack[3] = storage[0x0105] // @39C0 stack[4] = stack[-3] // @39C1 stack[5] = stack[-2] // @39C2 stack[6] = stack[-1] // @39C3 stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x46f6, returns to 0x39C8 label_39C8: // Incoming return from call to 0x46F6 at 0x39C7 // Inputs[2] // { // @39D1 stack[-1] // @39D2 stack[-2] // } 39C8 5B JUMPDEST 39C9 60 PUSH1 0x01 39CB 60 PUSH1 0x01 39CD 60 PUSH1 0xa0 39CF 1B SHL 39D0 03 SUB 39D1 16 AND 39D2 14 EQ 39D3 61 PUSH2 0x3a0c 39D6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3a0c, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_39D7: // Incoming jump from 0x39D6, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @39DA memory[0x40:0x60] // @3A02 memory[0x40:0x60] // @3A0B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 39D7 60 PUSH1 0x40 39D9 80 DUP1 39DA 51 MLOAD 39DB 62 PUSH3 0x461bcd 39DF 60 PUSH1 0xe5 39E1 1B SHL 39E2 81 DUP2 39E3 52 MSTORE 39E4 60 PUSH1 0x20 39E6 60 PUSH1 0x04 39E8 80 DUP1 39E9 83 DUP4 39EA 01 ADD 39EB 91 SWAP2 39EC 90 SWAP1 39ED 91 SWAP2 39EE 52 MSTORE 39EF 60 PUSH1 0x24 39F1 82 DUP3 39F2 01 ADD 39F3 52 MSTORE 39F4 63 PUSH4 0x53493031 39F9 60 PUSH1 0xe0 39FB 1B SHL 39FC 60 PUSH1 0x44 39FE 82 DUP3 39FF 01 ADD 3A00 52 MSTORE 3A01 90 SWAP1 3A02 51 MLOAD 3A03 90 SWAP1 3A04 81 DUP2 3A05 90 SWAP1 3A06 03 SUB 3A07 60 PUSH1 0x64 3A09 01 ADD 3A0A 90 SWAP1 3A0B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @39E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @39EE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @39F3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3A00 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53493031 << 0xe0 // @3A0B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3A0C: // Incoming jump from 0x39D6, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @3A10 stack[-8] // @3A11 stack[-7] // @3A12 stack[-6] // } 3A0C 5B JUMPDEST 3A0D 61 PUSH2 0x3a17 3A10 88 DUP9 3A11 88 DUP9 3A12 88 DUP9 3A13 61 PUSH2 0x4384 3A16 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3A0D stack[0] = 0x3a17 // @3A10 stack[1] = stack[-8] // @3A11 stack[2] = stack[-7] // @3A12 stack[3] = stack[-6] // } // Block ends with call to 0x4384, returns to 0x3A17 label_3A17: // Incoming return from call to 0x4384 at 0x3A16 // Inputs[1] { @3A20 stack[-9] } 3A17 5B JUMPDEST 3A18 50 POP 3A19 50 POP 3A1A 50 POP 3A1B 50 POP 3A1C 50 POP 3A1D 50 POP 3A1E 50 POP 3A1F 50 POP 3A20 56 *JUMP // Stack delta = -9 // Block ends with unconditional jump to stack[-9] label_3A21: // Incoming jump from 0x0EED // Inputs[1] { @3A24 storage[0x97] } 3A21 5B JUMPDEST 3A22 60 PUSH1 0x97 3A24 54 SLOAD 3A25 60 PUSH1 0x01 3A27 60 PUSH1 0x01 3A29 60 PUSH1 0xa0 3A2B 1B SHL 3A2C 03 SUB 3A2D 16 AND 3A2E 61 PUSH2 0x3a67 3A31 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3a67, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_3A32: // Incoming jump from 0x3A31, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @3A35 memory[0x40:0x60] // @3A5D memory[0x40:0x60] // @3A66 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3A32 60 PUSH1 0x40 3A34 80 DUP1 3A35 51 MLOAD 3A36 62 PUSH3 0x461bcd 3A3A 60 PUSH1 0xe5 3A3C 1B SHL 3A3D 81 DUP2 3A3E 52 MSTORE 3A3F 60 PUSH1 0x20 3A41 60 PUSH1 0x04 3A43 80 DUP1 3A44 83 DUP4 3A45 01 ADD 3A46 91 SWAP2 3A47 90 SWAP1 3A48 91 SWAP2 3A49 52 MSTORE 3A4A 60 PUSH1 0x24 3A4C 82 DUP3 3A4D 01 ADD 3A4E 52 MSTORE 3A4F 63 PUSH4 0x50523031 3A54 60 PUSH1 0xe0 3A56 1B SHL 3A57 60 PUSH1 0x44 3A59 82 DUP3 3A5A 01 ADD 3A5B 52 MSTORE 3A5C 90 SWAP1 3A5D 51 MLOAD 3A5E 90 SWAP1 3A5F 81 DUP2 3A60 90 SWAP1 3A61 03 SUB 3A62 60 PUSH1 0x64 3A64 01 ADD 3A65 90 SWAP1 3A66 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3A3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3A49 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3A4E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3A5B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @3A66 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3A67: // Incoming jump from 0x3A31, if (0x01 << 0xa0) - 0x01 & storage[0x97] 3A67 5B JUMPDEST 3A68 61 PUSH2 0x2521 3A6B 61 PUSH2 0x3a72 3A6E 61 PUSH2 0x4380 3A71 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3A68 stack[0] = 0x2521 // @3A6B stack[1] = 0x3a72 // } // Block ends with call to 0x4380, returns to 0x3A72 label_3A72: // Incoming return from call to 0x4380 at 0x3A71 // Inputs[2] // { // @3A73 stack[-4] // @3A74 stack[-3] // } 3A72 5B JUMPDEST 3A73 83 DUP4 3A74 83 DUP4 3A75 61 PUSH2 0x4b3f 3A78 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3A73 stack[0] = stack[-4] // @3A74 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x4b3f label_3A79: // Incoming call from 0x0EF5, returns to 0x0543 // Inputs[1] { @3A9B stack[-1] } 3A79 5B JUMPDEST 3A7A 7F PUSH32 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429 3A9B 81 DUP2 3A9C 56 *JUMP // Stack delta = +1 // Outputs[1] { @3A7A stack[0] = 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429 } // Block ends with unconditional jump to stack[-1] label_3A9D: // Incoming jump from 0x0F1B // Inputs[1] { @3AA5 stack[-1] } 3A9D 5B JUMPDEST 3A9E 60 PUSH1 0x00 3AA0 61 PUSH2 0x14f0 3AA3 60 PUSH1 0x99 3AA5 83 DUP4 3AA6 63 PUSH4 0xffffffff 3AAB 61 PUSH2 0x4440 3AAE 16 AND 3AAF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3A9E stack[0] = 0x00 // @3AA0 stack[1] = 0x14f0 // @3AA3 stack[2] = 0x99 // @3AA5 stack[3] = stack[-1] // } // Block ends with call to 0x4440 & 0xffffffff, returns to 0x14F0 label_3AB0: // Incoming jump from 0x0F38 // Inputs[2] // { // @3AB4 storage[0x0102] // @3ABA stack[-1] // } 3AB0 5B JUMPDEST 3AB1 61 PUSH2 0x0102 3AB4 54 SLOAD 3AB5 60 PUSH1 0x00 3AB7 90 SWAP1 3AB8 81 DUP2 3AB9 90 SWAP1 3ABA 83 DUP4 3ABB 10 LT 3ABC 61 PUSH2 0x3af5 3ABF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3AB7 stack[0] = 0x00 // @3AB9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3af5, if stack[-1] < storage[0x0102] label_3AC0: // Incoming jump from 0x3ABF, if not stack[-1] < storage[0x0102] // Inputs[3] // { // @3AC3 memory[0x40:0x60] // @3AEB memory[0x40:0x60] // @3AF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3AC0 60 PUSH1 0x40 3AC2 80 DUP1 3AC3 51 MLOAD 3AC4 62 PUSH3 0x461bcd 3AC8 60 PUSH1 0xe5 3ACA 1B SHL 3ACB 81 DUP2 3ACC 52 MSTORE 3ACD 60 PUSH1 0x20 3ACF 60 PUSH1 0x04 3AD1 80 DUP1 3AD2 83 DUP4 3AD3 01 ADD 3AD4 91 SWAP2 3AD5 90 SWAP1 3AD6 91 SWAP2 3AD7 52 MSTORE 3AD8 60 PUSH1 0x24 3ADA 82 DUP3 3ADB 01 ADD 3ADC 52 MSTORE 3ADD 63 PUSH4 0x52453031 3AE2 60 PUSH1 0xe0 3AE4 1B SHL 3AE5 60 PUSH1 0x44 3AE7 82 DUP3 3AE8 01 ADD 3AE9 52 MSTORE 3AEA 90 SWAP1 3AEB 51 MLOAD 3AEC 90 SWAP1 3AED 81 DUP2 3AEE 90 SWAP1 3AEF 03 SUB 3AF0 60 PUSH1 0x64 3AF2 01 ADD 3AF3 90 SWAP1 3AF4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3ACC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3AD7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3ADC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3AE9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x52453031 << 0xe0 // @3AF4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3AF5: // Incoming jump from 0x3ABF, if stack[-1] < storage[0x0102] // Inputs[2] // { // @3AF9 stack[-3] // @3AFB storage[0x0102] // } 3AF5 5B JUMPDEST 3AF6 61 PUSH2 0x0102 3AF9 83 DUP4 3AFA 81 DUP2 3AFB 54 SLOAD 3AFC 81 DUP2 3AFD 10 LT 3AFE 61 PUSH2 0x3b03 3B01 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3AF6 stack[0] = 0x0102 // @3AF9 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x3b03, if stack[-3] < storage[0x0102] label_3B02: // Incoming jump from 0x3B01, if not stack[-3] < storage[0x0102] 3B02 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3B02 assert(); } // Block terminates label_3B03: // Incoming jump from 0x3B01, if stack[-3] < storage[0x0102] // Inputs[6] // { // @3B04 stack[-1] // @3B04 stack[-2] // @3B0C memory[0x00:0x20] // @3B0E storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @3B12 stack[-5] // @3B14 storage[0x0103] // } 3B03 5B JUMPDEST 3B04 90 SWAP1 3B05 60 PUSH1 0x00 3B07 52 MSTORE 3B08 60 PUSH1 0x20 3B0A 60 PUSH1 0x00 3B0C 20 SHA3 3B0D 01 ADD 3B0E 54 SLOAD 3B0F 61 PUSH2 0x0103 3B12 84 DUP5 3B13 81 DUP2 3B14 54 SLOAD 3B15 81 DUP2 3B16 10 LT 3B17 61 PUSH2 0x3b1c 3B1A 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @3B07 memory[0x00:0x20] = stack[-2] // @3B0E stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @3B0F stack[-1] = 0x0103 // @3B12 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x3b1c, if stack[-5] < storage[0x0103] label_3B1B: // Incoming jump from 0x3B1A, if not stack[-5] < storage[0x0103] 3B1B FE *ASSERT // Stack delta = +0 // Outputs[1] { @3B1B assert(); } // Block terminates label_3B1C: // Incoming jump from 0x3B1A, if stack[-5] < storage[0x0103] // Inputs[9] // { // @3B1D stack[-1] // @3B1D stack[-2] // @3B25 memory[0x00:0x20] // @3B27 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @3B28 stack[-4] // @3B2A stack[-5] // @3B2A stack[-3] // @3B2C stack[-6] // @3B2E stack[-7] // } 3B1C 5B JUMPDEST 3B1D 90 SWAP1 3B1E 60 PUSH1 0x00 3B20 52 MSTORE 3B21 60 PUSH1 0x20 3B23 60 PUSH1 0x00 3B25 20 SHA3 3B26 01 ADD 3B27 54 SLOAD 3B28 91 SWAP2 3B29 50 POP 3B2A 91 SWAP2 3B2B 50 POP 3B2C 91 SWAP2 3B2D 50 POP 3B2E 91 SWAP2 3B2F 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @3B20 memory[0x00:0x20] = stack[-2] // @3B2C stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @3B2E stack[-7] = stack[-3] // } // Block ends with unconditional jump to stack[-7] label_3B30: // Incoming jump from 0x0F7F // Inputs[1] { @3B33 storage[0x97] } 3B30 5B JUMPDEST 3B31 60 PUSH1 0x97 3B33 54 SLOAD 3B34 60 PUSH1 0x00 3B36 90 SWAP1 3B37 60 PUSH1 0x01 3B39 60 PUSH1 0x01 3B3B 60 PUSH1 0xa0 3B3D 1B SHL 3B3E 03 SUB 3B3F 16 AND 3B40 61 PUSH2 0x3b79 3B43 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3B36 stack[0] = 0x00 } // Block ends with conditional jump to 0x3b79, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_3B44: // Incoming jump from 0x3B43, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @3B47 memory[0x40:0x60] // @3B6F memory[0x40:0x60] // @3B78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3B44 60 PUSH1 0x40 3B46 80 DUP1 3B47 51 MLOAD 3B48 62 PUSH3 0x461bcd 3B4C 60 PUSH1 0xe5 3B4E 1B SHL 3B4F 81 DUP2 3B50 52 MSTORE 3B51 60 PUSH1 0x20 3B53 60 PUSH1 0x04 3B55 80 DUP1 3B56 83 DUP4 3B57 01 ADD 3B58 91 SWAP2 3B59 90 SWAP1 3B5A 91 SWAP2 3B5B 52 MSTORE 3B5C 60 PUSH1 0x24 3B5E 82 DUP3 3B5F 01 ADD 3B60 52 MSTORE 3B61 63 PUSH4 0x50523031 3B66 60 PUSH1 0xe0 3B68 1B SHL 3B69 60 PUSH1 0x44 3B6B 82 DUP3 3B6C 01 ADD 3B6D 52 MSTORE 3B6E 90 SWAP1 3B6F 51 MLOAD 3B70 90 SWAP1 3B71 81 DUP2 3B72 90 SWAP1 3B73 03 SUB 3B74 60 PUSH1 0x64 3B76 01 ADD 3B77 90 SWAP1 3B78 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3B50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3B5B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3B60 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3B6D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @3B78 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3B79: // Incoming jump from 0x3B43, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[6] // { // @3B7C storage[0x97] // @3B80 memory[0x40:0x60] // @3B93 stack[-3] // @3B9B stack[-2] // @3BA4 memory[0x40:0x60] // @3BC2 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 3B79 5B JUMPDEST 3B7A 60 PUSH1 0x97 3B7C 54 SLOAD 3B7D 60 PUSH1 0x40 3B7F 80 DUP1 3B80 51 MLOAD 3B81 63 PUSH4 0x6eb1769f 3B86 60 PUSH1 0xe1 3B88 1B SHL 3B89 81 DUP2 3B8A 52 MSTORE 3B8B 60 PUSH1 0x01 3B8D 60 PUSH1 0x01 3B8F 60 PUSH1 0xa0 3B91 1B SHL 3B92 03 SUB 3B93 86 DUP7 3B94 81 DUP2 3B95 16 AND 3B96 60 PUSH1 0x04 3B98 83 DUP4 3B99 01 ADD 3B9A 52 MSTORE 3B9B 85 DUP6 3B9C 81 DUP2 3B9D 16 AND 3B9E 60 PUSH1 0x24 3BA0 83 DUP4 3BA1 01 ADD 3BA2 52 MSTORE 3BA3 91 SWAP2 3BA4 51 MLOAD 3BA5 91 SWAP2 3BA6 90 SWAP1 3BA7 92 SWAP3 3BA8 16 AND 3BA9 91 SWAP2 3BAA 63 PUSH4 0xdd62ed3e 3BAF 91 SWAP2 3BB0 60 PUSH1 0x44 3BB2 80 DUP1 3BB3 83 DUP4 3BB4 01 ADD 3BB5 92 SWAP3 3BB6 60 PUSH1 0x20 3BB8 92 SWAP3 3BB9 91 SWAP2 3BBA 90 SWAP1 3BBB 82 DUP3 3BBC 90 SWAP1 3BBD 03 SUB 3BBE 01 ADD 3BBF 81 DUP2 3BC0 86 DUP7 3BC1 80 DUP1 3BC2 3B EXTCODESIZE 3BC3 15 ISZERO 3BC4 80 DUP1 3BC5 15 ISZERO 3BC6 61 PUSH2 0x3bce 3BC9 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @3B8A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6eb1769f << 0xe1 // @3B9A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @3BA2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @3BA9 stack[0] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @3BAF stack[1] = 0xdd62ed3e // @3BB5 stack[2] = memory[0x40:0x60] + 0x44 // @3BB8 stack[3] = 0x20 // @3BB9 stack[4] = memory[0x40:0x60] // @3BBE stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @3BBF stack[6] = memory[0x40:0x60] // @3BC0 stack[7] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @3BC3 stack[8] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x3bce, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_3BCA: // Incoming jump from 0x3BC9, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @3BCD memory[0x00:0x00] } 3BCA 60 PUSH1 0x00 3BCC 80 DUP1 3BCD FD *REVERT // Stack delta = +0 // Outputs[1] { @3BCD revert(memory[0x00:0x00]); } // Block terminates label_3BCE: // Incoming jump from 0x3BC9, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @3BD0 msg.gas // @3BD1 stack[-5] // @3BD1 stack[-2] // @3BD1 stack[-3] // @3BD1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3BD1 memory[stack[-3]:stack[-3] + stack[-4]] // @3BD1 stack[-6] // @3BD1 stack[-4] // } 3BCE 5B JUMPDEST 3BCF 50 POP 3BD0 5A GAS 3BD1 FA STATICCALL 3BD2 15 ISZERO 3BD3 80 DUP1 3BD4 15 ISZERO 3BD5 61 PUSH2 0x3be2 3BD8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3BD1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3BD2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3be2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3BD9: // Incoming jump from 0x3BD8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3BD9 returndata.length // @3BDD returndata[0x00:0x00 + returndata.length] // @3BDE returndata.length // @3BE1 memory[0x00:0x00 + returndata.length] // } 3BD9 3D RETURNDATASIZE 3BDA 60 PUSH1 0x00 3BDC 80 DUP1 3BDD 3E RETURNDATACOPY 3BDE 3D RETURNDATASIZE 3BDF 60 PUSH1 0x00 3BE1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3BDD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3BE1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3BE2: // Incoming jump from 0x3BD8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3BE9 memory[0x40:0x60] // @3BEA returndata.length // } 3BE2 5B JUMPDEST 3BE3 50 POP 3BE4 50 POP 3BE5 50 POP 3BE6 50 POP 3BE7 60 PUSH1 0x40 3BE9 51 MLOAD 3BEA 3D RETURNDATASIZE 3BEB 60 PUSH1 0x20 3BED 81 DUP2 3BEE 10 LT 3BEF 15 ISZERO 3BF0 61 PUSH2 0x3bf8 3BF3 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3BE9 stack[-4] = memory[0x40:0x60] // @3BEA stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3bf8, if !(returndata.length < 0x20) label_3BF4: // Incoming jump from 0x3BF3, if not !(returndata.length < 0x20) // Inputs[1] { @3BF7 memory[0x00:0x00] } 3BF4 60 PUSH1 0x00 3BF6 80 DUP1 3BF7 FD *REVERT // Stack delta = +0 // Outputs[1] { @3BF7 revert(memory[0x00:0x00]); } // Block terminates label_3BF8: // Incoming jump from 0x3BF3, if !(returndata.length < 0x20) // Inputs[4] // { // @3BFA stack[-2] // @3BFA memory[stack[-2]:stack[-2] + 0x20] // @3BFB stack[-6] // @3BFC stack[-5] // } 3BF8 5B JUMPDEST 3BF9 50 POP 3BFA 51 MLOAD 3BFB 93 SWAP4 3BFC 92 SWAP3 3BFD 50 POP 3BFE 50 POP 3BFF 50 POP 3C00 56 *JUMP // Stack delta = -5 // Outputs[1] { @3BFB stack[-6] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-6] label_3C01: // Incoming jump from 0x0FDE // Inputs[1] { @3C04 storage[0x97] } 3C01 5B JUMPDEST 3C02 60 PUSH1 0x97 3C04 54 SLOAD 3C05 60 PUSH1 0x01 3C07 60 PUSH1 0x01 3C09 60 PUSH1 0xa0 3C0B 1B SHL 3C0C 03 SUB 3C0D 16 AND 3C0E 61 PUSH2 0x3c47 3C11 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3c47, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_3C12: // Incoming jump from 0x3C11, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @3C15 memory[0x40:0x60] // @3C3D memory[0x40:0x60] // @3C46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3C12 60 PUSH1 0x40 3C14 80 DUP1 3C15 51 MLOAD 3C16 62 PUSH3 0x461bcd 3C1A 60 PUSH1 0xe5 3C1C 1B SHL 3C1D 81 DUP2 3C1E 52 MSTORE 3C1F 60 PUSH1 0x20 3C21 60 PUSH1 0x04 3C23 80 DUP1 3C24 83 DUP4 3C25 01 ADD 3C26 91 SWAP2 3C27 90 SWAP1 3C28 91 SWAP2 3C29 52 MSTORE 3C2A 60 PUSH1 0x24 3C2C 82 DUP3 3C2D 01 ADD 3C2E 52 MSTORE 3C2F 63 PUSH4 0x50523031 3C34 60 PUSH1 0xe0 3C36 1B SHL 3C37 60 PUSH1 0x44 3C39 82 DUP3 3C3A 01 ADD 3C3B 52 MSTORE 3C3C 90 SWAP1 3C3D 51 MLOAD 3C3E 90 SWAP1 3C3F 81 DUP2 3C40 90 SWAP1 3C41 03 SUB 3C42 60 PUSH1 0x64 3C44 01 ADD 3C45 90 SWAP1 3C46 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3C1E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3C29 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3C2E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3C3B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @3C46 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3C47: // Incoming jump from 0x3C11, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @3C4B stack[-9] // @3C4C stack[-4] // @3C4D stack[-6] // @3C4E stack[-5] // } 3C47 5B JUMPDEST 3C48 61 PUSH2 0x3c53 3C4B 89 DUP10 3C4C 85 DUP6 3C4D 88 DUP9 3C4E 88 DUP9 3C4F 61 PUSH2 0x466c 3C52 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @3C48 stack[0] = 0x3c53 // @3C4B stack[1] = stack[-9] // @3C4C stack[2] = stack[-4] // @3C4D stack[3] = stack[-6] // @3C4E stack[4] = stack[-5] // } // Block ends with call to 0x466c, returns to 0x3C53 label_3C53: // Incoming return from call to 0x466C at 0x3C52 // Inputs[12] // { // @3C57 memory[0x40:0x60] // @3C87 stack[-9] // @3C90 stack[-8] // @3C9B stack[-7] // @3CA2 stack[-6] // @3CA9 stack[-5] // @3CB1 stack[-4] // @3CB5 memory[0x40:0x60] // @3CCA storage[0x0105] // @3CD2 stack[-3] // @3CD3 stack[-2] // @3CD4 stack[-1] // } 3C53 5B JUMPDEST 3C54 60 PUSH1 0x40 3C56 80 DUP1 3C57 51 MLOAD 3C58 7F PUSH32 0x808c10407a796f3ef2c7ea38c0638ea9d2b8a1c63e3ca9e1f56ce84ae59df73c 3C79 60 PUSH1 0x20 3C7B 82 DUP3 3C7C 01 ADD 3C7D 52 MSTORE 3C7E 60 PUSH1 0x01 3C80 60 PUSH1 0x01 3C82 60 PUSH1 0xa0 3C84 1B SHL 3C85 03 SUB 3C86 80 DUP1 3C87 8C DUP13 3C88 16 AND 3C89 82 DUP3 3C8A 84 DUP5 3C8B 01 ADD 3C8C 81 DUP2 3C8D 90 SWAP1 3C8E 52 MSTORE 3C8F 90 SWAP1 3C90 8B DUP12 3C91 16 AND 3C92 60 PUSH1 0x60 3C94 83 DUP4 3C95 01 ADD 3C96 52 MSTORE 3C97 60 PUSH1 0x80 3C99 82 DUP3 3C9A 01 ADD 3C9B 8A DUP11 3C9C 90 SWAP1 3C9D 52 MSTORE 3C9E 60 PUSH1 0xa0 3CA0 82 DUP3 3CA1 01 ADD 3CA2 89 DUP10 3CA3 90 SWAP1 3CA4 52 MSTORE 3CA5 60 PUSH1 0xc0 3CA7 82 DUP3 3CA8 01 ADD 3CA9 88 DUP9 3CAA 90 SWAP1 3CAB 52 MSTORE 3CAC 60 PUSH1 0xe0 3CAE 80 DUP1 3CAF 83 DUP4 3CB0 01 ADD 3CB1 88 DUP9 3CB2 90 SWAP1 3CB3 52 MSTORE 3CB4 83 DUP4 3CB5 51 MLOAD 3CB6 80 DUP1 3CB7 84 DUP5 3CB8 03 SUB 3CB9 90 SWAP1 3CBA 91 SWAP2 3CBB 01 ADD 3CBC 81 DUP2 3CBD 52 MSTORE 3CBE 61 PUSH2 0x0100 3CC1 90 SWAP1 3CC2 92 SWAP3 3CC3 01 ADD 3CC4 90 SWAP1 3CC5 92 SWAP3 3CC6 52 MSTORE 3CC7 61 PUSH2 0x0105 3CCA 54 SLOAD 3CCB 90 SWAP1 3CCC 91 SWAP2 3CCD 90 SWAP1 3CCE 61 PUSH2 0x3cda 3CD1 90 SWAP1 3CD2 86 DUP7 3CD3 86 DUP7 3CD4 86 DUP7 3CD5 86 DUP7 3CD6 61 PUSH2 0x46f6 3CD9 56 *JUMP // Stack delta = +8 // Outputs[17] // { // @3C7D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x808c10407a796f3ef2c7ea38c0638ea9d2b8a1c63e3ca9e1f56ce84ae59df73c // @3C8E memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @3C96 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3C9D memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-7] // @3CA4 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-6] // @3CAB memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-5] // @3CB3 memory[memory[0x40:0x60] + 0xe0:memory[0x40:0x60] + 0xe0 + 0x20] = stack[-4] // @3CBD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @3CC6 memory[0x40:0x60] = memory[0x40:0x60] + 0x0100 // @3CCC stack[0] = memory[0x40:0x60] // @3CCD stack[1] = stack[-9] & (0x01 << 0xa0) - 0x01 // @3CD1 stack[2] = 0x3cda // @3CD1 stack[3] = storage[0x0105] // @3CD2 stack[4] = stack[-3] // @3CD3 stack[5] = stack[-2] // @3CD4 stack[6] = stack[-1] // @3CD5 stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x46f6, returns to 0x3CDA label_3CDA: // Incoming return from call to 0x46F6 at 0x3CD9 // Inputs[2] // { // @3CE3 stack[-1] // @3CE4 stack[-2] // } 3CDA 5B JUMPDEST 3CDB 60 PUSH1 0x01 3CDD 60 PUSH1 0x01 3CDF 60 PUSH1 0xa0 3CE1 1B SHL 3CE2 03 SUB 3CE3 16 AND 3CE4 14 EQ 3CE5 61 PUSH2 0x3d1e 3CE8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3d1e, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_3CE9: // Incoming jump from 0x3CE8, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @3CEC memory[0x40:0x60] // @3D14 memory[0x40:0x60] // @3D1D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3CE9 60 PUSH1 0x40 3CEB 80 DUP1 3CEC 51 MLOAD 3CED 62 PUSH3 0x461bcd 3CF1 60 PUSH1 0xe5 3CF3 1B SHL 3CF4 81 DUP2 3CF5 52 MSTORE 3CF6 60 PUSH1 0x20 3CF8 60 PUSH1 0x04 3CFA 80 DUP1 3CFB 83 DUP4 3CFC 01 ADD 3CFD 91 SWAP2 3CFE 90 SWAP1 3CFF 91 SWAP2 3D00 52 MSTORE 3D01 60 PUSH1 0x24 3D03 82 DUP3 3D04 01 ADD 3D05 52 MSTORE 3D06 63 PUSH4 0x53493031 3D0B 60 PUSH1 0xe0 3D0D 1B SHL 3D0E 60 PUSH1 0x44 3D10 82 DUP3 3D11 01 ADD 3D12 52 MSTORE 3D13 90 SWAP1 3D14 51 MLOAD 3D15 90 SWAP1 3D16 81 DUP2 3D17 90 SWAP1 3D18 03 SUB 3D19 60 PUSH1 0x64 3D1B 01 ADD 3D1C 90 SWAP1 3D1D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3CF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3D00 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3D05 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3D12 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53493031 << 0xe0 // @3D1D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3D1E: // Incoming jump from 0x3CE8, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @3D22 stack[-10] // @3D23 stack[-5] // } 3D1E 5B JUMPDEST 3D1F 61 PUSH2 0x3d28 3D22 8A DUP11 3D23 86 DUP7 3D24 61 PUSH2 0x474d 3D27 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3D1F stack[0] = 0x3d28 // @3D22 stack[1] = stack[-10] // @3D23 stack[2] = stack[-5] // } // Block ends with call to 0x474d, returns to 0x3D28 label_3D28: // Incoming return from call to 0x474D at 0x3D27 // Inputs[3] // { // @3D2C stack[-10] // @3D2D stack[-9] // @3D2E stack[-8] // } 3D28 5B JUMPDEST 3D29 61 PUSH2 0x1a50 3D2C 8A DUP11 3D2D 8A DUP11 3D2E 8A DUP11 3D2F 61 PUSH2 0x4384 3D32 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3D29 stack[0] = 0x1a50 // @3D2C stack[1] = stack[-10] // @3D2D stack[2] = stack[-9] // @3D2E stack[3] = stack[-8] // } // Block ends with call to 0x4384, returns to 0x1A50 label_3D33: // Incoming jump from 0x1004 3D33 5B JUMPDEST 3D34 61 PUSH2 0x3d3b 3D37 61 PUSH2 0x4380 3D3A 56 *JUMP // Stack delta = +1 // Outputs[1] { @3D34 stack[0] = 0x3d3b } // Block ends with call to 0x4380, returns to 0x3D3B label_3D3B: // Incoming return from call to 0x4380 at 0x3D3A // Inputs[1] { @3D44 stack[-1] } 3D3B 5B JUMPDEST 3D3C 60 PUSH1 0x01 3D3E 60 PUSH1 0x01 3D40 60 PUSH1 0xa0 3D42 1B SHL 3D43 03 SUB 3D44 16 AND 3D45 61 PUSH2 0x3d4c 3D48 61 PUSH2 0x2daa 3D4B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @3D44 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @3D45 stack[0] = 0x3d4c // } // Block ends with call to 0x2daa, returns to 0x3D4C label_3D4C: // Incoming return from call to 0x2DAA at 0x3D4B // Inputs[2] // { // @3D55 stack[-1] // @3D56 stack[-2] // } 3D4C 5B JUMPDEST 3D4D 60 PUSH1 0x01 3D4F 60 PUSH1 0x01 3D51 60 PUSH1 0xa0 3D53 1B SHL 3D54 03 SUB 3D55 16 AND 3D56 14 EQ 3D57 80 DUP1 3D58 61 PUSH2 0x3d67 3D5B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @3D56 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x3d67, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_3D5C: // Incoming jump from 0x3D5B, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 3D5C 50 POP 3D5D 61 PUSH2 0x3d67 3D60 61 PUSH2 0x153d 3D63 61 PUSH2 0x4380 3D66 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @3D5D stack[-1] = 0x3d67 // @3D60 stack[0] = 0x153d // } // Block ends with call to 0x4380, returns to 0x153D label_3D67: // Incoming jump from 0x3D5B, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @3D6B stack[-1] } 3D67 5B JUMPDEST 3D68 61 PUSH2 0x3da1 3D6B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3da1, if stack[-1] label_3D6C: // Incoming jump from 0x3D6B, if not stack[-1] // Inputs[3] // { // @3D6F memory[0x40:0x60] // @3D97 memory[0x40:0x60] // @3DA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3D6C 60 PUSH1 0x40 3D6E 80 DUP1 3D6F 51 MLOAD 3D70 62 PUSH3 0x461bcd 3D74 60 PUSH1 0xe5 3D76 1B SHL 3D77 81 DUP2 3D78 52 MSTORE 3D79 60 PUSH1 0x20 3D7B 60 PUSH1 0x04 3D7D 80 DUP1 3D7E 83 DUP4 3D7F 01 ADD 3D80 91 SWAP2 3D81 90 SWAP1 3D82 91 SWAP2 3D83 52 MSTORE 3D84 60 PUSH1 0x24 3D86 82 DUP3 3D87 01 ADD 3D88 52 MSTORE 3D89 63 PUSH4 0x41443031 3D8E 60 PUSH1 0xe0 3D90 1B SHL 3D91 60 PUSH1 0x44 3D93 82 DUP3 3D94 01 ADD 3D95 52 MSTORE 3D96 90 SWAP1 3D97 51 MLOAD 3D98 90 SWAP1 3D99 81 DUP2 3D9A 90 SWAP1 3D9B 03 SUB 3D9C 60 PUSH1 0x64 3D9E 01 ADD 3D9F 90 SWAP1 3DA0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3D78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3D83 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3D88 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3D95 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x41443031 << 0xe0 // @3DA0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3DA1: // Incoming jump from 0x3D6B, if stack[-1] // Inputs[5] // { // @3DA5 storage[0x97] // @3DB8 stack[-1] // @3DC2 memory[0x40:0x60] // @3DE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @3DEA stack[-2] // } 3DA1 5B JUMPDEST 3DA2 60 PUSH1 0x97 3DA4 80 DUP1 3DA5 54 SLOAD 3DA6 60 PUSH1 0x01 3DA8 60 PUSH1 0x01 3DAA 60 PUSH1 0xa0 3DAC 1B SHL 3DAD 03 SUB 3DAE 19 NOT 3DAF 16 AND 3DB0 60 PUSH1 0x01 3DB2 60 PUSH1 0x01 3DB4 60 PUSH1 0xa0 3DB6 1B SHL 3DB7 03 SUB 3DB8 83 DUP4 3DB9 16 AND 3DBA 90 SWAP1 3DBB 81 DUP2 3DBC 17 OR 3DBD 90 SWAP1 3DBE 91 SWAP2 3DBF 55 SSTORE 3DC0 60 PUSH1 0x40 3DC2 51 MLOAD 3DC3 7F PUSH32 0x63e7655c5ec08f94bc8ad23d90d8b7b5b1eddd5bb793c6dbfc7e00ce8fcdac47 3DE4 90 SWAP1 3DE5 60 PUSH1 0x00 3DE7 90 SWAP1 3DE8 A2 LOG2 3DE9 50 POP 3DEA 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3DBF storage[0x97] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x97]) // @3DE8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x63e7655c5ec08f94bc8ad23d90d8b7b5b1eddd5bb793c6dbfc7e00ce8fcdac47, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_3DEB: // Incoming jump from 0x1063 // Inputs[1] { @3DEE storage[0x97] } 3DEB 5B JUMPDEST 3DEC 60 PUSH1 0x97 3DEE 54 SLOAD 3DEF 60 PUSH1 0x01 3DF1 60 PUSH1 0x01 3DF3 60 PUSH1 0xa0 3DF5 1B SHL 3DF6 03 SUB 3DF7 16 AND 3DF8 61 PUSH2 0x3e31 3DFB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3e31, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_3DFC: // Incoming jump from 0x3DFB, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @3DFF memory[0x40:0x60] // @3E27 memory[0x40:0x60] // @3E30 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3DFC 60 PUSH1 0x40 3DFE 80 DUP1 3DFF 51 MLOAD 3E00 62 PUSH3 0x461bcd 3E04 60 PUSH1 0xe5 3E06 1B SHL 3E07 81 DUP2 3E08 52 MSTORE 3E09 60 PUSH1 0x20 3E0B 60 PUSH1 0x04 3E0D 80 DUP1 3E0E 83 DUP4 3E0F 01 ADD 3E10 91 SWAP2 3E11 90 SWAP1 3E12 91 SWAP2 3E13 52 MSTORE 3E14 60 PUSH1 0x24 3E16 82 DUP3 3E17 01 ADD 3E18 52 MSTORE 3E19 63 PUSH4 0x50523031 3E1E 60 PUSH1 0xe0 3E20 1B SHL 3E21 60 PUSH1 0x44 3E23 82 DUP3 3E24 01 ADD 3E25 52 MSTORE 3E26 90 SWAP1 3E27 51 MLOAD 3E28 90 SWAP1 3E29 81 DUP2 3E2A 90 SWAP1 3E2B 03 SUB 3E2C 60 PUSH1 0x64 3E2E 01 ADD 3E2F 90 SWAP1 3E30 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3E08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3E13 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3E18 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3E25 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @3E30 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3E31: // Incoming jump from 0x3DFB, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[4] // { // @3E35 stack[-9] // @3E36 stack[-4] // @3E37 stack[-6] // @3E38 stack[-5] // } 3E31 5B JUMPDEST 3E32 61 PUSH2 0x3e3d 3E35 89 DUP10 3E36 85 DUP6 3E37 88 DUP9 3E38 88 DUP9 3E39 61 PUSH2 0x466c 3E3C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @3E32 stack[0] = 0x3e3d // @3E35 stack[1] = stack[-9] // @3E36 stack[2] = stack[-4] // @3E37 stack[3] = stack[-6] // @3E38 stack[4] = stack[-5] // } // Block ends with call to 0x466c, returns to 0x3E3D label_3E3D: // Incoming return from call to 0x466C at 0x3E3C // Inputs[12] // { // @3E41 memory[0x40:0x60] // @3E71 stack[-9] // @3E7A stack[-8] // @3E85 stack[-7] // @3E8C stack[-6] // @3E93 stack[-5] // @3E9B stack[-4] // @3E9F memory[0x40:0x60] // @3EB4 storage[0x0105] // @3EBC stack[-3] // @3EBD stack[-2] // @3EBE stack[-1] // } 3E3D 5B JUMPDEST 3E3E 60 PUSH1 0x40 3E40 80 DUP1 3E41 51 MLOAD 3E42 7F PUSH32 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267 3E63 60 PUSH1 0x20 3E65 82 DUP3 3E66 01 ADD 3E67 52 MSTORE 3E68 60 PUSH1 0x01 3E6A 60 PUSH1 0x01 3E6C 60 PUSH1 0xa0 3E6E 1B SHL 3E6F 03 SUB 3E70 80 DUP1 3E71 8C DUP13 3E72 16 AND 3E73 82 DUP3 3E74 84 DUP5 3E75 01 ADD 3E76 81 DUP2 3E77 90 SWAP1 3E78 52 MSTORE 3E79 90 SWAP1 3E7A 8B DUP12 3E7B 16 AND 3E7C 60 PUSH1 0x60 3E7E 83 DUP4 3E7F 01 ADD 3E80 52 MSTORE 3E81 60 PUSH1 0x80 3E83 82 DUP3 3E84 01 ADD 3E85 8A DUP11 3E86 90 SWAP1 3E87 52 MSTORE 3E88 60 PUSH1 0xa0 3E8A 82 DUP3 3E8B 01 ADD 3E8C 89 DUP10 3E8D 90 SWAP1 3E8E 52 MSTORE 3E8F 60 PUSH1 0xc0 3E91 82 DUP3 3E92 01 ADD 3E93 88 DUP9 3E94 90 SWAP1 3E95 52 MSTORE 3E96 60 PUSH1 0xe0 3E98 80 DUP1 3E99 83 DUP4 3E9A 01 ADD 3E9B 88 DUP9 3E9C 90 SWAP1 3E9D 52 MSTORE 3E9E 83 DUP4 3E9F 51 MLOAD 3EA0 80 DUP1 3EA1 84 DUP5 3EA2 03 SUB 3EA3 90 SWAP1 3EA4 91 SWAP2 3EA5 01 ADD 3EA6 81 DUP2 3EA7 52 MSTORE 3EA8 61 PUSH2 0x0100 3EAB 90 SWAP1 3EAC 92 SWAP3 3EAD 01 ADD 3EAE 90 SWAP1 3EAF 92 SWAP3 3EB0 52 MSTORE 3EB1 61 PUSH2 0x0105 3EB4 54 SLOAD 3EB5 90 SWAP1 3EB6 91 SWAP2 3EB7 90 SWAP1 3EB8 61 PUSH2 0x3ec4 3EBB 90 SWAP1 3EBC 86 DUP7 3EBD 86 DUP7 3EBE 86 DUP7 3EBF 86 DUP7 3EC0 61 PUSH2 0x46f6 3EC3 56 *JUMP // Stack delta = +8 // Outputs[17] // { // @3E67 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267 // @3E78 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @3E80 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3E87 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-7] // @3E8E memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-6] // @3E95 memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-5] // @3E9D memory[memory[0x40:0x60] + 0xe0:memory[0x40:0x60] + 0xe0 + 0x20] = stack[-4] // @3EA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @3EB0 memory[0x40:0x60] = memory[0x40:0x60] + 0x0100 // @3EB6 stack[0] = memory[0x40:0x60] // @3EB7 stack[1] = stack[-9] & (0x01 << 0xa0) - 0x01 // @3EBB stack[2] = 0x3ec4 // @3EBB stack[3] = storage[0x0105] // @3EBC stack[4] = stack[-3] // @3EBD stack[5] = stack[-2] // @3EBE stack[6] = stack[-1] // @3EBF stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x46f6, returns to 0x3EC4 label_3EC4: // Incoming return from call to 0x46F6 at 0x3EC3 // Inputs[2] // { // @3ECD stack[-1] // @3ECE stack[-2] // } 3EC4 5B JUMPDEST 3EC5 60 PUSH1 0x01 3EC7 60 PUSH1 0x01 3EC9 60 PUSH1 0xa0 3ECB 1B SHL 3ECC 03 SUB 3ECD 16 AND 3ECE 14 EQ 3ECF 61 PUSH2 0x3f08 3ED2 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3f08, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_3ED3: // Incoming jump from 0x3ED2, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @3ED6 memory[0x40:0x60] // @3EFE memory[0x40:0x60] // @3F07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3ED3 60 PUSH1 0x40 3ED5 80 DUP1 3ED6 51 MLOAD 3ED7 62 PUSH3 0x461bcd 3EDB 60 PUSH1 0xe5 3EDD 1B SHL 3EDE 81 DUP2 3EDF 52 MSTORE 3EE0 60 PUSH1 0x20 3EE2 60 PUSH1 0x04 3EE4 80 DUP1 3EE5 83 DUP4 3EE6 01 ADD 3EE7 91 SWAP2 3EE8 90 SWAP1 3EE9 91 SWAP2 3EEA 52 MSTORE 3EEB 60 PUSH1 0x24 3EED 82 DUP3 3EEE 01 ADD 3EEF 52 MSTORE 3EF0 63 PUSH4 0x53493031 3EF5 60 PUSH1 0xe0 3EF7 1B SHL 3EF8 60 PUSH1 0x44 3EFA 82 DUP3 3EFB 01 ADD 3EFC 52 MSTORE 3EFD 90 SWAP1 3EFE 51 MLOAD 3EFF 90 SWAP1 3F00 81 DUP2 3F01 90 SWAP1 3F02 03 SUB 3F03 60 PUSH1 0x64 3F05 01 ADD 3F06 90 SWAP1 3F07 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3EDF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3EEA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3EEF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3EFC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53493031 << 0xe0 // @3F07 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3F08: // Incoming jump from 0x3ED2, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @3F0C stack[-10] // @3F0D stack[-5] // } 3F08 5B JUMPDEST 3F09 61 PUSH2 0x3f12 3F0C 8A DUP11 3F0D 86 DUP7 3F0E 61 PUSH2 0x474d 3F11 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3F09 stack[0] = 0x3f12 // @3F0C stack[1] = stack[-10] // @3F0D stack[2] = stack[-5] // } // Block ends with call to 0x474d, returns to 0x3F12 label_3F12: // Incoming return from call to 0x474D at 0x3F11 // Inputs[3] // { // @3F16 stack[-10] // @3F17 stack[-9] // @3F18 stack[-8] // } 3F12 5B JUMPDEST 3F13 61 PUSH2 0x3f1d 3F16 8A DUP11 3F17 8A DUP11 3F18 8A DUP11 3F19 61 PUSH2 0x450e 3F1C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3F13 stack[0] = 0x3f1d // @3F16 stack[1] = stack[-10] // @3F17 stack[2] = stack[-9] // @3F18 stack[3] = stack[-8] // } // Block ends with call to 0x450e, returns to 0x3F1D label_3F1D: // Incoming return from call to 0x450E at 0x3F1C // Inputs[1] { @3F2B stack[-14] } 3F1D 5B JUMPDEST 3F1E 50 POP 3F1F 50 POP 3F20 50 POP 3F21 50 POP 3F22 50 POP 3F23 50 POP 3F24 50 POP 3F25 50 POP 3F26 50 POP 3F27 50 POP 3F28 50 POP 3F29 50 POP 3F2A 50 POP 3F2B 56 *JUMP // Stack delta = -14 // Block ends with unconditional jump to stack[-14] label_3F2C: // Incoming jump from 0x1099 // Inputs[1] { @3F2F storage[0x97] } 3F2C 5B JUMPDEST 3F2D 60 PUSH1 0x97 3F2F 54 SLOAD 3F30 60 PUSH1 0x00 3F32 90 SWAP1 3F33 81 DUP2 3F34 90 SWAP1 3F35 81 DUP2 3F36 90 SWAP1 3F37 60 PUSH1 0x01 3F39 60 PUSH1 0x01 3F3B 60 PUSH1 0xa0 3F3D 1B SHL 3F3E 03 SUB 3F3F 16 AND 3F40 61 PUSH2 0x3f79 3F43 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3F32 stack[0] = 0x00 // @3F34 stack[1] = 0x00 // @3F36 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3f79, if (0x01 << 0xa0) - 0x01 & storage[0x97] label_3F44: // Incoming jump from 0x3F43, if not (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[3] // { // @3F47 memory[0x40:0x60] // @3F6F memory[0x40:0x60] // @3F78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3F44 60 PUSH1 0x40 3F46 80 DUP1 3F47 51 MLOAD 3F48 62 PUSH3 0x461bcd 3F4C 60 PUSH1 0xe5 3F4E 1B SHL 3F4F 81 DUP2 3F50 52 MSTORE 3F51 60 PUSH1 0x20 3F53 60 PUSH1 0x04 3F55 80 DUP1 3F56 83 DUP4 3F57 01 ADD 3F58 91 SWAP2 3F59 90 SWAP1 3F5A 91 SWAP2 3F5B 52 MSTORE 3F5C 60 PUSH1 0x24 3F5E 82 DUP3 3F5F 01 ADD 3F60 52 MSTORE 3F61 63 PUSH4 0x50523031 3F66 60 PUSH1 0xe0 3F68 1B SHL 3F69 60 PUSH1 0x44 3F6B 82 DUP3 3F6C 01 ADD 3F6D 52 MSTORE 3F6E 90 SWAP1 3F6F 51 MLOAD 3F70 90 SWAP1 3F71 81 DUP2 3F72 90 SWAP1 3F73 03 SUB 3F74 60 PUSH1 0x64 3F76 01 ADD 3F77 90 SWAP1 3F78 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3F50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3F5B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3F60 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @3F6D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50523031 << 0xe0 // @3F78 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3F79: // Incoming jump from 0x3F43, if (0x01 << 0xa0) - 0x01 & storage[0x97] // Inputs[7] // { // @3F7C storage[0x97] // @3F80 memory[0x40:0x60] // @3F93 stack[-6] // @3F9B stack[-5] // @3FA7 stack[-4] // @3FAB memory[0x40:0x60] // @3FC9 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 3F79 5B JUMPDEST 3F7A 60 PUSH1 0x97 3F7C 54 SLOAD 3F7D 60 PUSH1 0x40 3F7F 80 DUP1 3F80 51 MLOAD 3F81 63 PUSH4 0x72331c73 3F86 60 PUSH1 0xe1 3F88 1B SHL 3F89 81 DUP2 3F8A 52 MSTORE 3F8B 60 PUSH1 0x01 3F8D 60 PUSH1 0x01 3F8F 60 PUSH1 0xa0 3F91 1B SHL 3F92 03 SUB 3F93 89 DUP10 3F94 81 DUP2 3F95 16 AND 3F96 60 PUSH1 0x04 3F98 83 DUP4 3F99 01 ADD 3F9A 52 MSTORE 3F9B 88 DUP9 3F9C 81 DUP2 3F9D 16 AND 3F9E 60 PUSH1 0x24 3FA0 83 DUP4 3FA1 01 ADD 3FA2 52 MSTORE 3FA3 60 PUSH1 0x44 3FA5 82 DUP3 3FA6 01 ADD 3FA7 88 DUP9 3FA8 90 SWAP1 3FA9 52 MSTORE 3FAA 91 SWAP2 3FAB 51 MLOAD 3FAC 91 SWAP2 3FAD 90 SWAP1 3FAE 92 SWAP3 3FAF 16 AND 3FB0 91 SWAP2 3FB1 63 PUSH4 0xe46638e6 3FB6 91 SWAP2 3FB7 60 PUSH1 0x64 3FB9 80 DUP1 3FBA 83 DUP4 3FBB 01 ADD 3FBC 92 SWAP3 3FBD 60 PUSH1 0x60 3FBF 92 SWAP3 3FC0 91 SWAP2 3FC1 90 SWAP1 3FC2 82 DUP3 3FC3 90 SWAP1 3FC4 03 SUB 3FC5 01 ADD 3FC6 81 DUP2 3FC7 86 DUP7 3FC8 80 DUP1 3FC9 3B EXTCODESIZE 3FCA 15 ISZERO 3FCB 80 DUP1 3FCC 15 ISZERO 3FCD 61 PUSH2 0x3fd5 3FD0 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @3F8A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x72331c73 << 0xe1 // @3F9A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @3FA2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @3FA9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-4] // @3FB0 stack[0] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @3FB6 stack[1] = 0xe46638e6 // @3FBC stack[2] = memory[0x40:0x60] + 0x64 // @3FBF stack[3] = 0x60 // @3FC0 stack[4] = memory[0x40:0x60] // @3FC5 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @3FC6 stack[6] = memory[0x40:0x60] // @3FC7 stack[7] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @3FCA stack[8] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x3fd5, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_3FD1: // Incoming jump from 0x3FD0, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @3FD4 memory[0x00:0x00] } 3FD1 60 PUSH1 0x00 3FD3 80 DUP1 3FD4 FD *REVERT // Stack delta = +0 // Outputs[1] { @3FD4 revert(memory[0x00:0x00]); } // Block terminates label_3FD5: // Incoming jump from 0x3FD0, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @3FD7 msg.gas // @3FD8 stack[-5] // @3FD8 stack[-4] // @3FD8 stack[-6] // @3FD8 stack[-3] // @3FD8 memory[stack[-3]:stack[-3] + stack[-4]] // @3FD8 stack[-2] // @3FD8 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 3FD5 5B JUMPDEST 3FD6 50 POP 3FD7 5A GAS 3FD8 FA STATICCALL 3FD9 15 ISZERO 3FDA 80 DUP1 3FDB 15 ISZERO 3FDC 61 PUSH2 0x3fe9 3FDF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3FD8 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3FD9 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3fe9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3FE0: // Incoming jump from 0x3FDF, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3FE0 returndata.length // @3FE4 returndata[0x00:0x00 + returndata.length] // @3FE5 returndata.length // @3FE8 memory[0x00:0x00 + returndata.length] // } 3FE0 3D RETURNDATASIZE 3FE1 60 PUSH1 0x00 3FE3 80 DUP1 3FE4 3E RETURNDATACOPY 3FE5 3D RETURNDATASIZE 3FE6 60 PUSH1 0x00 3FE8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3FE4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3FE8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3FE9: // Incoming jump from 0x3FDF, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3FF0 memory[0x40:0x60] // @3FF1 returndata.length // } 3FE9 5B JUMPDEST 3FEA 50 POP 3FEB 50 POP 3FEC 50 POP 3FED 50 POP 3FEE 60 PUSH1 0x40 3FF0 51 MLOAD 3FF1 3D RETURNDATASIZE 3FF2 60 PUSH1 0x60 3FF4 81 DUP2 3FF5 10 LT 3FF6 15 ISZERO 3FF7 61 PUSH2 0x3fff 3FFA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3FF0 stack[-4] = memory[0x40:0x60] // @3FF1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3fff, if !(returndata.length < 0x60) label_3FFB: // Incoming jump from 0x3FFA, if not !(returndata.length < 0x60) // Inputs[1] { @3FFE memory[0x00:0x00] } 3FFB 60 PUSH1 0x00 3FFD 80 DUP1 3FFE FD *REVERT // Stack delta = +0 // Outputs[1] { @3FFE revert(memory[0x00:0x00]); } // Block terminates label_3FFF: // Incoming jump from 0x3FFA, if !(returndata.length < 0x60) // Inputs[8] // { // @4001 stack[-2] // @4002 memory[stack[-2]:stack[-2] + 0x20] // @4007 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @400D memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @400F stack[-9] // @4011 stack[-8] // @4013 stack[-7] // @4015 stack[-6] // } 3FFF 5B JUMPDEST 4000 50 POP 4001 80 DUP1 4002 51 MLOAD 4003 60 PUSH1 0x20 4005 82 DUP3 4006 01 ADD 4007 51 MLOAD 4008 60 PUSH1 0x40 400A 90 SWAP1 400B 92 SWAP3 400C 01 ADD 400D 51 MLOAD 400E 90 SWAP1 400F 98 SWAP9 4010 91 SWAP2 4011 97 SWAP8 4012 50 POP 4013 95 SWAP6 4014 50 POP 4015 93 SWAP4 4016 50 POP 4017 50 POP 4018 50 POP 4019 50 POP 401A 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @400F stack[-9] = memory[stack[-2]:stack[-2] + 0x20] // @4011 stack[-8] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @4013 stack[-7] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-9] label_401B: // Incoming jump from 0x10E5 401B 5B JUMPDEST 401C 61 PUSH2 0x402b 401F 61 PUSH2 0x4026 4022 61 PUSH2 0x4380 4025 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @401C stack[0] = 0x402b // @401F stack[1] = 0x4026 // } // Block ends with call to 0x4380, returns to 0x4026 label_4026: // Incoming return from call to 0x4380 at 0x4025 4026 5B JUMPDEST 4027 61 PUSH2 0x4368 402A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x4368 402B 5B JUMPDEST 402C 61 PUSH2 0x4065 402F 57 *JUMPI 4030 60 PUSH1 0x40 4032 80 DUP1 4033 51 MLOAD 4034 62 PUSH3 0x461bcd 4038 60 PUSH1 0xe5 403A 1B SHL 403B 81 DUP2 403C 52 MSTORE 403D 60 PUSH1 0x20 403F 60 PUSH1 0x04 4041 80 DUP1 4042 83 DUP4 4043 01 ADD 4044 91 SWAP2 4045 90 SWAP1 4046 91 SWAP2 4047 52 MSTORE 4048 60 PUSH1 0x24 404A 82 DUP3 404B 01 ADD 404C 52 MSTORE 404D 63 PUSH4 0x29a29819 4052 60 PUSH1 0xe1 4054 1B SHL 4055 60 PUSH1 0x44 4057 82 DUP3 4058 01 ADD 4059 52 MSTORE 405A 90 SWAP1 405B 51 MLOAD 405C 90 SWAP1 405D 81 DUP2 405E 90 SWAP1 405F 03 SUB 4060 60 PUSH1 0x64 4062 01 ADD 4063 90 SWAP1 4064 FD *REVERT 4065 5B JUMPDEST 4066 60 PUSH1 0x97 4068 54 SLOAD 4069 60 PUSH1 0x01 406B 60 PUSH1 0x01 406D 60 PUSH1 0xa0 406F 1B SHL 4070 03 SUB 4071 16 AND 4072 61 PUSH2 0x40ab 4075 57 *JUMPI 4076 60 PUSH1 0x40 4078 80 DUP1 4079 51 MLOAD 407A 62 PUSH3 0x461bcd 407E 60 PUSH1 0xe5 4080 1B SHL 4081 81 DUP2 4082 52 MSTORE 4083 60 PUSH1 0x20 4085 60 PUSH1 0x04 4087 80 DUP1 4088 83 DUP4 4089 01 ADD 408A 91 SWAP2 408B 90 SWAP1 408C 91 SWAP2 408D 52 MSTORE 408E 60 PUSH1 0x24 4090 82 DUP3 4091 01 ADD 4092 52 MSTORE 4093 63 PUSH4 0x50523031 4098 60 PUSH1 0xe0 409A 1B SHL 409B 60 PUSH1 0x44 409D 82 DUP3 409E 01 ADD 409F 52 MSTORE 40A0 90 SWAP1 40A1 51 MLOAD 40A2 90 SWAP1 40A3 81 DUP2 40A4 90 SWAP1 40A5 03 SUB 40A6 60 PUSH1 0x64 40A8 01 ADD 40A9 90 SWAP1 40AA FD *REVERT 40AB 5B JUMPDEST 40AC 60 PUSH1 0x97 40AE 54 SLOAD 40AF 60 PUSH1 0x01 40B1 60 PUSH1 0x01 40B3 60 PUSH1 0xa0 40B5 1B SHL 40B6 03 SUB 40B7 16 AND 40B8 63 PUSH4 0xb2a02ff1 40BD 61 PUSH2 0x40c4 40C0 61 PUSH2 0x4380 40C3 56 *JUMP 40C4 5B JUMPDEST 40C5 60 PUSH1 0x40 40C7 80 DUP1 40C8 51 MLOAD 40C9 60 PUSH1 0x01 40CB 60 PUSH1 0x01 40CD 60 PUSH1 0xe0 40CF 1B SHL 40D0 03 SUB 40D1 19 NOT 40D2 60 PUSH1 0xe0 40D4 85 DUP6 40D5 90 SWAP1 40D6 1B SHL 40D7 16 AND 40D8 81 DUP2 40D9 52 MSTORE 40DA 60 PUSH1 0x01 40DC 60 PUSH1 0x01 40DE 60 PUSH1 0xa0 40E0 1B SHL 40E1 03 SUB 40E2 92 SWAP3 40E3 83 DUP4 40E4 16 AND 40E5 60 PUSH1 0x04 40E7 82 DUP3 40E8 01 ADD 40E9 52 MSTORE 40EA 91 SWAP2 40EB 86 DUP7 40EC 16 AND 40ED 60 PUSH1 0x24 40EF 83 DUP4 40F0 01 ADD 40F1 52 MSTORE 40F2 60 PUSH1 0x44 40F4 82 DUP3 40F5 01 ADD 40F6 85 DUP6 40F7 90 SWAP1 40F8 52 MSTORE 40F9 51 MLOAD 40FA 60 PUSH1 0x64 40FC 80 DUP1 40FD 83 DUP4 40FE 01 ADD 40FF 92 SWAP3 4100 60 PUSH1 0x00 4102 92 SWAP3 4103 91 SWAP2 4104 90 SWAP1 4105 82 DUP3 4106 90 SWAP1 4107 03 SUB 4108 01 ADD 4109 81 DUP2 410A 83 DUP4 410B 87 DUP8 410C 80 DUP1 410D 3B EXTCODESIZE 410E 15 ISZERO 410F 80 DUP1 4110 15 ISZERO 4111 61 PUSH2 0x4119 4114 57 *JUMPI 4115 60 PUSH1 0x00 4117 80 DUP1 4118 FD *REVERT 4119 5B JUMPDEST 411A 50 POP 411B 5A GAS 411C F1 CALL 411D 15 ISZERO 411E 80 DUP1 411F 15 ISZERO 4120 61 PUSH2 0x412d 4123 57 *JUMPI 4124 3D RETURNDATASIZE 4125 60 PUSH1 0x00 4127 80 DUP1 4128 3E RETURNDATACOPY 4129 3D RETURNDATASIZE 412A 60 PUSH1 0x00 412C FD *REVERT 412D 5B JUMPDEST 412E 50 POP 412F 50 POP 4130 60 PUSH1 0x40 4132 80 DUP1 4133 51 MLOAD 4134 60 PUSH1 0x01 4136 60 PUSH1 0x01 4138 60 PUSH1 0xa0 413A 1B SHL 413B 03 SUB 413C 86 DUP7 413D 16 AND 413E 81 DUP2 413F 52 MSTORE 4140 60 PUSH1 0x20 4142 81 DUP2 4143 01 ADD 4144 85 DUP6 4145 90 SWAP1 4146 52 MSTORE 4147 81 DUP2 4148 51 MLOAD 4149 7F PUSH32 0x4051ba94e08bb094159fc38391422b4b8ccfd2b1f8919c0eb37bb042d4b9cd8e 416A 94 SWAP5 416B 50 POP 416C 90 SWAP1 416D 81 DUP2 416E 90 SWAP1 416F 03 SUB 4170 90 SWAP1 4171 91 SWAP2 4172 01 ADD 4173 91 SWAP2 4174 50 POP 4175 A1 LOG1 4176 61 PUSH2 0x417d 4179 61 PUSH2 0x4380 417C 56 *JUMP 417D 5B JUMPDEST 417E 60 PUSH1 0x01 4180 60 PUSH1 0x01 4182 60 PUSH1 0xa0 4184 1B SHL 4185 03 SUB 4186 16 AND 4187 82 DUP3 4188 60 PUSH1 0x01 418A 60 PUSH1 0x01 418C 60 PUSH1 0xa0 418E 1B SHL 418F 03 SUB 4190 16 AND 4191 60 PUSH1 0x00 4193 80 DUP1 4194 51 MLOAD 4195 60 PUSH1 0x20 4197 61 PUSH2 0x5729 419A 83 DUP4 419B 39 CODECOPY 419C 81 DUP2 419D 51 MLOAD 419E 91 SWAP2 419F 52 MSTORE 41A0 83 DUP4 41A1 60 PUSH1 0x40 41A3 51 MLOAD 41A4 80 DUP1 41A5 82 DUP3 41A6 81 DUP2 41A7 52 MSTORE 41A8 60 PUSH1 0x20 41AA 01 ADD 41AB 91 SWAP2 41AC 50 POP 41AD 50 POP 41AE 60 PUSH1 0x40 41B0 51 MLOAD 41B1 80 DUP1 41B2 91 SWAP2 41B3 03 SUB 41B4 90 SWAP1 41B5 A3 LOG3 41B6 50 POP 41B7 50 POP 41B8 56 *JUMP label_41B9: // Incoming jump from 0x110B 41B9 5B JUMPDEST 41BA 61 PUSH2 0x41c1 41BD 61 PUSH2 0x4380 41C0 56 *JUMP // Stack delta = +1 // Outputs[1] { @41BA stack[0] = 0x41c1 } // Block ends with call to 0x4380, returns to 0x41C1 label_41C1: // Incoming return from call to 0x4380 at 0x41C0 // Inputs[2] // { // @41C4 storage[0x65] // @41D0 stack[-1] // } 41C1 5B JUMPDEST 41C2 60 PUSH1 0x65 41C4 54 SLOAD 41C5 60 PUSH1 0x01 41C7 60 PUSH1 0x01 41C9 60 PUSH1 0xa0 41CB 1B SHL 41CC 03 SUB 41CD 90 SWAP1 41CE 81 DUP2 41CF 16 AND 41D0 91 SWAP2 41D1 16 AND 41D2 14 EQ 41D3 61 PUSH2 0x4211 41D6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4211, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] label_41D7: // Incoming jump from 0x41D6, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[5] // { // @41DA memory[0x40:0x60] // @41F5 memory[0x00:0x20] // @41FE memory[0x00:0x20] // @4207 memory[0x40:0x60] // @4210 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 41D7 60 PUSH1 0x40 41D9 80 DUP1 41DA 51 MLOAD 41DB 62 PUSH3 0x461bcd 41DF 60 PUSH1 0xe5 41E1 1B SHL 41E2 81 DUP2 41E3 52 MSTORE 41E4 60 PUSH1 0x20 41E6 60 PUSH1 0x04 41E8 82 DUP3 41E9 01 ADD 41EA 81 DUP2 41EB 90 SWAP1 41EC 52 MSTORE 41ED 60 PUSH1 0x24 41EF 82 DUP3 41F0 01 ADD 41F1 52 MSTORE 41F2 60 PUSH1 0x00 41F4 80 DUP1 41F5 51 MLOAD 41F6 60 PUSH1 0x20 41F8 61 PUSH2 0x56b9 41FB 83 DUP4 41FC 39 CODECOPY 41FD 81 DUP2 41FE 51 MLOAD 41FF 91 SWAP2 4200 52 MSTORE 4201 60 PUSH1 0x44 4203 82 DUP3 4204 01 ADD 4205 52 MSTORE 4206 90 SWAP1 4207 51 MLOAD 4208 90 SWAP1 4209 81 DUP2 420A 90 SWAP1 420B 03 SUB 420C 60 PUSH1 0x64 420E 01 ADD 420F 90 SWAP1 4210 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @41E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @41EC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @41F1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @41FC memory[0x00:0x20] = code[0x56b9:0x56d9] // @4200 memory[0x00:0x20] = memory[0x00:0x20] // @4205 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @4210 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4211: // Incoming jump from 0x41D6, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x65] // Inputs[1] { @421A stack[-1] } 4211 5B JUMPDEST 4212 60 PUSH1 0x01 4214 60 PUSH1 0x01 4216 60 PUSH1 0xa0 4218 1B SHL 4219 03 SUB 421A 81 DUP2 421B 16 AND 421C 61 PUSH2 0x4256 421F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4256, if stack[-1] & (0x01 << 0xa0) - 0x01 label_4220: // Incoming jump from 0x421F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @4222 memory[0x40:0x60] // @4250 memory[0x40:0x60] // @4255 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 4220 60 PUSH1 0x40 4222 51 MLOAD 4223 62 PUSH3 0x461bcd 4227 60 PUSH1 0xe5 4229 1B SHL 422A 81 DUP2 422B 52 MSTORE 422C 60 PUSH1 0x04 422E 01 ADD 422F 80 DUP1 4230 80 DUP1 4231 60 PUSH1 0x20 4233 01 ADD 4234 82 DUP3 4235 81 DUP2 4236 03 SUB 4237 82 DUP3 4238 52 MSTORE 4239 60 PUSH1 0x26 423B 81 DUP2 423C 52 MSTORE 423D 60 PUSH1 0x20 423F 01 ADD 4240 80 DUP1 4241 61 PUSH2 0x5651 4244 60 PUSH1 0x26 4246 91 SWAP2 4247 39 CODECOPY 4248 60 PUSH1 0x40 424A 01 ADD 424B 91 SWAP2 424C 50 POP 424D 50 POP 424E 60 PUSH1 0x40 4250 51 MLOAD 4251 80 DUP1 4252 91 SWAP2 4253 03 SUB 4254 90 SWAP1 4255 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @422B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4238 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @423C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @4247 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x5651:0x5677] // @4255 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_4256: // Incoming jump from 0x421F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @4259 storage[0x65] // @425C memory[0x40:0x60] // @4266 stack[-1] // @4290 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @4294 storage[0x65] // @42B1 stack[-2] // } 4256 5B JUMPDEST 4257 60 PUSH1 0x65 4259 54 SLOAD 425A 60 PUSH1 0x40 425C 51 MLOAD 425D 60 PUSH1 0x01 425F 60 PUSH1 0x01 4261 60 PUSH1 0xa0 4263 1B SHL 4264 03 SUB 4265 80 DUP1 4266 84 DUP5 4267 16 AND 4268 92 SWAP3 4269 16 AND 426A 90 SWAP1 426B 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 428C 90 SWAP1 428D 60 PUSH1 0x00 428F 90 SWAP1 4290 A3 LOG3 4291 60 PUSH1 0x65 4293 80 DUP1 4294 54 SLOAD 4295 60 PUSH1 0x01 4297 60 PUSH1 0x01 4299 60 PUSH1 0xa0 429B 1B SHL 429C 03 SUB 429D 19 NOT 429E 16 AND 429F 60 PUSH1 0x01 42A1 60 PUSH1 0x01 42A3 60 PUSH1 0xa0 42A5 1B SHL 42A6 03 SUB 42A7 92 SWAP3 42A8 90 SWAP1 42A9 92 SWAP3 42AA 16 AND 42AB 91 SWAP2 42AC 90 SWAP1 42AD 91 SWAP2 42AE 17 OR 42AF 90 SWAP1 42B0 55 SSTORE 42B1 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @4290 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x65] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // @42B0 storage[0x65] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x65]) // } // Block ends with unconditional jump to stack[-2] label_42B2: // Incoming jump from 0x12DA // Inputs[1] { @42B5 storage[0x00] } 42B2 5B JUMPDEST 42B3 60 PUSH1 0x00 42B5 54 SLOAD 42B6 61 PUSH2 0x0100 42B9 90 SWAP1 42BA 04 DIV 42BB 60 PUSH1 0xff 42BD 16 AND 42BE 80 DUP1 42BF 61 PUSH2 0x42cb 42C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @42BD stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x42cb, if 0xff & storage[0x00] / 0x0100 label_42C3: // Incoming jump from 0x42C2, if not 0xff & storage[0x00] / 0x0100 42C3 50 POP 42C4 61 PUSH2 0x42cb 42C7 61 PUSH2 0x48ef 42CA 56 *JUMP // Stack delta = +0 // Outputs[1] { @42C4 stack[-1] = 0x42cb } // Block ends with call to 0x48ef, returns to 0x42CB label_42CB: // Incoming jump from 0x42C2, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x48EF at 0x42CA // Inputs[1] { @42CC stack[-1] } 42CB 5B JUMPDEST 42CC 80 DUP1 42CD 61 PUSH2 0x42d9 42D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x42d9, if stack[-1] label_42D1: // Incoming jump from 0x42D0, if not stack[-1] // Inputs[1] { @42D4 storage[0x00] } 42D1 50 POP 42D2 60 PUSH1 0x00 42D4 54 SLOAD 42D5 60 PUSH1 0xff 42D7 16 AND 42D8 15 ISZERO 42D9 5B JUMPDEST 42DA 61 PUSH2 0x4314 42DD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4314, if !(0xff & storage[0x00]) label_42DE: // Incoming jump from 0x42DD, if not !(0xff & storage[0x00]) // Incoming jump from 0x42DD, if not stack[-1] // Inputs[3] // { // @42E0 memory[0x40:0x60] // @430E memory[0x40:0x60] // @4313 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 42DE 60 PUSH1 0x40 42E0 51 MLOAD 42E1 62 PUSH3 0x461bcd 42E5 60 PUSH1 0xe5 42E7 1B SHL 42E8 81 DUP2 42E9 52 MSTORE 42EA 60 PUSH1 0x04 42EC 01 ADD 42ED 80 DUP1 42EE 80 DUP1 42EF 60 PUSH1 0x20 42F1 01 ADD 42F2 82 DUP3 42F3 81 DUP2 42F4 03 SUB 42F5 82 DUP3 42F6 52 MSTORE 42F7 60 PUSH1 0x2e 42F9 81 DUP2 42FA 52 MSTORE 42FB 60 PUSH1 0x20 42FD 01 ADD 42FE 80 DUP1 42FF 61 PUSH2 0x56fb 4302 60 PUSH1 0x2e 4304 91 SWAP2 4305 39 CODECOPY 4306 60 PUSH1 0x40 4308 01 ADD 4309 91 SWAP2 430A 50 POP 430B 50 POP 430C 60 PUSH1 0x40 430E 51 MLOAD 430F 80 DUP1 4310 91 SWAP2 4311 03 SUB 4312 90 SWAP1 4313 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @42E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @42F6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @42FA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @4305 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x56fb:0x5729] // @4313 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_4314: // Incoming jump from 0x42DD, if !(0xff & storage[0x00]) // Incoming jump from 0x42DD, if stack[-1] // Inputs[1] { @4317 storage[0x00] } 4314 5B JUMPDEST 4315 60 PUSH1 0x00 4317 54 SLOAD 4318 61 PUSH2 0x0100 431B 90 SWAP1 431C 04 DIV 431D 60 PUSH1 0xff 431F 16 AND 4320 15 ISZERO 4321 80 DUP1 4322 15 ISZERO 4323 61 PUSH2 0x433f 4326 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4320 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x433f, if !!(0xff & storage[0x00] / 0x0100) label_4327: // Incoming jump from 0x4326, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[7] // { // @432A storage[0x00] // @4343 stack[-7] // @4344 stack[-6] // @4345 stack[-5] // @4346 stack[-4] // @4347 stack[-3] // @4348 stack[-2] // } 4327 60 PUSH1 0x00 4329 80 DUP1 432A 54 SLOAD 432B 60 PUSH1 0xff 432D 19 NOT 432E 61 PUSH2 0xff00 4331 19 NOT 4332 90 SWAP1 4333 91 SWAP2 4334 16 AND 4335 61 PUSH2 0x0100 4338 17 OR 4339 16 AND 433A 60 PUSH1 0x01 433C 17 OR 433D 90 SWAP1 433E 55 SSTORE 433F 5B JUMPDEST 4340 61 PUSH2 0x434d 4343 87 DUP8 4344 87 DUP8 4345 87 DUP8 4346 87 DUP8 4347 87 DUP8 4348 87 DUP8 4349 61 PUSH2 0x4d46 434C 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @433E storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @4340 stack[0] = 0x434d // @4343 stack[1] = stack[-7] // @4344 stack[2] = stack[-6] // @4345 stack[3] = stack[-5] // @4346 stack[4] = stack[-4] // @4347 stack[5] = stack[-3] // @4348 stack[6] = stack[-2] // } // Block ends with unconditional jump to 0x4d46 434D 5B JUMPDEST 434E 80 DUP1 434F 15 ISZERO 4350 61 PUSH2 0x435f 4353 57 *JUMPI 4354 60 PUSH1 0x00 4356 80 DUP1 4357 54 SLOAD 4358 61 PUSH2 0xff00 435B 19 NOT 435C 16 AND 435D 90 SWAP1 435E 55 SSTORE 435F 5B JUMPDEST 4360 50 POP 4361 50 POP 4362 50 POP 4363 50 POP 4364 50 POP 4365 50 POP 4366 50 POP 4367 56 *JUMP label_4368: // Incoming jump from 0x402A // Incoming jump from 0x1300 // Inputs[1] { @4370 stack[-1] } 4368 5B JUMPDEST 4369 60 PUSH1 0x00 436B 61 PUSH2 0x14f0 436E 60 PUSH1 0xcf 4370 83 DUP4 4371 63 PUSH4 0xffffffff 4376 61 PUSH2 0x4440 4379 16 AND 437A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4369 stack[0] = 0x00 // @436B stack[1] = 0x14f0 // @436E stack[2] = 0xcf // @4370 stack[3] = stack[-1] // } // Block ends with call to 0x4440 & 0xffffffff, returns to 0x14F0 label_437B: // Incoming call from 0x1308, returns to 0x0543 // Inputs[1] { @437E stack[-1] } 437B 5B JUMPDEST 437C 60 PUSH1 0x02 437E 81 DUP2 437F 56 *JUMP // Stack delta = +1 // Outputs[1] { @437C stack[0] = 0x02 } // Block ends with unconditional jump to stack[-1] label_4380: // Incoming call from 0x2E7B, returns to 0x2E7C // Incoming call from 0x16A2, returns to 0x16A3 // Incoming call from 0x1DE2, returns to 0x153D // Incoming call from 0x1DB6, returns to 0x1DB7 // Incoming call from 0x2C25, returns to 0x2C26 // Incoming call from 0x4025, returns to 0x4026 // Incoming call from 0x2519, returns to 0x251A // Incoming call from 0x1ABE, returns to 0x1ABF // Incoming call from 0x2EA7, returns to 0x153D // Incoming call from 0x14E4, returns to 0x14E5 // Incoming call from 0x338C, returns to 0x338D // Incoming call from 0x32F7, returns to 0x32F8 // Incoming call from 0x37A2, returns to 0x37A3 // Incoming call from 0x3A71, returns to 0x3A72 // Incoming call from 0x35C9, returns to 0x35CA // Incoming call from 0x2C51, returns to 0x153D // Incoming call from 0x1FF4, returns to 0x1FF5 // Incoming call from 0x252C, returns to 0x252D // Incoming call from 0x2B71, returns to 0x153D // Incoming call from 0x3710, returns to 0x3711 // Incoming call from 0x153C, returns to 0x153D // Incoming call from 0x541D, returns to 0x541E // Incoming call from 0x32B4, returns to 0x153D // Incoming call from 0x2020, returns to 0x153D // Incoming call from 0x2279, returns to 0x153D // Incoming call from 0x1BB8, returns to 0x1BB9 // Incoming call from 0x189B, returns to 0x153D // Incoming call from 0x16F0, returns to 0x16F1 // Incoming call from 0x3D3A, returns to 0x3D3B // Incoming call from 0x2305, returns to 0x2306 // Incoming call from 0x1510, returns to 0x1511 // Incoming call from 0x171C, returns to 0x153D // Incoming call from 0x1E6F, returns to 0x1E70 // Incoming call from 0x3288, returns to 0x3289 // Incoming call from 0x3D66, returns to 0x153D // Incoming call from 0x541D, returns to 0x541E // Incoming call from 0x2331, returns to 0x153D // Incoming call from 0x224D, returns to 0x224E // Incoming call from 0x325B, returns to 0x325C // Incoming call from 0x2F34, returns to 0x1E70 // Incoming call from 0x26B8, returns to 0x26B9 // Incoming call from 0x41C0, returns to 0x41C1 // Incoming call from 0x2B45, returns to 0x2B46 // Incoming call from 0x3842, returns to 0x3843 // Incoming call from 0x186F, returns to 0x1870 // Inputs[2] // { // @4381 msg.sender // @4382 stack[-1] // } 4380 5B JUMPDEST 4381 33 CALLER 4382 90 SWAP1 4383 56 *JUMP // Stack delta = +0 // Outputs[1] { @4382 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_4384: // Incoming jump from 0x14EB // Incoming call from 0x3D32, returns to 0x1A50 // Incoming call from 0x3A16, returns to 0x3A17 // Inputs[7] // { // @4387 storage[0x97] // @438B memory[0x40:0x60] // @439E stack[-3] // @43A6 stack[-2] // @43B2 stack[-1] // @43B6 memory[0x40:0x60] // @43D5 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 4384 5B JUMPDEST 4385 60 PUSH1 0x97 4387 54 SLOAD 4388 60 PUSH1 0x40 438A 80 DUP1 438B 51 MLOAD 438C 63 PUSH4 0xe1f21c67 4391 60 PUSH1 0xe0 4393 1B SHL 4394 81 DUP2 4395 52 MSTORE 4396 60 PUSH1 0x01 4398 60 PUSH1 0x01 439A 60 PUSH1 0xa0 439C 1B SHL 439D 03 SUB 439E 86 DUP7 439F 81 DUP2 43A0 16 AND 43A1 60 PUSH1 0x04 43A3 83 DUP4 43A4 01 ADD 43A5 52 MSTORE 43A6 85 DUP6 43A7 81 DUP2 43A8 16 AND 43A9 60 PUSH1 0x24 43AB 83 DUP4 43AC 01 ADD 43AD 52 MSTORE 43AE 60 PUSH1 0x44 43B0 82 DUP3 43B1 01 ADD 43B2 85 DUP6 43B3 90 SWAP1 43B4 52 MSTORE 43B5 91 SWAP2 43B6 51 MLOAD 43B7 91 SWAP2 43B8 90 SWAP1 43B9 92 SWAP3 43BA 16 AND 43BB 91 SWAP2 43BC 63 PUSH4 0xe1f21c67 43C1 91 SWAP2 43C2 60 PUSH1 0x64 43C4 80 DUP1 43C5 83 DUP4 43C6 01 ADD 43C7 92 SWAP3 43C8 60 PUSH1 0x00 43CA 92 SWAP3 43CB 91 SWAP2 43CC 90 SWAP1 43CD 82 DUP3 43CE 90 SWAP1 43CF 03 SUB 43D0 01 ADD 43D1 81 DUP2 43D2 83 DUP4 43D3 87 DUP8 43D4 80 DUP1 43D5 3B EXTCODESIZE 43D6 15 ISZERO 43D7 80 DUP1 43D8 15 ISZERO 43D9 61 PUSH2 0x43e1 43DC 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @4395 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe1f21c67 << 0xe0 // @43A5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @43AD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @43B4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @43BB stack[0] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @43C1 stack[1] = 0xe1f21c67 // @43C7 stack[2] = memory[0x40:0x60] + 0x64 // @43CA stack[3] = 0x00 // @43CB stack[4] = memory[0x40:0x60] // @43D0 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @43D1 stack[6] = memory[0x40:0x60] // @43D2 stack[7] = 0x00 // @43D3 stack[8] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @43D6 stack[9] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x43e1, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_43DD: // Incoming jump from 0x43DC, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @43E0 memory[0x00:0x00] } 43DD 60 PUSH1 0x00 43DF 80 DUP1 43E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @43E0 revert(memory[0x00:0x00]); } // Block terminates label_43E1: // Incoming jump from 0x43DC, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @43E3 msg.gas // @43E4 memory[stack[-4]:stack[-4] + stack[-5]] // @43E4 stack[-4] // @43E4 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @43E4 stack[-2] // @43E4 stack[-7] // @43E4 stack[-3] // @43E4 stack[-6] // @43E4 stack[-5] // } 43E1 5B JUMPDEST 43E2 50 POP 43E3 5A GAS 43E4 F1 CALL 43E5 15 ISZERO 43E6 80 DUP1 43E7 15 ISZERO 43E8 61 PUSH2 0x43f5 43EB 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @43E4 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @43E5 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 0x43f5, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_43EC: // Incoming jump from 0x43EB, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @43EC returndata.length // @43F0 returndata[0x00:0x00 + returndata.length] // @43F1 returndata.length // @43F4 memory[0x00:0x00 + returndata.length] // } 43EC 3D RETURNDATASIZE 43ED 60 PUSH1 0x00 43EF 80 DUP1 43F0 3E RETURNDATACOPY 43F1 3D RETURNDATASIZE 43F2 60 PUSH1 0x00 43F4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @43F0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @43F4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_43F5: // Incoming jump from 0x43EB, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[9] // { // @43FB memory[0x40:0x60] // @43FC stack[-5] // @4400 memory[0x40:0x60] // @440A stack[-6] // @440C stack[-4] // @440E stack[-7] // @4410 stack[-3] // @443B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @443F stack[-8] // } 43F5 5B JUMPDEST 43F6 50 POP 43F7 50 POP 43F8 60 PUSH1 0x40 43FA 80 DUP1 43FB 51 MLOAD 43FC 84 DUP5 43FD 81 DUP2 43FE 52 MSTORE 43FF 90 SWAP1 4400 51 MLOAD 4401 60 PUSH1 0x01 4403 60 PUSH1 0x01 4405 60 PUSH1 0xa0 4407 1B SHL 4408 03 SUB 4409 80 DUP1 440A 87 DUP8 440B 16 AND 440C 94 SWAP5 440D 50 POP 440E 87 DUP8 440F 16 AND 4410 92 SWAP3 4411 50 POP 4412 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 4433 91 SWAP2 4434 81 DUP2 4435 90 SWAP1 4436 03 SUB 4437 60 PUSH1 0x20 4439 01 ADD 443A 90 SWAP1 443B A3 LOG3 443C 50 POP 443D 50 POP 443E 50 POP 443F 56 *JUMP // Stack delta = -8 // Outputs[2] // { // @43FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @443B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-8] label_4440: // Incoming call from 0x437A, returns to 0x14F0 // Incoming call from 0x44B0, returns to 0x44B1 // Incoming call from 0x3AAF, returns to 0x14F0 // Incoming call from 0x1508, returns to 0x14F0 // Incoming call from 0x45F4, returns to 0x45F5 // Incoming call from 0x20E2, returns to 0x14F0 // Inputs[1] { @444B stack[-1] } 4440 5B JUMPDEST 4441 60 PUSH1 0x00 4443 60 PUSH1 0x01 4445 60 PUSH1 0x01 4447 60 PUSH1 0xa0 4449 1B SHL 444A 03 SUB 444B 82 DUP3 444C 16 AND 444D 61 PUSH2 0x4487 4450 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4441 stack[0] = 0x00 } // Block ends with conditional jump to 0x4487, if stack[-1] & (0x01 << 0xa0) - 0x01 label_4451: // Incoming jump from 0x4450, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @4453 memory[0x40:0x60] // @4481 memory[0x40:0x60] // @4486 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 4451 60 PUSH1 0x40 4453 51 MLOAD 4454 62 PUSH3 0x461bcd 4458 60 PUSH1 0xe5 445A 1B SHL 445B 81 DUP2 445C 52 MSTORE 445D 60 PUSH1 0x04 445F 01 ADD 4460 80 DUP1 4461 80 DUP1 4462 60 PUSH1 0x20 4464 01 ADD 4465 82 DUP3 4466 81 DUP2 4467 03 SUB 4468 82 DUP3 4469 52 MSTORE 446A 60 PUSH1 0x22 446C 81 DUP2 446D 52 MSTORE 446E 60 PUSH1 0x20 4470 01 ADD 4471 80 DUP1 4472 61 PUSH2 0x56d9 4475 60 PUSH1 0x22 4477 91 SWAP2 4478 39 CODECOPY 4479 60 PUSH1 0x40 447B 01 ADD 447C 91 SWAP2 447D 50 POP 447E 50 POP 447F 60 PUSH1 0x40 4481 51 MLOAD 4482 80 DUP1 4483 91 SWAP2 4484 03 SUB 4485 90 SWAP1 4486 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @445C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4469 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @446D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @4478 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x56d9:0x56fb] // @4486 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_4487: // Incoming jump from 0x4450, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @4491 stack[-2] // @4499 stack[-3] // @44A0 memory[0x00:0x40] // @44A1 storage[keccak256(memory[0x00:0x40])] // @44A5 stack[-4] // } 4487 5B JUMPDEST 4488 50 POP 4489 60 PUSH1 0x01 448B 60 PUSH1 0x01 448D 60 PUSH1 0xa0 448F 1B SHL 4490 03 SUB 4491 16 AND 4492 60 PUSH1 0x00 4494 90 SWAP1 4495 81 DUP2 4496 52 MSTORE 4497 60 PUSH1 0x20 4499 91 SWAP2 449A 90 SWAP1 449B 91 SWAP2 449C 52 MSTORE 449D 60 PUSH1 0x40 449F 90 SWAP1 44A0 20 SHA3 44A1 54 SLOAD 44A2 60 PUSH1 0xff 44A4 16 AND 44A5 90 SWAP1 44A6 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @4496 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @449C memory[0x20:0x40] = stack[-3] // @44A5 stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_44A7: // Incoming call from 0x18E6, returns to 0x18E7 // Incoming call from 0x158D, returns to 0x158E // Incoming call from 0x2EF2, returns to 0x2EF3 // Incoming call from 0x258D, returns to 0x258E // Inputs[2] // { // @44AB stack[-2] // @44AC stack[-1] // } 44A7 5B JUMPDEST 44A8 61 PUSH2 0x44b1 44AB 82 DUP3 44AC 82 DUP3 44AD 61 PUSH2 0x4440 44B0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @44A8 stack[0] = 0x44b1 // @44AB stack[1] = stack[-2] // @44AC stack[2] = stack[-1] // } // Block ends with call to 0x4440, returns to 0x44B1 label_44B1: // Incoming return from call to 0x4440 at 0x44B0 // Inputs[1] { @44B5 stack[-1] } 44B1 5B JUMPDEST 44B2 61 PUSH2 0x44ec 44B5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x44ec, if stack[-1] label_44B6: // Incoming jump from 0x44B5, if not stack[-1] // Inputs[3] // { // @44B8 memory[0x40:0x60] // @44E6 memory[0x40:0x60] // @44EB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 44B6 60 PUSH1 0x40 44B8 51 MLOAD 44B9 62 PUSH3 0x461bcd 44BD 60 PUSH1 0xe5 44BF 1B SHL 44C0 81 DUP2 44C1 52 MSTORE 44C2 60 PUSH1 0x04 44C4 01 ADD 44C5 80 DUP1 44C6 80 DUP1 44C7 60 PUSH1 0x20 44C9 01 ADD 44CA 82 DUP3 44CB 81 DUP2 44CC 03 SUB 44CD 82 DUP3 44CE 52 MSTORE 44CF 60 PUSH1 0x21 44D1 81 DUP2 44D2 52 MSTORE 44D3 60 PUSH1 0x20 44D5 01 ADD 44D6 80 DUP1 44D7 61 PUSH2 0x5677 44DA 60 PUSH1 0x21 44DC 91 SWAP2 44DD 39 CODECOPY 44DE 60 PUSH1 0x40 44E0 01 ADD 44E1 91 SWAP2 44E2 50 POP 44E3 50 POP 44E4 60 PUSH1 0x40 44E6 51 MLOAD 44E7 80 DUP1 44E8 91 SWAP2 44E9 03 SUB 44EA 90 SWAP1 44EB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @44C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @44CE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @44D2 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @44DD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x5677:0x5698] // @44EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_44EC: // Incoming jump from 0x44B5, if stack[-1] // Inputs[5] // { // @44F5 stack[-1] // @44FD stack[-2] // @4504 memory[0x00:0x40] // @4506 storage[keccak256(memory[0x00:0x40])] // @450D stack[-3] // } 44EC 5B JUMPDEST 44ED 60 PUSH1 0x01 44EF 60 PUSH1 0x01 44F1 60 PUSH1 0xa0 44F3 1B SHL 44F4 03 SUB 44F5 16 AND 44F6 60 PUSH1 0x00 44F8 90 SWAP1 44F9 81 DUP2 44FA 52 MSTORE 44FB 60 PUSH1 0x20 44FD 91 SWAP2 44FE 90 SWAP1 44FF 91 SWAP2 4500 52 MSTORE 4501 60 PUSH1 0x40 4503 90 SWAP1 4504 20 SHA3 4505 80 DUP1 4506 54 SLOAD 4507 60 PUSH1 0xff 4509 19 NOT 450A 16 AND 450B 90 SWAP1 450C 55 SSTORE 450D 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @44FA memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @4500 memory[0x20:0x40] = stack[-2] // @450C storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_450E: // Incoming jump from 0x16D6 // Incoming call from 0x3F1C, returns to 0x3F1D // Incoming call from 0x1B96, returns to 0x1B97 // Incoming jump from 0x3262 // Inputs[7] // { // @4511 storage[0x97] // @4515 memory[0x40:0x60] // @4528 stack[-3] // @4530 stack[-2] // @453C stack[-1] // @4540 memory[0x40:0x60] // @4565 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 450E 5B JUMPDEST 450F 60 PUSH1 0x97 4511 54 SLOAD 4512 60 PUSH1 0x40 4514 80 DUP1 4515 51 MLOAD 4516 63 PUSH4 0x23b872dd 451B 60 PUSH1 0xe0 451D 1B SHL 451E 81 DUP2 451F 52 MSTORE 4520 60 PUSH1 0x01 4522 60 PUSH1 0x01 4524 60 PUSH1 0xa0 4526 1B SHL 4527 03 SUB 4528 86 DUP7 4529 81 DUP2 452A 16 AND 452B 60 PUSH1 0x04 452D 83 DUP4 452E 01 ADD 452F 52 MSTORE 4530 85 DUP6 4531 81 DUP2 4532 16 AND 4533 60 PUSH1 0x24 4535 83 DUP4 4536 01 ADD 4537 52 MSTORE 4538 60 PUSH1 0x44 453A 82 DUP3 453B 01 ADD 453C 85 DUP6 453D 90 SWAP1 453E 52 MSTORE 453F 91 SWAP2 4540 51 MLOAD 4541 60 PUSH1 0x00 4543 93 SWAP4 4544 84 DUP5 4545 93 SWAP4 4546 84 DUP5 4547 93 SWAP4 4548 91 SWAP2 4549 16 AND 454A 91 SWAP2 454B 63 PUSH4 0x23b872dd 4550 91 SWAP2 4551 60 PUSH1 0x64 4553 80 DUP1 4554 82 DUP3 4555 01 ADD 4556 92 SWAP3 4557 60 PUSH1 0x60 4559 92 SWAP3 455A 90 SWAP1 455B 91 SWAP2 455C 90 SWAP1 455D 82 DUP3 455E 90 SWAP1 455F 03 SUB 4560 01 ADD 4561 81 DUP2 4562 87 DUP8 4563 87 DUP8 4564 80 DUP1 4565 3B EXTCODESIZE 4566 15 ISZERO 4567 80 DUP1 4568 15 ISZERO 4569 61 PUSH2 0x4571 456C 57 *JUMPI // Stack delta = +13 // Outputs[17] // { // @451F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23b872dd << 0xe0 // @452F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @4537 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @453E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @4543 stack[0] = 0x00 // @4545 stack[1] = 0x00 // @4547 stack[2] = 0x00 // @454A stack[3] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @4550 stack[4] = 0x23b872dd // @4556 stack[5] = memory[0x40:0x60] + 0x64 // @4559 stack[6] = 0x60 // @455B stack[7] = memory[0x40:0x60] // @4560 stack[8] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @4561 stack[9] = memory[0x40:0x60] // @4562 stack[10] = 0x00 // @4563 stack[11] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @4566 stack[12] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x4571, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_456D: // Incoming jump from 0x456C, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @4570 memory[0x00:0x00] } 456D 60 PUSH1 0x00 456F 80 DUP1 4570 FD *REVERT // Stack delta = +0 // Outputs[1] { @4570 revert(memory[0x00:0x00]); } // Block terminates label_4571: // Incoming jump from 0x456C, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @4573 msg.gas // @4574 stack[-5] // @4574 memory[stack[-4]:stack[-4] + stack[-5]] // @4574 stack[-3] // @4574 stack[-4] // @4574 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4574 stack[-7] // @4574 stack[-6] // @4574 stack[-2] // } 4571 5B JUMPDEST 4572 50 POP 4573 5A GAS 4574 F1 CALL 4575 15 ISZERO 4576 80 DUP1 4577 15 ISZERO 4578 61 PUSH2 0x4585 457B 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @4574 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4575 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 0x4585, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_457C: // Incoming jump from 0x457B, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @457C returndata.length // @4580 returndata[0x00:0x00 + returndata.length] // @4581 returndata.length // @4584 memory[0x00:0x00 + returndata.length] // } 457C 3D RETURNDATASIZE 457D 60 PUSH1 0x00 457F 80 DUP1 4580 3E RETURNDATACOPY 4581 3D RETURNDATASIZE 4582 60 PUSH1 0x00 4584 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4580 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4584 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4585: // Incoming jump from 0x457B, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @458C memory[0x40:0x60] // @458D returndata.length // } 4585 5B JUMPDEST 4586 50 POP 4587 50 POP 4588 50 POP 4589 50 POP 458A 60 PUSH1 0x40 458C 51 MLOAD 458D 3D RETURNDATASIZE 458E 60 PUSH1 0x60 4590 81 DUP2 4591 10 LT 4592 15 ISZERO 4593 61 PUSH2 0x459b 4596 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @458C stack[-4] = memory[0x40:0x60] // @458D stack[-3] = returndata.length // } // Block ends with conditional jump to 0x459b, if !(returndata.length < 0x60) label_4597: // Incoming jump from 0x4596, if not !(returndata.length < 0x60) // Inputs[1] { @459A memory[0x00:0x00] } 4597 60 PUSH1 0x00 4599 80 DUP1 459A FD *REVERT // Stack delta = +0 // Outputs[1] { @459A revert(memory[0x00:0x00]); } // Block terminates label_459B: // Incoming jump from 0x4596, if !(returndata.length < 0x60) // Inputs[16] // { // @459D stack[-2] // @459E memory[stack[-2]:stack[-2] + 0x20] // @45A4 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @45AA memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // @45AC memory[0x40:0x60] // @45B1 memory[0x40:0x60] // @45B3 stack[-5] // @45B6 stack[-4] // @45B8 stack[-3] // @45C7 stack[-8] // @45CD memory[0x00:0x20] // @45D6 memory[0x00:0x20] // @45E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @45E3 stack[-7] // @45E7 stack[-9] // @45E8 stack[-6] // } 459B 5B JUMPDEST 459C 50 POP 459D 80 DUP1 459E 51 MLOAD 459F 60 PUSH1 0x20 45A1 80 DUP1 45A2 83 DUP4 45A3 01 ADD 45A4 51 MLOAD 45A5 60 PUSH1 0x40 45A7 93 SWAP4 45A8 84 DUP5 45A9 01 ADD 45AA 51 MLOAD 45AB 84 DUP5 45AC 51 MLOAD 45AD 81 DUP2 45AE 81 DUP2 45AF 52 MSTORE 45B0 94 SWAP5 45B1 51 MLOAD 45B2 93 SWAP4 45B3 97 SWAP8 45B4 50 POP 45B5 90 SWAP1 45B6 95 SWAP6 45B7 50 POP 45B8 93 SWAP4 45B9 50 POP 45BA 60 PUSH1 0x01 45BC 60 PUSH1 0x01 45BE 60 PUSH1 0xa0 45C0 1B SHL 45C1 03 SUB 45C2 80 DUP1 45C3 86 DUP7 45C4 16 AND 45C5 93 SWAP4 45C6 90 SWAP1 45C7 8A DUP11 45C8 16 AND 45C9 92 SWAP3 45CA 60 PUSH1 0x00 45CC 80 DUP1 45CD 51 MLOAD 45CE 60 PUSH1 0x20 45D0 61 PUSH2 0x5729 45D3 83 DUP4 45D4 39 CODECOPY 45D5 81 DUP2 45D6 51 MLOAD 45D7 91 SWAP2 45D8 52 MSTORE 45D9 92 SWAP3 45DA 91 SWAP2 45DB 81 DUP2 45DC 90 SWAP1 45DD 03 SUB 45DE 90 SWAP1 45DF 91 SWAP2 45E0 01 ADD 45E1 90 SWAP1 45E2 A3 LOG3 45E3 93 SWAP4 45E4 50 POP 45E5 93 SWAP4 45E6 50 POP 45E7 93 SWAP4 45E8 90 SWAP1 45E9 50 POP 45EA 56 *JUMP // Stack delta = -6 // Outputs[7] // { // @45AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // @45D4 memory[0x00:0x20] = code[0x5729:0x5749] // @45D8 memory[0x00:0x20] = memory[0x00:0x20] // @45E2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [memory[0x00:0x20], stack[-8] & (0x01 << 0xa0) - 0x01, memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & (0x01 << 0xa0) - 0x01]); // @45E3 stack[-7] = memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // @45E5 stack[-8] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @45E7 stack[-9] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to stack[-9] label_45EB: // Incoming call from 0x3803, returns to 0x3804 // Incoming call from 0x1768, returns to 0x1769 // Incoming call from 0x237C, returns to 0x237D // Incoming call from 0x1E2D, returns to 0x1E2E // Inputs[2] // { // @45EF stack[-2] // @45F0 stack[-1] // } 45EB 5B JUMPDEST 45EC 61 PUSH2 0x45f5 45EF 82 DUP3 45F0 82 DUP3 45F1 61 PUSH2 0x4440 45F4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @45EC stack[0] = 0x45f5 // @45EF stack[1] = stack[-2] // @45F0 stack[2] = stack[-1] // } // Block ends with call to 0x4440, returns to 0x45F5 label_45F5: // Incoming return from call to 0x4440 at 0x45F4 // Inputs[1] { @45F6 stack[-1] } 45F5 5B JUMPDEST 45F6 15 ISZERO 45F7 61 PUSH2 0x4647 45FA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4647, if !stack[-1] label_45FB: // Incoming jump from 0x45FA, if not !stack[-1] // Inputs[3] // { // @45FE memory[0x40:0x60] // @463D memory[0x40:0x60] // @4646 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 45FB 60 PUSH1 0x40 45FD 80 DUP1 45FE 51 MLOAD 45FF 62 PUSH3 0x461bcd 4603 60 PUSH1 0xe5 4605 1B SHL 4606 81 DUP2 4607 52 MSTORE 4608 60 PUSH1 0x20 460A 60 PUSH1 0x04 460C 82 DUP3 460D 01 ADD 460E 52 MSTORE 460F 60 PUSH1 0x1f 4611 60 PUSH1 0x24 4613 82 DUP3 4614 01 ADD 4615 52 MSTORE 4616 7F PUSH32 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 4637 60 PUSH1 0x44 4639 82 DUP3 463A 01 ADD 463B 52 MSTORE 463C 90 SWAP1 463D 51 MLOAD 463E 90 SWAP1 463F 81 DUP2 4640 90 SWAP1 4641 03 SUB 4642 60 PUSH1 0x64 4644 01 ADD 4645 90 SWAP1 4646 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4607 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @460E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4615 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @463B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 // @4646 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4647: // Incoming jump from 0x45FA, if !stack[-1] // Inputs[5] // { // @4650 stack[-1] // @4658 stack[-2] // @465F memory[0x00:0x40] // @4661 storage[keccak256(memory[0x00:0x40])] // @466B stack[-3] // } 4647 5B JUMPDEST 4648 60 PUSH1 0x01 464A 60 PUSH1 0x01 464C 60 PUSH1 0xa0 464E 1B SHL 464F 03 SUB 4650 16 AND 4651 60 PUSH1 0x00 4653 90 SWAP1 4654 81 DUP2 4655 52 MSTORE 4656 60 PUSH1 0x20 4658 91 SWAP2 4659 90 SWAP1 465A 91 SWAP2 465B 52 MSTORE 465C 60 PUSH1 0x40 465E 90 SWAP1 465F 20 SHA3 4660 80 DUP1 4661 54 SLOAD 4662 60 PUSH1 0xff 4664 19 NOT 4665 16 AND 4666 60 PUSH1 0x01 4668 17 OR 4669 90 SWAP1 466A 55 SSTORE 466B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @4655 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @465B memory[0x20:0x40] = stack[-2] // @466A storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_466C: // Incoming call from 0x3E3C, returns to 0x3E3D // Incoming call from 0x3C52, returns to 0x3C53 // Incoming call from 0x30FE, returns to 0x30FF // Incoming call from 0x196F, returns to 0x1970 // Inputs[2] // { // @466D stack[-2] // @466E block.timestamp // } 466C 5B JUMPDEST 466D 81 DUP2 466E 42 TIMESTAMP 466F 11 GT 4670 61 PUSH2 0x46a9 4673 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x46a9, if block.timestamp > stack[-2] label_4674: // Incoming jump from 0x4673, if not block.timestamp > stack[-2] // Inputs[3] // { // @4677 memory[0x40:0x60] // @469F memory[0x40:0x60] // @46A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4674 60 PUSH1 0x40 4676 80 DUP1 4677 51 MLOAD 4678 62 PUSH3 0x461bcd 467C 60 PUSH1 0xe5 467E 1B SHL 467F 81 DUP2 4680 52 MSTORE 4681 60 PUSH1 0x20 4683 60 PUSH1 0x04 4685 80 DUP1 4686 83 DUP4 4687 01 ADD 4688 91 SWAP2 4689 90 SWAP1 468A 91 SWAP2 468B 52 MSTORE 468C 60 PUSH1 0x24 468E 82 DUP3 468F 01 ADD 4690 52 MSTORE 4691 63 PUSH4 0x22ac1819 4696 60 PUSH1 0xe1 4698 1B SHL 4699 60 PUSH1 0x44 469B 82 DUP3 469C 01 ADD 469D 52 MSTORE 469E 90 SWAP1 469F 51 MLOAD 46A0 90 SWAP1 46A1 81 DUP2 46A2 90 SWAP1 46A3 03 SUB 46A4 60 PUSH1 0x64 46A6 01 ADD 46A7 90 SWAP1 46A8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4680 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @468B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4690 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @469D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x22ac1819 << 0xe1 // @46A8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_46A9: // Incoming jump from 0x4673, if block.timestamp > stack[-2] // Inputs[2] // { // @46AA stack[-1] // @46AB block.timestamp // } 46A9 5B JUMPDEST 46AA 80 DUP1 46AB 42 TIMESTAMP 46AC 10 LT 46AD 61 PUSH2 0x46e6 46B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x46e6, if block.timestamp < stack[-1] label_46B1: // Incoming jump from 0x46B0, if not block.timestamp < stack[-1] // Inputs[3] // { // @46B4 memory[0x40:0x60] // @46DC memory[0x40:0x60] // @46E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 46B1 60 PUSH1 0x40 46B3 80 DUP1 46B4 51 MLOAD 46B5 62 PUSH3 0x461bcd 46B9 60 PUSH1 0xe5 46BB 1B SHL 46BC 81 DUP2 46BD 52 MSTORE 46BE 60 PUSH1 0x20 46C0 60 PUSH1 0x04 46C2 80 DUP1 46C3 83 DUP4 46C4 01 ADD 46C5 91 SWAP2 46C6 90 SWAP1 46C7 91 SWAP2 46C8 52 MSTORE 46C9 60 PUSH1 0x24 46CB 82 DUP3 46CC 01 ADD 46CD 52 MSTORE 46CE 63 PUSH4 0x45583031 46D3 60 PUSH1 0xe0 46D5 1B SHL 46D6 60 PUSH1 0x44 46D8 82 DUP3 46D9 01 ADD 46DA 52 MSTORE 46DB 90 SWAP1 46DC 51 MLOAD 46DD 90 SWAP1 46DE 81 DUP2 46DF 90 SWAP1 46E0 03 SUB 46E1 60 PUSH1 0x64 46E3 01 ADD 46E4 90 SWAP1 46E5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @46BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @46C8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @46CD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @46DA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45583031 << 0xe0 // @46E5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_46E6: // Incoming jump from 0x46B0, if block.timestamp < stack[-1] // Inputs[2] // { // @46EA stack[-4] // @46EB stack[-3] // } 46E6 5B JUMPDEST 46E7 61 PUSH2 0x46f0 46EA 84 DUP5 46EB 84 DUP5 46EC 61 PUSH2 0x4a2f 46EF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @46E7 stack[0] = 0x46f0 // @46EA stack[1] = stack[-4] // @46EB stack[2] = stack[-3] // } // Block ends with call to 0x4a2f, returns to 0x46F0 label_46F0: // Incoming return from call to 0x4A2F at 0x46EF // Inputs[1] { @46F5 stack[-5] } 46F0 5B JUMPDEST 46F1 50 POP 46F2 50 POP 46F3 50 POP 46F4 50 POP 46F5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_46F6: // Incoming call from 0x3CD9, returns to 0x3CDA // Incoming call from 0x2425, returns to 0x2426 // Incoming call from 0x3EC3, returns to 0x3EC4 // Incoming call from 0x3185, returns to 0x3186 // Incoming call from 0x39C7, returns to 0x39C8 // Incoming call from 0x19F6, returns to 0x19F7 // Inputs[11] // { // @46F7 stack[-1] // @46F8 memory[stack[-1]:stack[-1] + 0x20] // @4701 memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]] // @4705 memory[0x40:0x60] // @4714 stack[-5] // @4721 memory[0x40:0x60] // @4730 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @4733 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @473B stack[-4] // @473C stack[-3] // @473D stack[-2] // } 46F6 5B JUMPDEST 46F7 80 DUP1 46F8 51 MLOAD 46F9 60 PUSH1 0x20 46FB 80 DUP1 46FC 83 DUP4 46FD 01 ADD 46FE 91 SWAP2 46FF 90 SWAP1 4700 91 SWAP2 4701 20 SHA3 4702 60 PUSH1 0x40 4704 80 DUP1 4705 51 MLOAD 4706 61 PUSH2 0x1901 4709 60 PUSH1 0xf0 470B 1B SHL 470C 81 DUP2 470D 85 DUP6 470E 01 ADD 470F 52 MSTORE 4710 60 PUSH1 0x22 4712 81 DUP2 4713 01 ADD 4714 89 DUP10 4715 90 SWAP1 4716 52 MSTORE 4717 60 PUSH1 0x42 4719 80 DUP1 471A 82 DUP3 471B 01 ADD 471C 93 SWAP4 471D 90 SWAP1 471E 93 SWAP4 471F 52 MSTORE 4720 81 DUP2 4721 51 MLOAD 4722 80 DUP1 4723 82 DUP3 4724 03 SUB 4725 90 SWAP1 4726 93 SWAP4 4727 01 ADD 4728 83 DUP4 4729 52 MSTORE 472A 60 PUSH1 0x62 472C 01 ADD 472D 90 SWAP1 472E 52 MSTORE 472F 80 DUP1 4730 51 MLOAD 4731 91 SWAP2 4732 01 ADD 4733 20 SHA3 4734 60 PUSH1 0x00 4736 90 SWAP1 4737 61 PUSH2 0x4742 473A 81 DUP2 473B 87 DUP8 473C 87 DUP8 473D 87 DUP8 473E 61 PUSH2 0x4fa3 4741 56 *JUMP // Stack delta = +7 // Outputs[12] // { // @470F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x1901 << 0xf0 // @4716 memory[memory[0x40:0x60] + 0x22:memory[0x40:0x60] + 0x22 + 0x20] = stack[-5] // @471F memory[memory[0x40:0x60] + 0x42:memory[0x40:0x60] + 0x42 + 0x20] = keccak256(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) // @4729 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x42 + (memory[0x40:0x60] - memory[0x40:0x60]) // @472E memory[0x40:0x60] = 0x62 + memory[0x40:0x60] // @4736 stack[0] = 0x00 // @4736 stack[1] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @4737 stack[2] = 0x4742 // @473A stack[3] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @473B stack[4] = stack[-4] // @473C stack[5] = stack[-3] // @473D stack[6] = stack[-2] // } // Block ends with call to 0x4fa3, returns to 0x4742 label_4742: // Incoming return from call to 0x4FA3 at 0x4741 // Inputs[3] // { // @4743 stack[-9] // @4743 stack[-1] // @4744 stack[-8] // } 4742 5B JUMPDEST 4743 97 SWAP8 4744 96 SWAP7 4745 50 POP 4746 50 POP 4747 50 POP 4748 50 POP 4749 50 POP 474A 50 POP 474B 50 POP 474C 56 *JUMP // Stack delta = -8 // Outputs[1] { @4743 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_474D: // Incoming call from 0x1A44, returns to 0x1A45 // Incoming call from 0x31D3, returns to 0x31D4 // Incoming call from 0x3F11, returns to 0x3F12 // Incoming call from 0x3D27, returns to 0x3D28 // Inputs[8] // { // @4756 stack[-2] // @4769 memory[0x00:0x40] // @476A stack[-1] // @4772 memory[0x00:0x40] // @4774 storage[keccak256(memory[0x00:0x40])] // @477E memory[0x40:0x60] // @47A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @47A7 stack[-3] // } 474D 5B JUMPDEST 474E 60 PUSH1 0x01 4750 60 PUSH1 0x01 4752 60 PUSH1 0xa0 4754 1B SHL 4755 03 SUB 4756 82 DUP3 4757 16 AND 4758 60 PUSH1 0x00 475A 81 DUP2 475B 81 DUP2 475C 52 MSTORE 475D 61 PUSH2 0x0107 4760 60 PUSH1 0x20 4762 90 SWAP1 4763 81 DUP2 4764 52 MSTORE 4765 60 PUSH1 0x40 4767 80 DUP1 4768 83 DUP4 4769 20 SHA3 476A 85 DUP6 476B 84 DUP5 476C 52 MSTORE 476D 90 SWAP1 476E 91 SWAP2 476F 52 MSTORE 4770 80 DUP1 4771 82 DUP3 4772 20 SHA3 4773 80 DUP1 4774 54 SLOAD 4775 60 PUSH1 0xff 4777 19 NOT 4778 16 AND 4779 60 PUSH1 0x01 477B 17 OR 477C 90 SWAP1 477D 55 SSTORE 477E 51 MLOAD 477F 83 DUP4 4780 92 SWAP3 4781 91 SWAP2 4782 7F PUSH32 0x98de503528ee59b575ef0c0a2576a82497bfc029a5685b209e9ec333479b10a5 47A3 91 SWAP2 47A4 A3 LOG3 47A5 50 POP 47A6 50 POP 47A7 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @475C memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @4764 memory[0x20:0x40] = 0x0107 // @476C memory[0x00:0x20] = stack[-1] // @476F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @477D storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @47A4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x98de503528ee59b575ef0c0a2576a82497bfc029a5685b209e9ec333479b10a5, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with unconditional jump to stack[-3] label_47A8: // Incoming call from 0x1A4F, returns to 0x1A50 // Incoming jump from 0x2520 // Inputs[7] // { // @47AB storage[0x97] // @47AF memory[0x40:0x60] // @47C2 stack[-3] // @47CA stack[-2] // @47D6 stack[-1] // @47DA memory[0x40:0x60] // @47F9 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 47A8 5B JUMPDEST 47A9 60 PUSH1 0x97 47AB 54 SLOAD 47AC 60 PUSH1 0x40 47AE 80 DUP1 47AF 51 MLOAD 47B0 63 PUSH4 0xf019c267 47B5 60 PUSH1 0xe0 47B7 1B SHL 47B8 81 DUP2 47B9 52 MSTORE 47BA 60 PUSH1 0x01 47BC 60 PUSH1 0x01 47BE 60 PUSH1 0xa0 47C0 1B SHL 47C1 03 SUB 47C2 86 DUP7 47C3 81 DUP2 47C4 16 AND 47C5 60 PUSH1 0x04 47C7 83 DUP4 47C8 01 ADD 47C9 52 MSTORE 47CA 85 DUP6 47CB 81 DUP2 47CC 16 AND 47CD 60 PUSH1 0x24 47CF 83 DUP4 47D0 01 ADD 47D1 52 MSTORE 47D2 60 PUSH1 0x44 47D4 82 DUP3 47D5 01 ADD 47D6 85 DUP6 47D7 90 SWAP1 47D8 52 MSTORE 47D9 91 SWAP2 47DA 51 MLOAD 47DB 91 SWAP2 47DC 90 SWAP1 47DD 92 SWAP3 47DE 16 AND 47DF 91 SWAP2 47E0 63 PUSH4 0xf019c267 47E5 91 SWAP2 47E6 60 PUSH1 0x64 47E8 80 DUP1 47E9 83 DUP4 47EA 01 ADD 47EB 92 SWAP3 47EC 60 PUSH1 0x00 47EE 92 SWAP3 47EF 91 SWAP2 47F0 90 SWAP1 47F1 82 DUP3 47F2 90 SWAP1 47F3 03 SUB 47F4 01 ADD 47F5 81 DUP2 47F6 83 DUP4 47F7 87 DUP8 47F8 80 DUP1 47F9 3B EXTCODESIZE 47FA 15 ISZERO 47FB 80 DUP1 47FC 15 ISZERO 47FD 61 PUSH2 0x4805 4800 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @47B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf019c267 << 0xe0 // @47C9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @47D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @47D8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @47DF stack[0] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @47E5 stack[1] = 0xf019c267 // @47EB stack[2] = memory[0x40:0x60] + 0x64 // @47EE stack[3] = 0x00 // @47EF stack[4] = memory[0x40:0x60] // @47F4 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @47F5 stack[6] = memory[0x40:0x60] // @47F6 stack[7] = 0x00 // @47F7 stack[8] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @47FA stack[9] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x4805, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_4801: // Incoming jump from 0x4800, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @4804 memory[0x00:0x00] } 4801 60 PUSH1 0x00 4803 80 DUP1 4804 FD *REVERT // Stack delta = +0 // Outputs[1] { @4804 revert(memory[0x00:0x00]); } // Block terminates label_4805: // Incoming jump from 0x4800, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x4B97, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @4807 msg.gas // @4808 stack[-6] // @4808 stack[-4] // @4808 stack[-7] // @4808 stack[-3] // @4808 stack[-5] // @4808 memory[stack[-4]:stack[-4] + stack[-5]] // @4808 stack[-2] // @4808 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 4805 5B JUMPDEST 4806 50 POP 4807 5A GAS 4808 F1 CALL 4809 15 ISZERO 480A 80 DUP1 480B 15 ISZERO 480C 61 PUSH2 0x4819 480F 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @4808 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4809 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 0x4819, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_4810: // Incoming jump from 0x480F, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @4810 returndata.length // @4814 returndata[0x00:0x00 + returndata.length] // @4815 returndata.length // @4818 memory[0x00:0x00 + returndata.length] // } 4810 3D RETURNDATASIZE 4811 60 PUSH1 0x00 4813 80 DUP1 4814 3E RETURNDATACOPY 4815 3D RETURNDATASIZE 4816 60 PUSH1 0x00 4818 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4814 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4818 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4819: // Incoming jump from 0x480F, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[8] // { // @481E storage[0x97] // @4822 memory[0x40:0x60] // @4835 stack[-7] // @483D stack[-6] // @4846 memory[0x40:0x60] // @4849 stack[-4] // @484F stack[-3] // @486A address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 4819 5B JUMPDEST 481A 50 POP 481B 50 POP 481C 60 PUSH1 0x97 481E 54 SLOAD 481F 60 PUSH1 0x40 4821 80 DUP1 4822 51 MLOAD 4823 63 PUSH4 0x6eb1769f 4828 60 PUSH1 0xe1 482A 1B SHL 482B 81 DUP2 482C 52 MSTORE 482D 60 PUSH1 0x01 482F 60 PUSH1 0x01 4831 60 PUSH1 0xa0 4833 1B SHL 4834 03 SUB 4835 88 DUP9 4836 81 DUP2 4837 16 AND 4838 60 PUSH1 0x04 483A 83 DUP4 483B 01 ADD 483C 52 MSTORE 483D 87 DUP8 483E 81 DUP2 483F 16 AND 4840 60 PUSH1 0x24 4842 83 DUP4 4843 01 ADD 4844 52 MSTORE 4845 91 SWAP2 4846 51 MLOAD 4847 60 PUSH1 0x00 4849 95 SWAP6 484A 50 POP 484B 91 SWAP2 484C 90 SWAP1 484D 92 SWAP3 484E 16 AND 484F 92 SWAP3 4850 50 POP 4851 63 PUSH4 0xdd62ed3e 4856 91 SWAP2 4857 60 PUSH1 0x44 4859 80 DUP1 485A 82 DUP3 485B 01 ADD 485C 92 SWAP3 485D 60 PUSH1 0x20 485F 92 SWAP3 4860 90 SWAP1 4861 91 SWAP2 4862 90 SWAP1 4863 82 DUP3 4864 90 SWAP1 4865 03 SUB 4866 01 ADD 4867 81 DUP2 4868 86 DUP7 4869 80 DUP1 486A 3B EXTCODESIZE 486B 15 ISZERO 486C 80 DUP1 486D 15 ISZERO 486E 61 PUSH2 0x4876 4871 57 *JUMPI // Stack delta = +6 // Outputs[13] // { // @482C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6eb1769f << 0xe1 // @483C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @4844 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @4849 stack[-4] = 0x00 // @484F stack[-3] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @4856 stack[-2] = 0xdd62ed3e // @485C stack[-1] = memory[0x40:0x60] + 0x44 // @485F stack[0] = 0x20 // @4861 stack[1] = memory[0x40:0x60] // @4866 stack[2] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @4867 stack[3] = memory[0x40:0x60] // @4868 stack[4] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @486B stack[5] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x4876, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_4872: // Incoming jump from 0x4871, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @4875 memory[0x00:0x00] } 4872 60 PUSH1 0x00 4874 80 DUP1 4875 FD *REVERT // Stack delta = +0 // Outputs[1] { @4875 revert(memory[0x00:0x00]); } // Block terminates label_4876: // Incoming jump from 0x4871, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @4878 msg.gas // @4879 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @4879 stack[-2] // @4879 stack[-4] // @4879 stack[-3] // @4879 memory[stack[-3]:stack[-3] + stack[-4]] // @4879 stack[-6] // @4879 stack[-5] // } 4876 5B JUMPDEST 4877 50 POP 4878 5A GAS 4879 FA STATICCALL 487A 15 ISZERO 487B 80 DUP1 487C 15 ISZERO 487D 61 PUSH2 0x488a 4880 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @4879 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @487A stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x488a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_4881: // Incoming jump from 0x4880, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @4881 returndata.length // @4885 returndata[0x00:0x00 + returndata.length] // @4886 returndata.length // @4889 memory[0x00:0x00 + returndata.length] // } 4881 3D RETURNDATASIZE 4882 60 PUSH1 0x00 4884 80 DUP1 4885 3E RETURNDATACOPY 4886 3D RETURNDATASIZE 4887 60 PUSH1 0x00 4889 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4885 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4889 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_488A: // Incoming jump from 0x4880, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @4891 memory[0x40:0x60] // @4892 returndata.length // } 488A 5B JUMPDEST 488B 50 POP 488C 50 POP 488D 50 POP 488E 50 POP 488F 60 PUSH1 0x40 4891 51 MLOAD 4892 3D RETURNDATASIZE 4893 60 PUSH1 0x20 4895 81 DUP2 4896 10 LT 4897 15 ISZERO 4898 61 PUSH2 0x48a0 489B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4891 stack[-4] = memory[0x40:0x60] // @4892 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x48a0, if !(returndata.length < 0x20) label_489C: // Incoming jump from 0x489B, if not !(returndata.length < 0x20) // Inputs[1] { @489F memory[0x00:0x00] } 489C 60 PUSH1 0x00 489E 80 DUP1 489F FD *REVERT // Stack delta = +0 // Outputs[1] { @489F revert(memory[0x00:0x00]); } // Block terminates label_48A0: // Incoming jump from 0x489B, if !(returndata.length < 0x20) // Inputs[9] // { // @48A2 memory[stack[-2]:stack[-2] + 0x20] // @48A2 stack[-2] // @48A6 memory[0x40:0x60] // @48AB memory[0x40:0x60] // @48AD stack[-3] // @48B8 stack[-5] // @48BC stack[-6] // @48E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @48EE stack[-7] // } 48A0 5B JUMPDEST 48A1 50 POP 48A2 51 MLOAD 48A3 60 PUSH1 0x40 48A5 80 DUP1 48A6 51 MLOAD 48A7 82 DUP3 48A8 81 DUP2 48A9 52 MSTORE 48AA 90 SWAP1 48AB 51 MLOAD 48AC 91 SWAP2 48AD 92 SWAP3 48AE 50 POP 48AF 60 PUSH1 0x01 48B1 60 PUSH1 0x01 48B3 60 PUSH1 0xa0 48B5 1B SHL 48B6 03 SUB 48B7 80 DUP1 48B8 86 DUP7 48B9 16 AND 48BA 92 SWAP3 48BB 90 SWAP1 48BC 87 DUP8 48BD 16 AND 48BE 91 SWAP2 48BF 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 48E0 91 SWAP2 48E1 90 SWAP1 48E2 81 DUP2 48E3 90 SWAP1 48E4 03 SUB 48E5 60 PUSH1 0x20 48E7 01 ADD 48E8 90 SWAP1 48E9 A3 LOG3 48EA 50 POP 48EB 50 POP 48EC 50 POP 48ED 50 POP 48EE 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @48A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @48E9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-7] label_48EF: // Incoming call from 0x490D, returns to 0x490E // Incoming call from 0x539F, returns to 0x53A0 // Incoming call from 0x20FB, returns to 0x20FC // Incoming call from 0x5139, returns to 0x513A // Incoming call from 0x52FF, returns to 0x5300 // Incoming call from 0x4D5E, returns to 0x4D5F // Incoming call from 0x42CA, returns to 0x42CB // Inputs[3] // { // @48F0 address(this) // @48F1 address(address(this)).code.length // @48F3 stack[-1] // } 48EF 5B JUMPDEST 48F0 30 ADDRESS 48F1 3B EXTCODESIZE 48F2 15 ISZERO 48F3 90 SWAP1 48F4 56 *JUMP // Stack delta = +0 // Outputs[1] { @48F3 stack[-1] = !address(address(this)).code.length } // Block ends with unconditional jump to stack[-1] label_48F5: // Incoming jump from 0x2179 // Incoming jump from 0x2179 // Inputs[1] { @48F8 storage[0x00] } 48F5 5B JUMPDEST 48F6 60 PUSH1 0x00 48F8 54 SLOAD 48F9 61 PUSH2 0x0100 48FC 90 SWAP1 48FD 04 DIV 48FE 60 PUSH1 0xff 4900 16 AND 4901 80 DUP1 4902 61 PUSH2 0x490e 4905 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4900 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x490e, if 0xff & storage[0x00] / 0x0100 label_4906: // Incoming jump from 0x4905, if not 0xff & storage[0x00] / 0x0100 4906 50 POP 4907 61 PUSH2 0x490e 490A 61 PUSH2 0x48ef 490D 56 *JUMP // Stack delta = +0 // Outputs[1] { @4907 stack[-1] = 0x490e } // Block ends with call to 0x48ef, returns to 0x490E label_490E: // Incoming jump from 0x4905, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x48EF at 0x490D // Inputs[1] { @490F stack[-1] } 490E 5B JUMPDEST 490F 80 DUP1 4910 61 PUSH2 0x491c 4913 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x491c, if stack[-1] label_4914: // Incoming jump from 0x4913, if not stack[-1] // Inputs[1] { @4917 storage[0x00] } 4914 50 POP 4915 60 PUSH1 0x00 4917 54 SLOAD 4918 60 PUSH1 0xff 491A 16 AND 491B 15 ISZERO 491C 5B JUMPDEST 491D 61 PUSH2 0x4957 4920 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4957, if !(0xff & storage[0x00]) label_4921: // Incoming jump from 0x4920, if not stack[-1] // Incoming jump from 0x4920, if not !(0xff & storage[0x00]) // Inputs[3] // { // @4923 memory[0x40:0x60] // @4951 memory[0x40:0x60] // @4956 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 4921 60 PUSH1 0x40 4923 51 MLOAD 4924 62 PUSH3 0x461bcd 4928 60 PUSH1 0xe5 492A 1B SHL 492B 81 DUP2 492C 52 MSTORE 492D 60 PUSH1 0x04 492F 01 ADD 4930 80 DUP1 4931 80 DUP1 4932 60 PUSH1 0x20 4934 01 ADD 4935 82 DUP3 4936 81 DUP2 4937 03 SUB 4938 82 DUP3 4939 52 MSTORE 493A 60 PUSH1 0x2e 493C 81 DUP2 493D 52 MSTORE 493E 60 PUSH1 0x20 4940 01 ADD 4941 80 DUP1 4942 61 PUSH2 0x56fb 4945 60 PUSH1 0x2e 4947 91 SWAP2 4948 39 CODECOPY 4949 60 PUSH1 0x40 494B 01 ADD 494C 91 SWAP2 494D 50 POP 494E 50 POP 494F 60 PUSH1 0x40 4951 51 MLOAD 4952 80 DUP1 4953 91 SWAP2 4954 03 SUB 4955 90 SWAP1 4956 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @492C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4939 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @493D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @4948 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x56fb:0x5729] // @4956 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_4957: // Incoming jump from 0x4920, if stack[-1] // Incoming jump from 0x4920, if !(0xff & storage[0x00]) // Inputs[1] { @495A storage[0x00] } 4957 5B JUMPDEST 4958 60 PUSH1 0x00 495A 54 SLOAD 495B 61 PUSH2 0x0100 495E 90 SWAP1 495F 04 DIV 4960 60 PUSH1 0xff 4962 16 AND 4963 15 ISZERO 4964 80 DUP1 4965 15 ISZERO 4966 61 PUSH2 0x4982 4969 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4963 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x4982, if !!(0xff & storage[0x00] / 0x0100) label_496A: // Incoming jump from 0x4969, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[1] { @496D storage[0x00] } 496A 60 PUSH1 0x00 496C 80 DUP1 496D 54 SLOAD 496E 60 PUSH1 0xff 4970 19 NOT 4971 61 PUSH2 0xff00 4974 19 NOT 4975 90 SWAP1 4976 91 SWAP2 4977 16 AND 4978 61 PUSH2 0x0100 497B 17 OR 497C 16 AND 497D 60 PUSH1 0x01 497F 17 OR 4980 90 SWAP1 4981 55 SSTORE 4982 5B JUMPDEST 4983 61 PUSH2 0x498a 4986 61 PUSH2 0x5121 4989 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @4981 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @4983 stack[0] = 0x498a // } // Block ends with unconditional jump to 0x5121 498A 5B JUMPDEST 498B 61 PUSH2 0x4993 498E 83 DUP4 498F 61 PUSH2 0x41b9 4992 56 *JUMP 4993 5B JUMPDEST 4994 60 PUSH1 0x97 4996 80 DUP1 4997 54 SLOAD 4998 60 PUSH1 0x01 499A 60 PUSH1 0x01 499C 60 PUSH1 0xa0 499E 1B SHL 499F 03 SUB 49A0 84 DUP5 49A1 16 AND 49A2 60 PUSH1 0x01 49A4 60 PUSH1 0x01 49A6 60 PUSH1 0xa0 49A8 1B SHL 49A9 03 SUB 49AA 19 NOT 49AB 91 SWAP2 49AC 82 DUP3 49AD 16 AND 49AE 81 DUP2 49AF 17 OR 49B0 90 SWAP1 49B1 92 SWAP3 49B2 55 SSTORE 49B3 60 PUSH1 0x9b 49B5 80 DUP1 49B6 54 SLOAD 49B7 90 SWAP1 49B8 91 SWAP2 49B9 16 AND 49BA 30 ADDRESS 49BB 17 OR 49BC 90 SWAP1 49BD 55 SSTORE 49BE 60 PUSH1 0x40 49C0 51 MLOAD 49C1 7F PUSH32 0x63e7655c5ec08f94bc8ad23d90d8b7b5b1eddd5bb793c6dbfc7e00ce8fcdac47 49E2 90 SWAP1 49E3 60 PUSH1 0x00 49E5 90 SWAP1 49E6 A2 LOG2 49E7 60 PUSH1 0x40 49E9 80 DUP1 49EA 51 MLOAD 49EB 30 ADDRESS 49EC 81 DUP2 49ED 52 MSTORE 49EE 90 SWAP1 49EF 51 MLOAD 49F0 7F PUSH32 0x198af0cedad0e99479f8e29795c967775c9a824402a94819578621b53864c243 4A11 91 SWAP2 4A12 81 DUP2 4A13 90 SWAP1 4A14 03 SUB 4A15 60 PUSH1 0x20 4A17 01 ADD 4A18 90 SWAP1 4A19 A1 LOG1 4A1A 80 DUP1 4A1B 15 ISZERO 4A1C 61 PUSH2 0x218c 4A1F 57 *JUMPI 4A20 60 PUSH1 0x00 4A22 80 DUP1 4A23 54 SLOAD 4A24 61 PUSH2 0xff00 4A27 19 NOT 4A28 16 AND 4A29 90 SWAP1 4A2A 55 SSTORE 4A2B 50 POP 4A2C 50 POP 4A2D 50 POP 4A2E 56 *JUMP label_4A2F: // Incoming call from 0x23BD, returns to 0x23BE // Incoming call from 0x46EF, returns to 0x46F0 // Inputs[5] // { // @4A38 stack[-2] // @4A4B memory[0x00:0x40] // @4A4C stack[-1] // @4A53 memory[0x00:0x40] // @4A54 storage[keccak256(memory[0x00:0x40])] // } 4A2F 5B JUMPDEST 4A30 60 PUSH1 0x01 4A32 60 PUSH1 0x01 4A34 60 PUSH1 0xa0 4A36 1B SHL 4A37 03 SUB 4A38 82 DUP3 4A39 16 AND 4A3A 60 PUSH1 0x00 4A3C 90 SWAP1 4A3D 81 DUP2 4A3E 52 MSTORE 4A3F 61 PUSH2 0x0107 4A42 60 PUSH1 0x20 4A44 90 SWAP1 4A45 81 DUP2 4A46 52 MSTORE 4A47 60 PUSH1 0x40 4A49 80 DUP1 4A4A 83 DUP4 4A4B 20 SHA3 4A4C 84 DUP5 4A4D 84 DUP5 4A4E 52 MSTORE 4A4F 90 SWAP1 4A50 91 SWAP2 4A51 52 MSTORE 4A52 81 DUP2 4A53 20 SHA3 4A54 54 SLOAD 4A55 60 PUSH1 0xff 4A57 16 AND 4A58 60 PUSH1 0x02 4A5A 81 DUP2 4A5B 11 GT 4A5C 15 ISZERO 4A5D 61 PUSH2 0x4a62 4A60 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @4A3C stack[0] = 0x00 // @4A3E memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @4A46 memory[0x20:0x40] = 0x0107 // @4A4E memory[0x00:0x20] = stack[-1] // @4A51 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @4A57 stack[1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x4a62, if !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x02) label_4A61: // Incoming jump from 0x4A60, if not !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x02) 4A61 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4A61 assert(); } // Block terminates label_4A62: // Incoming jump from 0x4A60, if !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x02) // Inputs[2] // { // @4A63 stack[-2] // @4A63 stack[-1] // } 4A62 5B JUMPDEST 4A63 14 EQ 4A64 61 PUSH2 0x2521 4A67 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2521, if stack[-1] == stack[-2] label_4A68: // Incoming jump from 0x4A67, if not stack[-1] == stack[-2] // Inputs[3] // { // @4A6B memory[0x40:0x60] // @4A93 memory[0x40:0x60] // @4A9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4A68 60 PUSH1 0x40 4A6A 80 DUP1 4A6B 51 MLOAD 4A6C 62 PUSH3 0x461bcd 4A70 60 PUSH1 0xe5 4A72 1B SHL 4A73 81 DUP2 4A74 52 MSTORE 4A75 60 PUSH1 0x20 4A77 60 PUSH1 0x04 4A79 80 DUP1 4A7A 83 DUP4 4A7B 01 ADD 4A7C 91 SWAP2 4A7D 90 SWAP1 4A7E 91 SWAP2 4A7F 52 MSTORE 4A80 60 PUSH1 0x24 4A82 82 DUP3 4A83 01 ADD 4A84 52 MSTORE 4A85 63 PUSH4 0x45583033 4A8A 60 PUSH1 0xe0 4A8C 1B SHL 4A8D 60 PUSH1 0x44 4A8F 82 DUP3 4A90 01 ADD 4A91 52 MSTORE 4A92 90 SWAP1 4A93 51 MLOAD 4A94 90 SWAP1 4A95 81 DUP2 4A96 90 SWAP1 4A97 03 SUB 4A98 60 PUSH1 0x64 4A9A 01 ADD 4A9B 90 SWAP1 4A9C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4A74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4A7F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4A84 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @4A91 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45583033 << 0xe0 // @4A9C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4A9D: // Incoming jump from 0x2ABC // Incoming jump from 0x2AE8 // Inputs[3] // { // @4AA3 stack[-2] // @4AA4 stack[-1] // @4AA7 memory[0x40:0x60] // } 4A9D 5B JUMPDEST 4A9E 60 PUSH1 0x00 4AA0 61 PUSH2 0x4adf 4AA3 83 DUP4 4AA4 83 DUP4 4AA5 60 PUSH1 0x40 4AA7 51 MLOAD 4AA8 80 DUP1 4AA9 60 PUSH1 0x40 4AAB 01 ADD 4AAC 60 PUSH1 0x40 4AAE 52 MSTORE 4AAF 80 DUP1 4AB0 60 PUSH1 0x1a 4AB2 81 DUP2 4AB3 52 MSTORE 4AB4 60 PUSH1 0x20 4AB6 01 ADD 4AB7 7F PUSH32 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 4AD8 81 DUP2 4AD9 52 MSTORE 4ADA 50 POP 4ADB 61 PUSH2 0x51d3 4ADE 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @4A9E stack[0] = 0x00 // @4AA0 stack[1] = 0x4adf // @4AA3 stack[2] = stack[-2] // @4AA4 stack[3] = stack[-1] // @4AA7 stack[4] = memory[0x40:0x60] // @4AAE memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @4AB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1a // @4AD9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 // } // Block ends with call to 0x51d3, returns to 0x4ADF label_4ADF: // Incoming return from call to 0x51D3 at 0x4ADE // Incoming jump from 0x4BA9, if !(stack[-1] + stack[-2] < stack[-2]) // Incoming jump from 0x4B08, if stack[-1] / stack[-2] == stack[-3] // Inputs[3] // { // @4AE0 stack[-1] // @4AE0 stack[-5] // @4AE1 stack[-4] // } 4ADF 5B JUMPDEST 4AE0 93 SWAP4 4AE1 92 SWAP3 4AE2 50 POP 4AE3 50 POP 4AE4 50 POP 4AE5 56 *JUMP // Stack delta = -4 // Outputs[1] { @4AE0 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_4AE6: // Incoming call from 0x2B11, returns to 0x2B12 // Incoming jump from 0x2B1D // Inputs[1] { @4AE9 stack[-2] } 4AE6 5B JUMPDEST 4AE7 60 PUSH1 0x00 4AE9 82 DUP3 4AEA 61 PUSH2 0x4af5 4AED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4AE7 stack[0] = 0x00 } // Block ends with conditional jump to 0x4af5, if stack[-2] label_4AEE: // Incoming jump from 0x4AED, if not stack[-2] 4AEE 50 POP 4AEF 60 PUSH1 0x00 4AF1 61 PUSH2 0x14f0 4AF4 56 *JUMP // Stack delta = +0 // Outputs[1] { @4AEF stack[-1] = 0x00 } // Block ends with unconditional jump to 0x14f0 label_4AF5: // Incoming jump from 0x4AED, if stack[-2] // Inputs[2] // { // @4AF6 stack[-3] // @4AF7 stack[-2] // } 4AF5 5B JUMPDEST 4AF6 82 DUP3 4AF7 82 DUP3 4AF8 02 MUL 4AF9 82 DUP3 4AFA 84 DUP5 4AFB 82 DUP3 4AFC 81 DUP2 4AFD 61 PUSH2 0x4b02 4B00 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @4AF8 stack[0] = stack[-2] * stack[-3] // @4AF9 stack[1] = stack[-2] // @4AFA stack[2] = stack[-3] // @4AFB stack[3] = stack[-2] * stack[-3] // } // Block ends with conditional jump to 0x4b02, if stack[-3] label_4B01: // Incoming jump from 0x4B00, if not stack[-3] 4B01 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4B01 assert(); } // Block terminates label_4B02: // Incoming jump from 0x4B00, if stack[-3] // Inputs[3] // { // @4B03 stack[-2] // @4B03 stack[-1] // @4B04 stack[-3] // } 4B02 5B JUMPDEST 4B03 04 DIV 4B04 14 EQ 4B05 61 PUSH2 0x4adf 4B08 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x4adf, if stack[-1] / stack[-2] == stack[-3] label_4B09: // Incoming jump from 0x4B08, if not stack[-1] / stack[-2] == stack[-3] // Inputs[3] // { // @4B0B memory[0x40:0x60] // @4B39 memory[0x40:0x60] // @4B3E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 4B09 60 PUSH1 0x40 4B0B 51 MLOAD 4B0C 62 PUSH3 0x461bcd 4B10 60 PUSH1 0xe5 4B12 1B SHL 4B13 81 DUP2 4B14 52 MSTORE 4B15 60 PUSH1 0x04 4B17 01 ADD 4B18 80 DUP1 4B19 80 DUP1 4B1A 60 PUSH1 0x20 4B1C 01 ADD 4B1D 82 DUP3 4B1E 81 DUP2 4B1F 03 SUB 4B20 82 DUP3 4B21 52 MSTORE 4B22 60 PUSH1 0x21 4B24 81 DUP2 4B25 52 MSTORE 4B26 60 PUSH1 0x20 4B28 01 ADD 4B29 80 DUP1 4B2A 61 PUSH2 0x5698 4B2D 60 PUSH1 0x21 4B2F 91 SWAP2 4B30 39 CODECOPY 4B31 60 PUSH1 0x40 4B33 01 ADD 4B34 91 SWAP2 4B35 50 POP 4B36 50 POP 4B37 60 PUSH1 0x40 4B39 51 MLOAD 4B3A 80 DUP1 4B3B 91 SWAP2 4B3C 03 SUB 4B3D 90 SWAP1 4B3E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4B14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4B21 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @4B25 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @4B30 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x5698:0x56b9] // @4B3E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_4B3F: // Incoming call from 0x31DE, returns to 0x1A50 // Incoming jump from 0x3A78 // Inputs[7] // { // @4B42 storage[0x97] // @4B46 memory[0x40:0x60] // @4B59 stack[-3] // @4B61 stack[-2] // @4B6D stack[-1] // @4B71 memory[0x40:0x60] // @4B90 address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } 4B3F 5B JUMPDEST 4B40 60 PUSH1 0x97 4B42 54 SLOAD 4B43 60 PUSH1 0x40 4B45 80 DUP1 4B46 51 MLOAD 4B47 63 PUSH4 0xbcdd6121 4B4C 60 PUSH1 0xe0 4B4E 1B SHL 4B4F 81 DUP2 4B50 52 MSTORE 4B51 60 PUSH1 0x01 4B53 60 PUSH1 0x01 4B55 60 PUSH1 0xa0 4B57 1B SHL 4B58 03 SUB 4B59 86 DUP7 4B5A 81 DUP2 4B5B 16 AND 4B5C 60 PUSH1 0x04 4B5E 83 DUP4 4B5F 01 ADD 4B60 52 MSTORE 4B61 85 DUP6 4B62 81 DUP2 4B63 16 AND 4B64 60 PUSH1 0x24 4B66 83 DUP4 4B67 01 ADD 4B68 52 MSTORE 4B69 60 PUSH1 0x44 4B6B 82 DUP3 4B6C 01 ADD 4B6D 85 DUP6 4B6E 90 SWAP1 4B6F 52 MSTORE 4B70 91 SWAP2 4B71 51 MLOAD 4B72 91 SWAP2 4B73 90 SWAP1 4B74 92 SWAP3 4B75 16 AND 4B76 91 SWAP2 4B77 63 PUSH4 0xbcdd6121 4B7C 91 SWAP2 4B7D 60 PUSH1 0x64 4B7F 80 DUP1 4B80 83 DUP4 4B81 01 ADD 4B82 92 SWAP3 4B83 60 PUSH1 0x00 4B85 92 SWAP3 4B86 91 SWAP2 4B87 90 SWAP1 4B88 82 DUP3 4B89 90 SWAP1 4B8A 03 SUB 4B8B 01 ADD 4B8C 81 DUP2 4B8D 83 DUP4 4B8E 87 DUP8 4B8F 80 DUP1 4B90 3B EXTCODESIZE 4B91 15 ISZERO 4B92 80 DUP1 4B93 15 ISZERO 4B94 61 PUSH2 0x4805 4B97 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @4B50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xbcdd6121 << 0xe0 // @4B60 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @4B68 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @4B6F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @4B76 stack[0] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @4B7C stack[1] = 0xbcdd6121 // @4B82 stack[2] = memory[0x40:0x60] + 0x64 // @4B85 stack[3] = 0x00 // @4B86 stack[4] = memory[0x40:0x60] // @4B8B stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @4B8C stack[6] = memory[0x40:0x60] // @4B8D stack[7] = 0x00 // @4B8E stack[8] = storage[0x97] & (0x01 << 0xa0) - 0x01 // @4B91 stack[9] = !address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x4805, if !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length label_4B98: // Incoming jump from 0x4B97, if not !!address(storage[0x97] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @4B9B memory[0x00:0x00] } 4B98 60 PUSH1 0x00 4B9A 80 DUP1 4B9B FD *REVERT // Stack delta = +0 // Outputs[1] { @4B9B revert(memory[0x00:0x00]); } // Block terminates label_4B9C: // Incoming jump from 0x35A4 // Incoming call from 0x36E4, returns to 0x36E5 // Inputs[2] // { // @4B9F stack[-2] // @4BA0 stack[-1] // } 4B9C 5B JUMPDEST 4B9D 60 PUSH1 0x00 4B9F 82 DUP3 4BA0 82 DUP3 4BA1 01 ADD 4BA2 83 DUP4 4BA3 81 DUP2 4BA4 10 LT 4BA5 15 ISZERO 4BA6 61 PUSH2 0x4adf 4BA9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @4B9D stack[0] = 0x00 // @4BA1 stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x4adf, if !(stack[-1] + stack[-2] < stack[-2]) label_4BAA: // Incoming jump from 0x4BA9, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @4BAD memory[0x40:0x60] // @4BEC memory[0x40:0x60] // @4BF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4BAA 60 PUSH1 0x40 4BAC 80 DUP1 4BAD 51 MLOAD 4BAE 62 PUSH3 0x461bcd 4BB2 60 PUSH1 0xe5 4BB4 1B SHL 4BB5 81 DUP2 4BB6 52 MSTORE 4BB7 60 PUSH1 0x20 4BB9 60 PUSH1 0x04 4BBB 82 DUP3 4BBC 01 ADD 4BBD 52 MSTORE 4BBE 60 PUSH1 0x1b 4BC0 60 PUSH1 0x24 4BC2 82 DUP3 4BC3 01 ADD 4BC4 52 MSTORE 4BC5 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 4BE6 60 PUSH1 0x44 4BE8 82 DUP3 4BE9 01 ADD 4BEA 52 MSTORE 4BEB 90 SWAP1 4BEC 51 MLOAD 4BED 90 SWAP1 4BEE 81 DUP2 4BEF 90 SWAP1 4BF0 03 SUB 4BF1 60 PUSH1 0x64 4BF3 01 ADD 4BF4 90 SWAP1 4BF5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4BB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4BBD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4BC4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @4BEA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @4BF5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4BF6: // Incoming call from 0x389A, returns to 0x389B // Inputs[4] // { // @4BF9 storage[0x97] // @4BFD memory[0x40:0x60] // @4C09 memory[0x40:0x60] // @4C30 address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // } 4BF6 5B JUMPDEST 4BF7 60 PUSH1 0x97 4BF9 54 SLOAD 4BFA 60 PUSH1 0x40 4BFC 80 DUP1 4BFD 51 MLOAD 4BFE 63 PUSH4 0x06fdde03 4C03 60 PUSH1 0xe0 4C05 1B SHL 4C06 81 DUP2 4C07 52 MSTORE 4C08 90 SWAP1 4C09 51 MLOAD 4C0A 61 PUSH2 0x4d40 4C0D 92 SWAP3 4C0E 60 PUSH1 0x01 4C10 60 PUSH1 0x01 4C12 60 PUSH1 0xa0 4C14 1B SHL 4C15 03 SUB 4C16 16 AND 4C17 91 SWAP2 4C18 63 PUSH4 0x06fdde03 4C1D 91 SWAP2 4C1E 60 PUSH1 0x04 4C20 80 DUP1 4C21 83 DUP4 4C22 01 ADD 4C23 92 SWAP3 4C24 60 PUSH1 0x00 4C26 92 SWAP3 4C27 91 SWAP2 4C28 90 SWAP1 4C29 82 DUP3 4C2A 90 SWAP1 4C2B 03 SUB 4C2C 01 ADD 4C2D 81 DUP2 4C2E 86 DUP7 4C2F 80 DUP1 4C30 3B EXTCODESIZE 4C31 15 ISZERO 4C32 80 DUP1 4C33 15 ISZERO 4C34 61 PUSH2 0x4c3c 4C37 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @4C07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x06fdde03 << 0xe0 // @4C0D stack[0] = 0x4d40 // @4C17 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @4C1D stack[2] = 0x06fdde03 // @4C23 stack[3] = memory[0x40:0x60] + 0x04 // @4C26 stack[4] = 0x00 // @4C27 stack[5] = memory[0x40:0x60] // @4C2C stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @4C2D stack[7] = memory[0x40:0x60] // @4C2E stack[8] = (0x01 << 0xa0) - 0x01 & storage[0x97] // @4C31 stack[9] = !address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // } // Block ends with conditional call to 0x4c3c, returns to 0x4D40, if !!address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length label_4C38: // Incoming jump from 0x4C37, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // Inputs[1] { @4C3B memory[0x00:0x00] } 4C38 60 PUSH1 0x00 4C3A 80 DUP1 4C3B FD *REVERT // Stack delta = +0 // Outputs[1] { @4C3B revert(memory[0x00:0x00]); } // Block terminates label_4C3C: // Incoming call from 0x4C37, returns to 0x4D40, if !!address((0x01 << 0xa0) - 0x01 & storage[0x97]).code.length // Inputs[8] // { // @4C3E msg.gas // @4C3F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @4C3F stack[-5] // @4C3F memory[stack[-3]:stack[-3] + stack[-4]] // @4C3F stack[-3] // @4C3F stack[-6] // @4C3F stack[-4] // @4C3F stack[-2] // } 4C3C 5B JUMPDEST 4C3D 50 POP 4C3E 5A GAS 4C3F FA STATICCALL 4C40 15 ISZERO 4C41 80 DUP1 4C42 15 ISZERO 4C43 61 PUSH2 0x4c50 4C46 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @4C3F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @4C40 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x4c50, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_4C47: // Incoming jump from 0x4C46, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @4C47 returndata.length // @4C4B returndata[0x00:0x00 + returndata.length] // @4C4C returndata.length // @4C4F memory[0x00:0x00 + returndata.length] // } 4C47 3D RETURNDATASIZE 4C48 60 PUSH1 0x00 4C4A 80 DUP1 4C4B 3E RETURNDATACOPY 4C4C 3D RETURNDATASIZE 4C4D 60 PUSH1 0x00 4C4F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4C4B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4C4F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4C50: // Incoming jump from 0x4C46, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @4C57 memory[0x40:0x60] // @4C58 returndata.length // @4C5C returndata[0x00:0x00 + returndata.length] // @4C5F returndata.length // } 4C50 5B JUMPDEST 4C51 50 POP 4C52 50 POP 4C53 50 POP 4C54 50 POP 4C55 60 PUSH1 0x40 4C57 51 MLOAD 4C58 3D RETURNDATASIZE 4C59 60 PUSH1 0x00 4C5B 82 DUP3 4C5C 3E RETURNDATACOPY 4C5D 60 PUSH1 0x1f 4C5F 3D RETURNDATASIZE 4C60 90 SWAP1 4C61 81 DUP2 4C62 01 ADD 4C63 60 PUSH1 0x1f 4C65 19 NOT 4C66 16 AND 4C67 82 DUP3 4C68 01 ADD 4C69 60 PUSH1 0x40 4C6B 52 MSTORE 4C6C 60 PUSH1 0x20 4C6E 81 DUP2 4C6F 10 LT 4C70 15 ISZERO 4C71 61 PUSH2 0x4c79 4C74 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @4C57 stack[-4] = memory[0x40:0x60] // @4C5C memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4C60 stack[-3] = returndata.length // @4C6B memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // } // Block ends with conditional jump to 0x4c79, if !(returndata.length < 0x20) label_4C75: // Incoming jump from 0x4C74, if not !(returndata.length < 0x20) // Inputs[1] { @4C78 memory[0x00:0x00] } 4C75 60 PUSH1 0x00 4C77 80 DUP1 4C78 FD *REVERT // Stack delta = +0 // Outputs[1] { @4C78 revert(memory[0x00:0x00]); } // Block terminates label_4C79: // Incoming jump from 0x4C74, if !(returndata.length < 0x20) // Inputs[4] // { // @4C7A stack[-2] // @4C7B stack[-1] // @4C7F memory[stack[-2]:stack[-2] + 0x20] // @4C82 memory[0x40:0x60] // } 4C79 5B JUMPDEST 4C7A 81 DUP2 4C7B 01 ADD 4C7C 90 SWAP1 4C7D 80 DUP1 4C7E 80 DUP1 4C7F 51 MLOAD 4C80 60 PUSH1 0x40 4C82 51 MLOAD 4C83 93 SWAP4 4C84 92 SWAP3 4C85 91 SWAP2 4C86 90 SWAP1 4C87 84 DUP5 4C88 60 PUSH1 0x01 4C8A 60 PUSH1 0x20 4C8C 1B SHL 4C8D 82 DUP3 4C8E 11 GT 4C8F 15 ISZERO 4C90 61 PUSH2 0x4c98 4C93 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @4C83 stack[-2] = memory[0x40:0x60] // @4C84 stack[-1] = stack[-2] + stack[-1] // @4C85 stack[0] = stack[-2] // @4C86 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @4C86 stack[1] = stack[-2] // @4C87 stack[3] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x4c98, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_4C94: // Incoming jump from 0x4C93, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @4C97 memory[0x00:0x00] } 4C94 60 PUSH1 0x00 4C96 80 DUP1 4C97 FD *REVERT // Stack delta = +0 // Outputs[1] { @4C97 revert(memory[0x00:0x00]); } // Block terminates label_4C98: // Incoming jump from 0x4C93, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[4] // { // @4C99 stack[-1] // @4C99 stack[-2] // @4C9A stack[-4] // @4CA1 stack[-5] // } 4C98 5B JUMPDEST 4C99 90 SWAP1 4C9A 83 DUP4 4C9B 01 ADD 4C9C 90 SWAP1 4C9D 60 PUSH1 0x20 4C9F 82 DUP3 4CA0 01 ADD 4CA1 85 DUP6 4CA2 81 DUP2 4CA3 11 GT 4CA4 15 ISZERO 4CA5 61 PUSH2 0x4cad 4CA8 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @4C9C stack[-2] = stack[-4] + stack[-2] // @4C9C stack[-1] = stack[-1] // @4CA0 stack[0] = stack[-4] + stack[-2] + 0x20 // } // Block ends with conditional jump to 0x4cad, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_4CA9: // Incoming jump from 0x4CA8, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @4CAC memory[0x00:0x00] } 4CA9 60 PUSH1 0x00 4CAB 80 DUP1 4CAC FD *REVERT // Stack delta = +0 // Outputs[1] { @4CAC revert(memory[0x00:0x00]); } // Block terminates label_4CAD: // Incoming jump from 0x4CA8, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[4] // { // @4CAE stack[-3] // @4CAF memory[stack[-3]:stack[-3] + 0x20] // @4CB7 stack[-1] // @4CBA stack[-6] // } 4CAD 5B JUMPDEST 4CAE 82 DUP3 4CAF 51 MLOAD 4CB0 60 PUSH1 0x01 4CB2 60 PUSH1 0x20 4CB4 1B SHL 4CB5 81 DUP2 4CB6 11 GT 4CB7 82 DUP3 4CB8 82 DUP3 4CB9 01 ADD 4CBA 88 DUP9 4CBB 10 LT 4CBC 17 OR 4CBD 15 ISZERO 4CBE 61 PUSH2 0x4cc6 4CC1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4CAF stack[0] = memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x4cc6, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) label_4CC2: // Incoming jump from 0x4CC1, if not !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[1] { @4CC5 memory[0x00:0x00] } 4CC2 60 PUSH1 0x00 4CC4 80 DUP1 4CC5 FD *REVERT // Stack delta = +0 // Outputs[1] { @4CC5 revert(memory[0x00:0x00]); } // Block terminates label_4CC6: // Incoming jump from 0x4CC1, if !((stack[-6] < memory[stack[-3]:stack[-3] + 0x20] + stack[-1]) | (memory[stack[-3]:stack[-3] + 0x20] > 0x01 << 0x20)) // Inputs[4] // { // @4CC7 stack[-3] // @4CC8 stack[-1] // @4CCA stack[-4] // @4CCB memory[stack[-4]:stack[-4] + 0x20] // } 4CC6 5B JUMPDEST 4CC7 82 DUP3 4CC8 52 MSTORE 4CC9 50 POP 4CCA 81 DUP2 4CCB 51 MLOAD 4CCC 60 PUSH1 0x20 4CCE 91 SWAP2 4CCF 82 DUP3 4CD0 01 ADD 4CD1 92 SWAP3 4CD2 90 SWAP1 4CD3 91 SWAP2 4CD4 01 ADD 4CD5 90 SWAP1 4CD6 80 DUP1 4CD7 83 DUP4 4CD8 83 DUP4 4CD9 60 PUSH1 0x00 4CDB 5B JUMPDEST 4CDC 83 DUP4 4CDD 81 DUP2 4CDE 10 LT 4CDF 15 ISZERO 4CE0 61 PUSH2 0x4cf3 4CE3 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @4CC8 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @4CD1 stack[-4] = 0x20 + stack[-3] // @4CD5 stack[-2] = memory[stack[-4]:stack[-4] + 0x20] // @4CD5 stack[-3] = 0x20 + stack[-4] // @4CD6 stack[-1] = memory[stack[-4]:stack[-4] + 0x20] // @4CD7 stack[0] = 0x20 + stack[-3] // @4CD8 stack[1] = 0x20 + stack[-4] // @4CD9 stack[2] = 0x00 // } // Block ends with conditional jump to 0x4cf3, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_4CE4: // Incoming jump from 0x4CE3, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x4CE3, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @4CE4 stack[-2] // @4CE5 stack[-1] // @4CE7 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @4CE8 stack[-3] // } 4CE4 81 DUP2 4CE5 81 DUP2 4CE6 01 ADD 4CE7 51 MLOAD 4CE8 83 DUP4 4CE9 82 DUP3 4CEA 01 ADD 4CEB 52 MSTORE 4CEC 60 PUSH1 0x20 4CEE 01 ADD 4CEF 61 PUSH2 0x4cdb 4CF2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @4CEB memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @4CEE stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x4cdb label_4CF3: // Incoming jump from 0x4CE3, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x4CE3, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @4CF8 stack[-5] // @4CF8 stack[-6] // @4CFA stack[-7] // } 4CF3 5B JUMPDEST 4CF4 50 POP 4CF5 50 POP 4CF6 50 POP 4CF7 50 POP 4CF8 90 SWAP1 4CF9 50 POP 4CFA 90 SWAP1 4CFB 81 DUP2 4CFC 01 ADD 4CFD 90 SWAP1 4CFE 60 PUSH1 0x1f 4D00 16 AND 4D01 80 DUP1 4D02 15 ISZERO 4D03 61 PUSH2 0x4d20 4D06 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @4CFD stack[-7] = stack[-5] + stack[-7] // @4D00 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x4d20, if !(0x1f & stack[-5]) label_4D07: // Incoming jump from 0x4D06, if not !(0x1f & stack[-5]) // Inputs[5] // { // @4D07 stack[-1] // @4D08 stack[-2] // @4D0B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @4D37 stack[-5] // @4D3C stack[-4] // } 4D07 80 DUP1 4D08 82 DUP3 4D09 03 SUB 4D0A 80 DUP1 4D0B 51 MLOAD 4D0C 60 PUSH1 0x01 4D0E 83 DUP4 4D0F 60 PUSH1 0x20 4D11 03 SUB 4D12 61 PUSH2 0x0100 4D15 0A EXP 4D16 03 SUB 4D17 19 NOT 4D18 16 AND 4D19 81 DUP2 4D1A 52 MSTORE 4D1B 60 PUSH1 0x20 4D1D 01 ADD 4D1E 91 SWAP2 4D1F 50 POP 4D20 5B JUMPDEST 4D21 50 POP 4D22 60 PUSH1 0x40 4D24 81 DUP2 4D25 81 DUP2 4D26 01 ADD 4D27 90 SWAP1 4D28 52 MSTORE 4D29 60 PUSH1 0x01 4D2B 81 DUP2 4D2C 52 MSTORE 4D2D 60 PUSH1 0x19 4D2F 60 PUSH1 0xf9 4D31 1B SHL 4D32 60 PUSH1 0x20 4D34 82 DUP3 4D35 01 ADD 4D36 52 MSTORE 4D37 92 SWAP3 4D38 50 POP 4D39 61 PUSH2 0x5275 4D3C 91 SWAP2 4D3D 50 POP 4D3E 50 POP 4D3F 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @4D1A memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @4D28 memory[0x40:0x60] = 0x40 + 0x20 + (stack[-2] - stack[-1]) // @4D2C memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = 0x01 // @4D36 memory[0x20 + (stack[-2] - stack[-1]) + 0x20:0x20 + (stack[-2] - stack[-1]) + 0x20 + 0x20] = 0x19 << 0xf9 // @4D37 stack[-5] = 0x20 + (stack[-2] - stack[-1]) // } // Block ends with unconditional jump to 0x5275 label_4D40: // Incoming return from call to 0x4C3C at 0x4C37 // Inputs[2] // { // @4D44 stack[-1] // @4D45 stack[-2] // } 4D40 5B JUMPDEST 4D41 61 PUSH2 0x0105 4D44 55 SSTORE 4D45 56 *JUMP // Stack delta = -2 // Outputs[1] { @4D44 storage[0x0105] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_4D46: // Incoming jump from 0x434C // Incoming jump from 0x434C // Inputs[1] { @4D49 storage[0x00] } 4D46 5B JUMPDEST 4D47 60 PUSH1 0x00 4D49 54 SLOAD 4D4A 61 PUSH2 0x0100 4D4D 90 SWAP1 4D4E 04 DIV 4D4F 60 PUSH1 0xff 4D51 16 AND 4D52 80 DUP1 4D53 61 PUSH2 0x4d5f 4D56 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4D51 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x4d5f, if 0xff & storage[0x00] / 0x0100 label_4D57: // Incoming jump from 0x4D56, if not 0xff & storage[0x00] / 0x0100 4D57 50 POP 4D58 61 PUSH2 0x4d5f 4D5B 61 PUSH2 0x48ef 4D5E 56 *JUMP // Stack delta = +0 // Outputs[1] { @4D58 stack[-1] = 0x4d5f } // Block ends with call to 0x48ef, returns to 0x4D5F label_4D5F: // Incoming return from call to 0x48EF at 0x4D5E // Incoming jump from 0x4D56, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @4D60 stack[-1] } 4D5F 5B JUMPDEST 4D60 80 DUP1 4D61 61 PUSH2 0x4d6d 4D64 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4d6d, if stack[-1] label_4D65: // Incoming jump from 0x4D64, if not stack[-1] // Inputs[1] { @4D68 storage[0x00] } 4D65 50 POP 4D66 60 PUSH1 0x00 4D68 54 SLOAD 4D69 60 PUSH1 0xff 4D6B 16 AND 4D6C 15 ISZERO 4D6D 5B JUMPDEST 4D6E 61 PUSH2 0x4da8 4D71 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4da8, if !(0xff & storage[0x00]) label_4D72: // Incoming jump from 0x4D71, if not stack[-1] // Incoming jump from 0x4D71, if not !(0xff & storage[0x00]) // Inputs[3] // { // @4D74 memory[0x40:0x60] // @4DA2 memory[0x40:0x60] // @4DA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 4D72 60 PUSH1 0x40 4D74 51 MLOAD 4D75 62 PUSH3 0x461bcd 4D79 60 PUSH1 0xe5 4D7B 1B SHL 4D7C 81 DUP2 4D7D 52 MSTORE 4D7E 60 PUSH1 0x04 4D80 01 ADD 4D81 80 DUP1 4D82 80 DUP1 4D83 60 PUSH1 0x20 4D85 01 ADD 4D86 82 DUP3 4D87 81 DUP2 4D88 03 SUB 4D89 82 DUP3 4D8A 52 MSTORE 4D8B 60 PUSH1 0x2e 4D8D 81 DUP2 4D8E 52 MSTORE 4D8F 60 PUSH1 0x20 4D91 01 ADD 4D92 80 DUP1 4D93 61 PUSH2 0x56fb 4D96 60 PUSH1 0x2e 4D98 91 SWAP2 4D99 39 CODECOPY 4D9A 60 PUSH1 0x40 4D9C 01 ADD 4D9D 91 SWAP2 4D9E 50 POP 4D9F 50 POP 4DA0 60 PUSH1 0x40 4DA2 51 MLOAD 4DA3 80 DUP1 4DA4 91 SWAP2 4DA5 03 SUB 4DA6 90 SWAP1 4DA7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4D7D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4D8A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @4D8E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @4D99 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x56fb:0x5729] // @4DA7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_4DA8: // Incoming jump from 0x4D71, if stack[-1] // Incoming jump from 0x4D71, if !(0xff & storage[0x00]) // Inputs[1] { @4DAB storage[0x00] } 4DA8 5B JUMPDEST 4DA9 60 PUSH1 0x00 4DAB 54 SLOAD 4DAC 61 PUSH2 0x0100 4DAF 90 SWAP1 4DB0 04 DIV 4DB1 60 PUSH1 0xff 4DB3 16 AND 4DB4 15 ISZERO 4DB5 80 DUP1 4DB6 15 ISZERO 4DB7 61 PUSH2 0x4dd3 4DBA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4DB4 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x4dd3, if !!(0xff & storage[0x00] / 0x0100) label_4DBB: // Incoming jump from 0x4DBA, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[3] // { // @4DBE storage[0x00] // @4DD7 stack[-7] // @4DD8 stack[-6] // } 4DBB 60 PUSH1 0x00 4DBD 80 DUP1 4DBE 54 SLOAD 4DBF 60 PUSH1 0xff 4DC1 19 NOT 4DC2 61 PUSH2 0xff00 4DC5 19 NOT 4DC6 90 SWAP1 4DC7 91 SWAP2 4DC8 16 AND 4DC9 61 PUSH2 0x0100 4DCC 17 OR 4DCD 16 AND 4DCE 60 PUSH1 0x01 4DD0 17 OR 4DD1 90 SWAP1 4DD2 55 SSTORE 4DD3 5B JUMPDEST 4DD4 61 PUSH2 0x4ddd 4DD7 87 DUP8 4DD8 87 DUP8 4DD9 61 PUSH2 0x20e3 4DDC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4DD2 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @4DD4 stack[0] = 0x4ddd // @4DD7 stack[1] = stack[-7] // @4DD8 stack[2] = stack[-6] // } // Block ends with unconditional jump to 0x20e3 4DDD 5B JUMPDEST 4DDE 85 DUP6 4DDF 60 PUSH1 0x01 4DE1 60 PUSH1 0x01 4DE3 60 PUSH1 0xa0 4DE5 1B SHL 4DE6 03 SUB 4DE7 16 AND 4DE8 63 PUSH4 0xb3f90e0a 4DED 86 DUP7 4DEE 86 DUP7 4DEF 86 DUP7 4DF0 60 PUSH1 0x40 4DF2 51 MLOAD 4DF3 84 DUP5 4DF4 63 PUSH4 0xffffffff 4DF9 16 AND 4DFA 60 PUSH1 0xe0 4DFC 1B SHL 4DFD 81 DUP2 4DFE 52 MSTORE 4DFF 60 PUSH1 0x04 4E01 01 ADD 4E02 80 DUP1 4E03 80 DUP1 4E04 60 PUSH1 0x20 4E06 01 ADD 4E07 80 DUP1 4E08 60 PUSH1 0x20 4E0A 01 ADD 4E0B 84 DUP5 4E0C 60 PUSH1 0xff 4E0E 16 AND 4E0F 60 PUSH1 0xff 4E11 16 AND 4E12 81 DUP2 4E13 52 MSTORE 4E14 60 PUSH1 0x20 4E16 01 ADD 4E17 83 DUP4 4E18 81 DUP2 4E19 03 SUB 4E1A 83 DUP4 4E1B 52 MSTORE 4E1C 86 DUP7 4E1D 81 DUP2 4E1E 81 DUP2 4E1F 51 MLOAD 4E20 81 DUP2 4E21 52 MSTORE 4E22 60 PUSH1 0x20 4E24 01 ADD 4E25 91 SWAP2 4E26 50 POP 4E27 80 DUP1 4E28 51 MLOAD 4E29 90 SWAP1 4E2A 60 PUSH1 0x20 4E2C 01 ADD 4E2D 90 SWAP1 4E2E 80 DUP1 4E2F 83 DUP4 4E30 83 DUP4 4E31 60 PUSH1 0x00 4E33 5B JUMPDEST 4E34 83 DUP4 4E35 81 DUP2 4E36 10 LT 4E37 15 ISZERO 4E38 61 PUSH2 0x4e4b 4E3B 57 *JUMPI 4E3C 81 DUP2 4E3D 81 DUP2 4E3E 01 ADD 4E3F 51 MLOAD 4E40 83 DUP4 4E41 82 DUP3 4E42 01 ADD 4E43 52 MSTORE 4E44 60 PUSH1 0x20 4E46 01 ADD 4E47 61 PUSH2 0x4e33 4E4A 56 *JUMP 4E4B 5B JUMPDEST 4E4C 50 POP 4E4D 50 POP 4E4E 50 POP 4E4F 50 POP 4E50 90 SWAP1 4E51 50 POP 4E52 90 SWAP1 4E53 81 DUP2 4E54 01 ADD 4E55 90 SWAP1 4E56 60 PUSH1 0x1f 4E58 16 AND 4E59 80 DUP1 4E5A 15 ISZERO 4E5B 61 PUSH2 0x4e78 4E5E 57 *JUMPI 4E5F 80 DUP1 4E60 82 DUP3 4E61 03 SUB 4E62 80 DUP1 4E63 51 MLOAD 4E64 60 PUSH1 0x01 4E66 83 DUP4 4E67 60 PUSH1 0x20 4E69 03 SUB 4E6A 61 PUSH2 0x0100 4E6D 0A EXP 4E6E 03 SUB 4E6F 19 NOT 4E70 16 AND 4E71 81 DUP2 4E72 52 MSTORE 4E73 60 PUSH1 0x20 4E75 01 ADD 4E76 91 SWAP2 4E77 50 POP 4E78 5B JUMPDEST 4E79 50 POP 4E7A 83 DUP4 4E7B 81 DUP2 4E7C 03 SUB 4E7D 82 DUP3 4E7E 52 MSTORE 4E7F 85 DUP6 4E80 51 MLOAD 4E81 81 DUP2 4E82 52 MSTORE 4E83 85 DUP6 4E84 51 MLOAD 4E85 60 PUSH1 0x20 4E87 91 SWAP2 4E88 82 DUP3 4E89 01 ADD 4E8A 91 SWAP2 4E8B 87 DUP8 4E8C 01 ADD 4E8D 90 SWAP1 4E8E 80 DUP1 4E8F 83 DUP4 4E90 83 DUP4 4E91 60 PUSH1 0x00 4E93 5B JUMPDEST 4E94 83 DUP4 4E95 81 DUP2 4E96 10 LT 4E97 15 ISZERO 4E98 61 PUSH2 0x4eab 4E9B 57 *JUMPI 4E9C 81 DUP2 4E9D 81 DUP2 4E9E 01 ADD 4E9F 51 MLOAD 4EA0 83 DUP4 4EA1 82 DUP3 4EA2 01 ADD 4EA3 52 MSTORE 4EA4 60 PUSH1 0x20 4EA6 01 ADD 4EA7 61 PUSH2 0x4e93 4EAA 56 *JUMP 4EAB 5B JUMPDEST 4EAC 50 POP 4EAD 50 POP 4EAE 50 POP 4EAF 50 POP 4EB0 90 SWAP1 4EB1 50 POP 4EB2 90 SWAP1 4EB3 81 DUP2 4EB4 01 ADD 4EB5 90 SWAP1 4EB6 60 PUSH1 0x1f 4EB8 16 AND 4EB9 80 DUP1 4EBA 15 ISZERO 4EBB 61 PUSH2 0x4ed8 4EBE 57 *JUMPI 4EBF 80 DUP1 4EC0 82 DUP3 4EC1 03 SUB 4EC2 80 DUP1 4EC3 51 MLOAD 4EC4 60 PUSH1 0x01 4EC6 83 DUP4 4EC7 60 PUSH1 0x20 4EC9 03 SUB 4ECA 61 PUSH2 0x0100 4ECD 0A EXP 4ECE 03 SUB 4ECF 19 NOT 4ED0 16 AND 4ED1 81 DUP2 4ED2 52 MSTORE 4ED3 60 PUSH1 0x20 4ED5 01 ADD 4ED6 91 SWAP2 4ED7 50 POP 4ED8 5B JUMPDEST 4ED9 50 POP 4EDA 95 SWAP6 4EDB 50 POP 4EDC 50 POP 4EDD 50 POP 4EDE 50 POP 4EDF 50 POP 4EE0 50 POP 4EE1 60 PUSH1 0x00 4EE3 60 PUSH1 0x40 4EE5 51 MLOAD 4EE6 80 DUP1 4EE7 83 DUP4 4EE8 03 SUB 4EE9 81 DUP2 4EEA 60 PUSH1 0x00 4EEC 87 DUP8 4EED 80 DUP1 4EEE 3B EXTCODESIZE 4EEF 15 ISZERO 4EF0 80 DUP1 4EF1 15 ISZERO 4EF2 61 PUSH2 0x4efa 4EF5 57 *JUMPI 4EF6 60 PUSH1 0x00 4EF8 80 DUP1 4EF9 FD *REVERT 4EFA 5B JUMPDEST 4EFB 50 POP 4EFC 5A GAS 4EFD F1 CALL 4EFE 15 ISZERO 4EFF 80 DUP1 4F00 15 ISZERO 4F01 61 PUSH2 0x4f0e 4F04 57 *JUMPI 4F05 3D RETURNDATASIZE 4F06 60 PUSH1 0x00 4F08 80 DUP1 4F09 3E RETURNDATACOPY 4F0A 3D RETURNDATASIZE 4F0B 60 PUSH1 0x00 4F0D FD *REVERT 4F0E 5B JUMPDEST 4F0F 50 POP 4F10 50 POP 4F11 83 DUP4 4F12 51 MLOAD 4F13 61 PUSH2 0x4f25 4F16 92 SWAP3 4F17 50 POP 4F18 60 PUSH1 0x9a 4F1A 91 SWAP2 4F1B 50 POP 4F1C 60 PUSH1 0x20 4F1E 85 DUP6 4F1F 01 ADD 4F20 90 SWAP1 4F21 61 PUSH2 0x5597 4F24 56 *JUMP 4F25 5B JUMPDEST 4F26 50 POP 4F27 7F PUSH32 0x57c55be0f3a533db430bb8586b26f0e2efa5afdd84b6657634863b9115cb63f8 4F48 82 DUP3 4F49 60 PUSH1 0x40 4F4B 51 MLOAD 4F4C 80 DUP1 4F4D 80 DUP1 4F4E 60 PUSH1 0x20 4F50 01 ADD 4F51 82 DUP3 4F52 81 DUP2 4F53 03 SUB 4F54 82 DUP3 4F55 52 MSTORE 4F56 83 DUP4 4F57 81 DUP2 4F58 81 DUP2 4F59 51 MLOAD 4F5A 81 DUP2 4F5B 52 MSTORE 4F5C 60 PUSH1 0x20 4F5E 01 ADD 4F5F 91 SWAP2 4F60 50 POP 4F61 80 DUP1 4F62 51 MLOAD 4F63 90 SWAP1 4F64 60 PUSH1 0x20 4F66 01 ADD 4F67 90 SWAP1 4F68 60 PUSH1 0x20 4F6A 02 MUL 4F6B 80 DUP1 4F6C 83 DUP4 4F6D 83 DUP4 4F6E 60 PUSH1 0x00 4F70 5B JUMPDEST 4F71 83 DUP4 4F72 81 DUP2 4F73 10 LT 4F74 15 ISZERO 4F75 61 PUSH2 0x4f88 4F78 57 *JUMPI 4F79 81 DUP2 4F7A 81 DUP2 4F7B 01 ADD 4F7C 51 MLOAD 4F7D 83 DUP4 4F7E 82 DUP3 4F7F 01 ADD 4F80 52 MSTORE 4F81 60 PUSH1 0x20 4F83 01 ADD 4F84 61 PUSH2 0x4f70 4F87 56 *JUMP 4F88 5B JUMPDEST 4F89 50 POP 4F8A 50 POP 4F8B 50 POP 4F8C 50 POP 4F8D 90 SWAP1 4F8E 50 POP 4F8F 01 ADD 4F90 92 SWAP3 4F91 50 POP 4F92 50 POP 4F93 50 POP 4F94 60 PUSH1 0x40 4F96 51 MLOAD 4F97 80 DUP1 4F98 91 SWAP2 4F99 03 SUB 4F9A 90 SWAP1 4F9B A1 LOG1 4F9C 61 PUSH2 0x434d 4F9F 61 PUSH2 0x4bf6 4FA2 56 *JUMP label_4FA3: // Incoming call from 0x4741, returns to 0x4742 // Inputs[1] { @4FC7 stack[-1] } 4FA3 5B JUMPDEST 4FA4 60 PUSH1 0x00 4FA6 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 4FC7 82 DUP3 4FC8 11 GT 4FC9 15 ISZERO 4FCA 61 PUSH2 0x5004 4FCD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4FA4 stack[0] = 0x00 } // Block ends with conditional jump to 0x5004, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) label_4FCE: // Incoming jump from 0x4FCD, if not !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[3] // { // @4FD0 memory[0x40:0x60] // @4FFE memory[0x40:0x60] // @5003 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 4FCE 60 PUSH1 0x40 4FD0 51 MLOAD 4FD1 62 PUSH3 0x461bcd 4FD5 60 PUSH1 0xe5 4FD7 1B SHL 4FD8 81 DUP2 4FD9 52 MSTORE 4FDA 60 PUSH1 0x04 4FDC 01 ADD 4FDD 80 DUP1 4FDE 80 DUP1 4FDF 60 PUSH1 0x20 4FE1 01 ADD 4FE2 82 DUP3 4FE3 81 DUP2 4FE4 03 SUB 4FE5 82 DUP3 4FE6 52 MSTORE 4FE7 60 PUSH1 0x26 4FE9 81 DUP2 4FEA 52 MSTORE 4FEB 60 PUSH1 0x20 4FED 01 ADD 4FEE 80 DUP1 4FEF 61 PUSH2 0x5749 4FF2 60 PUSH1 0x26 4FF4 91 SWAP2 4FF5 39 CODECOPY 4FF6 60 PUSH1 0x40 4FF8 01 ADD 4FF9 91 SWAP2 4FFA 50 POP 4FFB 50 POP 4FFC 60 PUSH1 0x40 4FFE 51 MLOAD 4FFF 80 DUP1 5000 91 SWAP2 5001 03 SUB 5002 90 SWAP1 5003 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4FD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @4FE6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @4FEA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @4FF5 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x5749:0x576f] // @5003 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_5004: // Incoming jump from 0x4FCD, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @5005 stack[-4] } 5004 5B JUMPDEST 5005 83 DUP4 5006 60 PUSH1 0xff 5008 16 AND 5009 60 PUSH1 0x1b 500B 14 EQ 500C 15 ISZERO 500D 80 DUP1 500E 15 ISZERO 500F 61 PUSH2 0x501c 5012 57 *JUMPI // Stack delta = +1 // Outputs[1] { @500C stack[0] = !(0x1b == 0xff & stack[-4]) } // Block ends with conditional jump to 0x501c, if !!(0x1b == 0xff & stack[-4]) label_5013: // Incoming jump from 0x5012, if not !!(0x1b == 0xff & stack[-4]) // Inputs[1] { @5014 stack[-5] } 5013 50 POP 5014 83 DUP4 5015 60 PUSH1 0xff 5017 16 AND 5018 60 PUSH1 0x1c 501A 14 EQ 501B 15 ISZERO 501C 5B JUMPDEST 501D 15 ISZERO 501E 61 PUSH2 0x5058 5021 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x5058, if !!(0x1c == 0xff & stack[-5]) label_5022: // Incoming jump from 0x5021, if not !stack[-1] // Incoming jump from 0x5021, if not !!(0x1c == 0xff & stack[-5]) // Inputs[3] // { // @5024 memory[0x40:0x60] // @5052 memory[0x40:0x60] // @5057 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 5022 60 PUSH1 0x40 5024 51 MLOAD 5025 62 PUSH3 0x461bcd 5029 60 PUSH1 0xe5 502B 1B SHL 502C 81 DUP2 502D 52 MSTORE 502E 60 PUSH1 0x04 5030 01 ADD 5031 80 DUP1 5032 80 DUP1 5033 60 PUSH1 0x20 5035 01 ADD 5036 82 DUP3 5037 81 DUP2 5038 03 SUB 5039 82 DUP3 503A 52 MSTORE 503B 60 PUSH1 0x26 503D 81 DUP2 503E 52 MSTORE 503F 60 PUSH1 0x20 5041 01 ADD 5042 80 DUP1 5043 61 PUSH2 0x562b 5046 60 PUSH1 0x26 5048 91 SWAP2 5049 39 CODECOPY 504A 60 PUSH1 0x40 504C 01 ADD 504D 91 SWAP2 504E 50 POP 504F 50 POP 5050 60 PUSH1 0x40 5052 51 MLOAD 5053 80 DUP1 5054 91 SWAP2 5055 03 SUB 5056 90 SWAP1 5057 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @502D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @503A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @503E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @5049 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x562b:0x5651] // @5057 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_5058: // Incoming jump from 0x5021, if !stack[-1] // Incoming jump from 0x5021, if !!(0x1c == 0xff & stack[-5]) // Inputs[9] // { // @505C memory[0x40:0x60] // @506A stack[-5] // @506F stack[-4] // @5079 stack[-3] // @5080 stack[-2] // @5084 memory[0x40:0x60] // @509E msg.gas // @509F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])] // @509F address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])]) // } 5058 5B JUMPDEST 5059 60 PUSH1 0x40 505B 80 DUP1 505C 51 MLOAD 505D 60 PUSH1 0x00 505F 80 DUP1 5060 82 DUP3 5061 52 MSTORE 5062 60 PUSH1 0x20 5064 80 DUP1 5065 83 DUP4 5066 01 ADD 5067 80 DUP1 5068 85 DUP6 5069 52 MSTORE 506A 89 DUP10 506B 90 SWAP1 506C 52 MSTORE 506D 60 PUSH1 0xff 506F 88 DUP9 5070 16 AND 5071 83 DUP4 5072 85 DUP6 5073 01 ADD 5074 52 MSTORE 5075 60 PUSH1 0x60 5077 83 DUP4 5078 01 ADD 5079 87 DUP8 507A 90 SWAP1 507B 52 MSTORE 507C 60 PUSH1 0x80 507E 83 DUP4 507F 01 ADD 5080 86 DUP7 5081 90 SWAP1 5082 52 MSTORE 5083 92 SWAP3 5084 51 MLOAD 5085 90 SWAP1 5086 92 SWAP3 5087 60 PUSH1 0x01 5089 92 SWAP3 508A 60 PUSH1 0xa0 508C 80 DUP1 508D 82 DUP3 508E 01 ADD 508F 93 SWAP4 5090 60 PUSH1 0x1f 5092 19 NOT 5093 81 DUP2 5094 01 ADD 5095 92 SWAP3 5096 81 DUP2 5097 90 SWAP1 5098 03 SUB 5099 90 SWAP1 509A 91 SWAP2 509B 01 ADD 509C 90 SWAP1 509D 85 DUP6 509E 5A GAS 509F FA STATICCALL 50A0 15 ISZERO 50A1 80 DUP1 50A2 15 ISZERO 50A3 61 PUSH2 0x50b0 50A6 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @5061 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @5069 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @506C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-5] // @5074 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-4] & 0xff // @507B memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-3] // @5082 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-2] // @5086 stack[0] = 0x00 // @5089 stack[1] = 0x01 // @508F stack[2] = memory[0x40:0x60] + 0xa0 // @509F memory[memory[0x40:0x60] + ~0x1f:memory[0x40:0x60] + ~0x1f + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])]) // @50A0 stack[3] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])]) // } // Block ends with conditional jump to 0x50b0, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])]) label_50A7: // Incoming jump from 0x50A6, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])]) // Inputs[4] // { // @50A7 returndata.length // @50AB returndata[0x00:0x00 + returndata.length] // @50AC returndata.length // @50AF memory[0x00:0x00 + returndata.length] // } 50A7 3D RETURNDATASIZE 50A8 60 PUSH1 0x00 50AA 80 DUP1 50AB 3E RETURNDATACOPY 50AC 3D RETURNDATASIZE 50AD 60 PUSH1 0x00 50AF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @50AB memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @50AF revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_50B0: // Incoming jump from 0x50A6, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])]) // Inputs[3] // { // @50B5 memory[0x40:0x60] // @50BA memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @50BB stack[-4] // } 50B0 5B JUMPDEST 50B1 50 POP 50B2 50 POP 50B3 60 PUSH1 0x40 50B5 51 MLOAD 50B6 60 PUSH1 0x1f 50B8 19 NOT 50B9 01 ADD 50BA 51 MLOAD 50BB 91 SWAP2 50BC 50 POP 50BD 50 POP 50BE 60 PUSH1 0x01 50C0 60 PUSH1 0x01 50C2 60 PUSH1 0xa0 50C4 1B SHL 50C5 03 SUB 50C6 81 DUP2 50C7 16 AND 50C8 61 PUSH2 0x5118 50CB 57 *JUMPI // Stack delta = -3 // Outputs[1] { @50BB stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x5118, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_50CC: // Incoming jump from 0x50CB, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @50CF memory[0x40:0x60] // @510E memory[0x40:0x60] // @5117 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 50CC 60 PUSH1 0x40 50CE 80 DUP1 50CF 51 MLOAD 50D0 62 PUSH3 0x461bcd 50D4 60 PUSH1 0xe5 50D6 1B SHL 50D7 81 DUP2 50D8 52 MSTORE 50D9 60 PUSH1 0x20 50DB 60 PUSH1 0x04 50DD 82 DUP3 50DE 01 ADD 50DF 52 MSTORE 50E0 60 PUSH1 0x1c 50E2 60 PUSH1 0x24 50E4 82 DUP3 50E5 01 ADD 50E6 52 MSTORE 50E7 7F PUSH32 0x45435265636f7665723a20696e76616c6964207369676e617475726500000000 5108 60 PUSH1 0x44 510A 82 DUP3 510B 01 ADD 510C 52 MSTORE 510D 90 SWAP1 510E 51 MLOAD 510F 90 SWAP1 5110 81 DUP2 5111 90 SWAP1 5112 03 SUB 5113 60 PUSH1 0x64 5115 01 ADD 5116 90 SWAP1 5117 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @50D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @50DF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @50E6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @510C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45435265636f7665723a20696e76616c6964207369676e617475726500000000 // @5117 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_5118: // Incoming jump from 0x50CB, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @5119 stack[-1] // @5119 stack[-7] // @511A stack[-6] // } 5118 5B JUMPDEST 5119 95 SWAP6 511A 94 SWAP5 511B 50 POP 511C 50 POP 511D 50 POP 511E 50 POP 511F 50 POP 5120 56 *JUMP // Stack delta = -6 // Outputs[1] { @5119 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_5121: // Incoming jump from 0x4989 // Incoming jump from 0x4989 // Inputs[1] { @5124 storage[0x00] } 5121 5B JUMPDEST 5122 60 PUSH1 0x00 5124 54 SLOAD 5125 61 PUSH2 0x0100 5128 90 SWAP1 5129 04 DIV 512A 60 PUSH1 0xff 512C 16 AND 512D 80 DUP1 512E 61 PUSH2 0x513a 5131 57 *JUMPI // Stack delta = +1 // Outputs[1] { @512C stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x513a, if 0xff & storage[0x00] / 0x0100 label_5132: // Incoming jump from 0x5131, if not 0xff & storage[0x00] / 0x0100 5132 50 POP 5133 61 PUSH2 0x513a 5136 61 PUSH2 0x48ef 5139 56 *JUMP // Stack delta = +0 // Outputs[1] { @5133 stack[-1] = 0x513a } // Block ends with call to 0x48ef, returns to 0x513A label_513A: // Incoming return from call to 0x48EF at 0x5139 // Incoming jump from 0x5131, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @513B stack[-1] } 513A 5B JUMPDEST 513B 80 DUP1 513C 61 PUSH2 0x5148 513F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x5148, if stack[-1] label_5140: // Incoming jump from 0x513F, if not stack[-1] // Inputs[1] { @5143 storage[0x00] } 5140 50 POP 5141 60 PUSH1 0x00 5143 54 SLOAD 5144 60 PUSH1 0xff 5146 16 AND 5147 15 ISZERO 5148 5B JUMPDEST 5149 61 PUSH2 0x5183 514C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x5183, if !(0xff & storage[0x00]) label_514D: // Incoming jump from 0x514C, if not stack[-1] // Incoming jump from 0x514C, if not !(0xff & storage[0x00]) // Inputs[3] // { // @514F memory[0x40:0x60] // @517D memory[0x40:0x60] // @5182 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 514D 60 PUSH1 0x40 514F 51 MLOAD 5150 62 PUSH3 0x461bcd 5154 60 PUSH1 0xe5 5156 1B SHL 5157 81 DUP2 5158 52 MSTORE 5159 60 PUSH1 0x04 515B 01 ADD 515C 80 DUP1 515D 80 DUP1 515E 60 PUSH1 0x20 5160 01 ADD 5161 82 DUP3 5162 81 DUP2 5163 03 SUB 5164 82 DUP3 5165 52 MSTORE 5166 60 PUSH1 0x2e 5168 81 DUP2 5169 52 MSTORE 516A 60 PUSH1 0x20 516C 01 ADD 516D 80 DUP1 516E 61 PUSH2 0x56fb 5171 60 PUSH1 0x2e 5173 91 SWAP2 5174 39 CODECOPY 5175 60 PUSH1 0x40 5177 01 ADD 5178 91 SWAP2 5179 50 POP 517A 50 POP 517B 60 PUSH1 0x40 517D 51 MLOAD 517E 80 DUP1 517F 91 SWAP2 5180 03 SUB 5181 90 SWAP1 5182 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @5158 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @5165 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @5169 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @5174 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x56fb:0x5729] // @5182 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_5183: // Incoming jump from 0x514C, if stack[-1] // Incoming jump from 0x514C, if !(0xff & storage[0x00]) // Inputs[1] { @5186 storage[0x00] } 5183 5B JUMPDEST 5184 60 PUSH1 0x00 5186 54 SLOAD 5187 61 PUSH2 0x0100 518A 90 SWAP1 518B 04 DIV 518C 60 PUSH1 0xff 518E 16 AND 518F 15 ISZERO 5190 80 DUP1 5191 15 ISZERO 5192 61 PUSH2 0x51ae 5195 57 *JUMPI // Stack delta = +1 // Outputs[1] { @518F stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x51ae, if !!(0xff & storage[0x00] / 0x0100) label_5196: // Incoming jump from 0x5195, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[1] { @5199 storage[0x00] } 5196 60 PUSH1 0x00 5198 80 DUP1 5199 54 SLOAD 519A 60 PUSH1 0xff 519C 19 NOT 519D 61 PUSH2 0xff00 51A0 19 NOT 51A1 90 SWAP1 51A2 91 SWAP2 51A3 16 AND 51A4 61 PUSH2 0x0100 51A7 17 OR 51A8 16 AND 51A9 60 PUSH1 0x01 51AB 17 OR 51AC 90 SWAP1 51AD 55 SSTORE 51AE 5B JUMPDEST 51AF 61 PUSH2 0x51b6 51B2 61 PUSH2 0x52e7 51B5 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @51AD storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @51AF stack[0] = 0x51b6 // } // Block ends with call to 0x52e7, returns to 0x51B6 label_51B6: // Incoming return from call to 0x52E7 at 0x51B5 // Incoming return from call to 0x52E7 at 0x51B5 51B6 5B JUMPDEST 51B7 61 PUSH2 0x51be 51BA 61 PUSH2 0x5387 51BD 56 *JUMP // Stack delta = +1 // Outputs[1] { @51B7 stack[0] = 0x51be } // Block ends with call to 0x5387, returns to 0x51BE label_51BE: // Incoming jump from 0x535B, if !!(0xff & storage[0x00] / 0x0100) // Incoming return from call to 0x5387 at 0x51BD // Inputs[1] { @51BF stack[-1] } 51BE 5B JUMPDEST 51BF 80 DUP1 51C0 15 ISZERO 51C1 61 PUSH2 0x51d0 51C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x51d0, if !stack[-1] label_51C5: // Incoming jump from 0x51C4, if not !stack[-1] // Inputs[2] // { // @51C8 storage[0x00] // @51D2 stack[-2] // } 51C5 60 PUSH1 0x00 51C7 80 DUP1 51C8 54 SLOAD 51C9 61 PUSH2 0xff00 51CC 19 NOT 51CD 16 AND 51CE 90 SWAP1 51CF 55 SSTORE 51D0 5B JUMPDEST 51D1 50 POP 51D2 56 *JUMP // Stack delta = -2 // Outputs[1] { @51CF storage[0x00] = ~0xff00 & storage[0x00] } // Block ends with unconditional jump to stack[-2] label_51D3: // Incoming call from 0x4ADE, returns to 0x4ADF // Inputs[2] // { // @51D6 stack[-1] // @51D7 stack[-2] // } 51D3 5B JUMPDEST 51D4 60 PUSH1 0x00 51D6 81 DUP2 51D7 83 DUP4 51D8 61 PUSH2 0x525f 51DB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @51D4 stack[0] = 0x00 // @51D6 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x525f, if stack[-2] label_51DC: // Incoming jump from 0x51DB, if not stack[-2] // Inputs[4] // { // @51DE memory[0x40:0x60] // @51F5 stack[-1] // @51F8 memory[stack[-1]:stack[-1] + 0x20] // @5201 memory[stack[-1]:stack[-1] + 0x20] // } 51DC 60 PUSH1 0x40 51DE 51 MLOAD 51DF 62 PUSH3 0x461bcd 51E3 60 PUSH1 0xe5 51E5 1B SHL 51E6 81 DUP2 51E7 52 MSTORE 51E8 60 PUSH1 0x04 51EA 01 ADD 51EB 80 DUP1 51EC 80 DUP1 51ED 60 PUSH1 0x20 51EF 01 ADD 51F0 82 DUP3 51F1 81 DUP2 51F2 03 SUB 51F3 82 DUP3 51F4 52 MSTORE 51F5 83 DUP4 51F6 81 DUP2 51F7 81 DUP2 51F8 51 MLOAD 51F9 81 DUP2 51FA 52 MSTORE 51FB 60 PUSH1 0x20 51FD 01 ADD 51FE 91 SWAP2 51FF 50 POP 5200 80 DUP1 5201 51 MLOAD 5202 90 SWAP1 5203 60 PUSH1 0x20 5205 01 ADD 5206 90 SWAP1 5207 80 DUP1 5208 83 DUP4 5209 83 DUP4 520A 60 PUSH1 0x00 520C 5B JUMPDEST 520D 83 DUP4 520E 81 DUP2 520F 10 LT 5210 15 ISZERO 5211 61 PUSH2 0x5224 5214 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @51E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @51EA stack[0] = 0x04 + memory[0x40:0x60] // @51EB stack[1] = 0x04 + memory[0x40:0x60] // @51F4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @51FA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @51FE stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @5206 stack[3] = 0x20 + stack[-1] // @5206 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @5207 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @5208 stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @5209 stack[7] = 0x20 + stack[-1] // @520A stack[8] = 0x00 // } // Block ends with conditional jump to 0x5224, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_5215: // Incoming jump from 0x5214, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x5214, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @5215 stack[-2] // @5216 stack[-1] // @5218 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @5219 stack[-3] // } 5215 81 DUP2 5216 81 DUP2 5217 01 ADD 5218 51 MLOAD 5219 83 DUP4 521A 82 DUP3 521B 01 ADD 521C 52 MSTORE 521D 60 PUSH1 0x20 521F 01 ADD 5220 61 PUSH2 0x520c 5223 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @521C memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @521F stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x520c label_5224: // Incoming jump from 0x5214, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x5214, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @5229 stack[-5] // @5229 stack[-6] // @522B stack[-7] // } 5224 5B JUMPDEST 5225 50 POP 5226 50 POP 5227 50 POP 5228 50 POP 5229 90 SWAP1 522A 50 POP 522B 90 SWAP1 522C 81 DUP2 522D 01 ADD 522E 90 SWAP1 522F 60 PUSH1 0x1f 5231 16 AND 5232 80 DUP1 5233 15 ISZERO 5234 61 PUSH2 0x5251 5237 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @522E stack[-7] = stack[-5] + stack[-7] // @5231 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x5251, if !(0x1f & stack[-5]) label_5238: // Incoming jump from 0x5237, if not !(0x1f & stack[-5]) // Inputs[6] // { // @5238 stack[-1] // @5239 stack[-2] // @523C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @5253 stack[-5] // @5259 memory[0x40:0x60] // @525E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 5238 80 DUP1 5239 82 DUP3 523A 03 SUB 523B 80 DUP1 523C 51 MLOAD 523D 60 PUSH1 0x01 523F 83 DUP4 5240 60 PUSH1 0x20 5242 03 SUB 5243 61 PUSH2 0x0100 5246 0A EXP 5247 03 SUB 5248 19 NOT 5249 16 AND 524A 81 DUP2 524B 52 MSTORE 524C 60 PUSH1 0x20 524E 01 ADD 524F 91 SWAP2 5250 50 POP 5251 5B JUMPDEST 5252 50 POP 5253 92 SWAP3 5254 50 POP 5255 50 POP 5256 50 POP 5257 60 PUSH1 0x40 5259 51 MLOAD 525A 80 DUP1 525B 91 SWAP2 525C 03 SUB 525D 90 SWAP1 525E FD *REVERT // Stack delta = -5 // Outputs[2] // { // @524B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @525E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_525F: // Incoming jump from 0x51DB, if stack[-2] // Inputs[2] // { // @5263 stack[-4] // @5264 stack[-5] // } 525F 5B JUMPDEST 5260 50 POP 5261 60 PUSH1 0x00 5263 83 DUP4 5264 85 DUP6 5265 81 DUP2 5266 61 PUSH2 0x526b 5269 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @5261 stack[-1] = 0x00 // @5263 stack[0] = stack[-4] // @5264 stack[1] = stack[-5] // } // Block ends with conditional jump to 0x526b, if stack[-4] label_526A: // Incoming jump from 0x5269, if not stack[-4] 526A FE *ASSERT // Stack delta = +0 // Outputs[1] { @526A assert(); } // Block terminates label_526B: // Incoming jump from 0x5269, if stack[-4] // Inputs[4] // { // @526C stack[-2] // @526C stack[-1] // @526D stack[-8] // @526E stack[-7] // } 526B 5B JUMPDEST 526C 04 DIV 526D 95 SWAP6 526E 94 SWAP5 526F 50 POP 5270 50 POP 5271 50 POP 5272 50 POP 5273 50 POP 5274 56 *JUMP // Stack delta = -7 // Outputs[1] { @526D stack[-8] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-8] label_5275: // Incoming jump from 0x4D3F // Incoming jump from 0x4D3F // Inputs[13] // { // @5276 stack[-2] // @5277 memory[stack[-2]:stack[-2] + 0x20] // @527D memory[0x20 + stack[-2]:0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20]] // @527E stack[-1] // @527F memory[stack[-1]:stack[-1] + 0x20] // @5286 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // @528A memory[0x40:0x60] // @52BF CHAINID() // @52C5 address(this) // @52D0 memory[0x40:0x60] // @52E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @52E4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @52E5 stack[-3] // } 5275 5B JUMPDEST 5276 81 DUP2 5277 51 MLOAD 5278 60 PUSH1 0x20 527A 92 SWAP3 527B 83 DUP4 527C 01 ADD 527D 20 SHA3 527E 81 DUP2 527F 51 MLOAD 5280 91 SWAP2 5281 83 DUP4 5282 01 ADD 5283 91 SWAP2 5284 90 SWAP1 5285 91 SWAP2 5286 20 SHA3 5287 60 PUSH1 0x40 5289 80 DUP1 528A 51 MLOAD 528B 7F PUSH32 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f 52AC 81 DUP2 52AD 86 DUP7 52AE 01 ADD 52AF 52 MSTORE 52B0 80 DUP1 52B1 82 DUP3 52B2 01 ADD 52B3 93 SWAP4 52B4 90 SWAP1 52B5 93 SWAP4 52B6 52 MSTORE 52B7 60 PUSH1 0x60 52B9 83 DUP4 52BA 01 ADD 52BB 91 SWAP2 52BC 90 SWAP1 52BD 91 SWAP2 52BE 52 MSTORE 52BF 46 CHAINID 52C0 60 PUSH1 0x80 52C2 83 DUP4 52C3 01 ADD 52C4 52 MSTORE 52C5 30 ADDRESS 52C6 60 PUSH1 0xa0 52C8 80 DUP1 52C9 84 DUP5 52CA 01 ADD 52CB 91 SWAP2 52CC 90 SWAP1 52CD 91 SWAP2 52CE 52 MSTORE 52CF 81 DUP2 52D0 51 MLOAD 52D1 80 DUP1 52D2 84 DUP5 52D3 03 SUB 52D4 90 SWAP1 52D5 91 SWAP2 52D6 01 ADD 52D7 81 DUP2 52D8 52 MSTORE 52D9 60 PUSH1 0xc0 52DB 90 SWAP1 52DC 92 SWAP3 52DD 01 ADD 52DE 90 SWAP1 52DF 52 MSTORE 52E0 80 DUP1 52E1 51 MLOAD 52E2 91 SWAP2 52E3 01 ADD 52E4 20 SHA3 52E5 90 SWAP1 52E6 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @52AF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f // @52B6 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = keccak256(memory[0x20 + stack[-2]:0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20]]) // @52BE memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = keccak256(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]) // @52C4 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = CHAINID() // @52CE memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = address(this) // @52D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @52DF memory[0x40:0x60] = memory[0x40:0x60] + 0xc0 // @52E5 stack[-3] = 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[-3] label_52E7: // Incoming call from 0x51B5, returns to 0x51B6 // Incoming call from 0x51B5, returns to 0x51B6 // Inputs[1] { @52EA storage[0x00] } 52E7 5B JUMPDEST 52E8 60 PUSH1 0x00 52EA 54 SLOAD 52EB 61 PUSH2 0x0100 52EE 90 SWAP1 52EF 04 DIV 52F0 60 PUSH1 0xff 52F2 16 AND 52F3 80 DUP1 52F4 61 PUSH2 0x5300 52F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @52F2 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x5300, if 0xff & storage[0x00] / 0x0100 label_52F8: // Incoming jump from 0x52F7, if not 0xff & storage[0x00] / 0x0100 52F8 50 POP 52F9 61 PUSH2 0x5300 52FC 61 PUSH2 0x48ef 52FF 56 *JUMP // Stack delta = +0 // Outputs[1] { @52F9 stack[-1] = 0x5300 } // Block ends with call to 0x48ef, returns to 0x5300 label_5300: // Incoming jump from 0x52F7, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x48EF at 0x52FF // Inputs[1] { @5301 stack[-1] } 5300 5B JUMPDEST 5301 80 DUP1 5302 61 PUSH2 0x530e 5305 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x530e, if stack[-1] label_5306: // Incoming jump from 0x5305, if not stack[-1] // Inputs[1] { @5309 storage[0x00] } 5306 50 POP 5307 60 PUSH1 0x00 5309 54 SLOAD 530A 60 PUSH1 0xff 530C 16 AND 530D 15 ISZERO 530E 5B JUMPDEST 530F 61 PUSH2 0x5349 5312 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x5349, if !(0xff & storage[0x00]) label_5313: // Incoming jump from 0x5312, if not !(0xff & storage[0x00]) // Incoming jump from 0x5312, if not stack[-1] // Inputs[3] // { // @5315 memory[0x40:0x60] // @5343 memory[0x40:0x60] // @5348 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 5313 60 PUSH1 0x40 5315 51 MLOAD 5316 62 PUSH3 0x461bcd 531A 60 PUSH1 0xe5 531C 1B SHL 531D 81 DUP2 531E 52 MSTORE 531F 60 PUSH1 0x04 5321 01 ADD 5322 80 DUP1 5323 80 DUP1 5324 60 PUSH1 0x20 5326 01 ADD 5327 82 DUP3 5328 81 DUP2 5329 03 SUB 532A 82 DUP3 532B 52 MSTORE 532C 60 PUSH1 0x2e 532E 81 DUP2 532F 52 MSTORE 5330 60 PUSH1 0x20 5332 01 ADD 5333 80 DUP1 5334 61 PUSH2 0x56fb 5337 60 PUSH1 0x2e 5339 91 SWAP2 533A 39 CODECOPY 533B 60 PUSH1 0x40 533D 01 ADD 533E 91 SWAP2 533F 50 POP 5340 50 POP 5341 60 PUSH1 0x40 5343 51 MLOAD 5344 80 DUP1 5345 91 SWAP2 5346 03 SUB 5347 90 SWAP1 5348 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @531E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @532B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @532F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @533A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x56fb:0x5729] // @5348 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_5349: // Incoming jump from 0x5312, if !(0xff & storage[0x00]) // Incoming jump from 0x5312, if stack[-1] // Inputs[1] { @534C storage[0x00] } 5349 5B JUMPDEST 534A 60 PUSH1 0x00 534C 54 SLOAD 534D 61 PUSH2 0x0100 5350 90 SWAP1 5351 04 DIV 5352 60 PUSH1 0xff 5354 16 AND 5355 15 ISZERO 5356 80 DUP1 5357 15 ISZERO 5358 61 PUSH2 0x51be 535B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @5355 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x51be, if !!(0xff & storage[0x00] / 0x0100) label_535C: // Incoming jump from 0x535B, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[2] // { // @535F storage[0x00] // @5374 stack[-1] // } 535C 60 PUSH1 0x00 535E 80 DUP1 535F 54 SLOAD 5360 60 PUSH1 0xff 5362 19 NOT 5363 61 PUSH2 0xff00 5366 19 NOT 5367 90 SWAP1 5368 91 SWAP2 5369 16 AND 536A 61 PUSH2 0x0100 536D 17 OR 536E 16 AND 536F 60 PUSH1 0x01 5371 17 OR 5372 90 SWAP1 5373 55 SSTORE 5374 80 DUP1 5375 15 ISZERO 5376 61 PUSH2 0x51d0 5379 57 *JUMPI // Stack delta = +0 // Outputs[1] { @5373 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) } // Block ends with conditional jump to 0x51d0, if !stack[-1] label_537A: // Incoming jump from 0x5379, if not !stack[-1] // Inputs[2] // { // @537D storage[0x00] // @5386 stack[-2] // } 537A 60 PUSH1 0x00 537C 80 DUP1 537D 54 SLOAD 537E 61 PUSH2 0xff00 5381 19 NOT 5382 16 AND 5383 90 SWAP1 5384 55 SSTORE 5385 50 POP 5386 56 *JUMP // Stack delta = -2 // Outputs[1] { @5384 storage[0x00] = ~0xff00 & storage[0x00] } // Block ends with unconditional jump to stack[-2] label_5387: // Incoming call from 0x51BD, returns to 0x51BE // Inputs[1] { @538A storage[0x00] } 5387 5B JUMPDEST 5388 60 PUSH1 0x00 538A 54 SLOAD 538B 61 PUSH2 0x0100 538E 90 SWAP1 538F 04 DIV 5390 60 PUSH1 0xff 5392 16 AND 5393 80 DUP1 5394 61 PUSH2 0x53a0 5397 57 *JUMPI // Stack delta = +1 // Outputs[1] { @5392 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x53a0, if 0xff & storage[0x00] / 0x0100 label_5398: // Incoming jump from 0x5397, if not 0xff & storage[0x00] / 0x0100 5398 50 POP 5399 61 PUSH2 0x53a0 539C 61 PUSH2 0x48ef 539F 56 *JUMP // Stack delta = +0 // Outputs[1] { @5399 stack[-1] = 0x53a0 } // Block ends with call to 0x48ef, returns to 0x53A0 label_53A0: // Incoming return from call to 0x48EF at 0x539F // Incoming jump from 0x5397, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @53A1 stack[-1] } 53A0 5B JUMPDEST 53A1 80 DUP1 53A2 61 PUSH2 0x53ae 53A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x53ae, if stack[-1] label_53A6: // Incoming jump from 0x53A5, if not stack[-1] // Inputs[1] { @53A9 storage[0x00] } 53A6 50 POP 53A7 60 PUSH1 0x00 53A9 54 SLOAD 53AA 60 PUSH1 0xff 53AC 16 AND 53AD 15 ISZERO 53AE 5B JUMPDEST 53AF 61 PUSH2 0x53e9 53B2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x53e9, if !(0xff & storage[0x00]) label_53B3: // Incoming jump from 0x53B2, if not stack[-1] // Incoming jump from 0x53B2, if not !(0xff & storage[0x00]) // Inputs[3] // { // @53B5 memory[0x40:0x60] // @53E3 memory[0x40:0x60] // @53E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 53B3 60 PUSH1 0x40 53B5 51 MLOAD 53B6 62 PUSH3 0x461bcd 53BA 60 PUSH1 0xe5 53BC 1B SHL 53BD 81 DUP2 53BE 52 MSTORE 53BF 60 PUSH1 0x04 53C1 01 ADD 53C2 80 DUP1 53C3 80 DUP1 53C4 60 PUSH1 0x20 53C6 01 ADD 53C7 82 DUP3 53C8 81 DUP2 53C9 03 SUB 53CA 82 DUP3 53CB 52 MSTORE 53CC 60 PUSH1 0x2e 53CE 81 DUP2 53CF 52 MSTORE 53D0 60 PUSH1 0x20 53D2 01 ADD 53D3 80 DUP1 53D4 61 PUSH2 0x56fb 53D7 60 PUSH1 0x2e 53D9 91 SWAP2 53DA 39 CODECOPY 53DB 60 PUSH1 0x40 53DD 01 ADD 53DE 91 SWAP2 53DF 50 POP 53E0 50 POP 53E1 60 PUSH1 0x40 53E3 51 MLOAD 53E4 80 DUP1 53E5 91 SWAP2 53E6 03 SUB 53E7 90 SWAP1 53E8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @53BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @53CB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @53CF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @53DA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x56fb:0x5729] // @53E8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_53E9: // Incoming jump from 0x53B2, if stack[-1] // Incoming jump from 0x53B2, if !(0xff & storage[0x00]) // Inputs[1] { @53EC storage[0x00] } 53E9 5B JUMPDEST 53EA 60 PUSH1 0x00 53EC 54 SLOAD 53ED 61 PUSH2 0x0100 53F0 90 SWAP1 53F1 04 DIV 53F2 60 PUSH1 0xff 53F4 16 AND 53F5 15 ISZERO 53F6 80 DUP1 53F7 15 ISZERO 53F8 61 PUSH2 0x5414 53FB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @53F5 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x5414, if !!(0xff & storage[0x00] / 0x0100) label_53FC: // Incoming jump from 0x53FB, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[1] { @53FF storage[0x00] } 53FC 60 PUSH1 0x00 53FE 80 DUP1 53FF 54 SLOAD 5400 60 PUSH1 0xff 5402 19 NOT 5403 61 PUSH2 0xff00 5406 19 NOT 5407 90 SWAP1 5408 91 SWAP2 5409 16 AND 540A 61 PUSH2 0x0100 540D 17 OR 540E 16 AND 540F 60 PUSH1 0x01 5411 17 OR 5412 90 SWAP1 5413 55 SSTORE 5414 5B JUMPDEST 5415 60 PUSH1 0x00 5417 61 PUSH2 0x541e 541A 61 PUSH2 0x4380 541D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @5413 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @5415 stack[0] = 0x00 // @5417 stack[1] = 0x541e // } // Block ends with call to 0x4380, returns to 0x541E label_541E: // Incoming return from call to 0x4380 at 0x541D // Incoming return from call to 0x4380 at 0x541D // Inputs[6] // { // @5422 storage[0x65] // @5435 stack[-1] // @543F memory[0x40:0x60] // @5441 stack[-2] // @546B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @546D stack[-3] // } 541E 5B JUMPDEST 541F 60 PUSH1 0x65 5421 80 DUP1 5422 54 SLOAD 5423 60 PUSH1 0x01 5425 60 PUSH1 0x01 5427 60 PUSH1 0xa0 5429 1B SHL 542A 03 SUB 542B 19 NOT 542C 16 AND 542D 60 PUSH1 0x01 542F 60 PUSH1 0x01 5431 60 PUSH1 0xa0 5433 1B SHL 5434 03 SUB 5435 83 DUP4 5436 16 AND 5437 90 SWAP1 5438 81 DUP2 5439 17 OR 543A 90 SWAP1 543B 91 SWAP2 543C 55 SSTORE 543D 60 PUSH1 0x40 543F 51 MLOAD 5440 91 SWAP2 5441 92 SWAP3 5442 50 POP 5443 90 SWAP1 5444 60 PUSH1 0x00 5446 90 SWAP1 5447 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 5468 90 SWAP1 5469 82 DUP3 546A 90 SWAP1 546B A3 LOG3 546C 50 POP 546D 80 DUP1 546E 15 ISZERO 546F 61 PUSH2 0x51d0 5472 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @543C storage[0x65] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x65]) // @546B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, 0x00, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with conditional jump to 0x51d0, if !stack[-3] label_5473: // Incoming jump from 0x5472, if not !stack[-3] // Inputs[2] // { // @5476 storage[0x00] // @547F stack[-2] // } 5473 60 PUSH1 0x00 5475 80 DUP1 5476 54 SLOAD 5477 61 PUSH2 0xff00 547A 19 NOT 547B 16 AND 547C 90 SWAP1 547D 55 SSTORE 547E 50 POP 547F 56 *JUMP // Stack delta = -2 // Outputs[1] { @547D storage[0x00] = ~0xff00 & storage[0x00] } // Block ends with unconditional jump to stack[-2] label_5480: // Incoming jump from 0x2066 // Inputs[5] // { // @5481 stack[-3] // @5483 storage[stack[-3]] // @5484 stack[-1] // @548F memory[0x00:0x20] // @5493 stack[-2] // } 5480 5B JUMPDEST 5481 82 DUP3 5482 80 DUP1 5483 54 SLOAD 5484 82 DUP3 5485 82 DUP3 5486 55 SSTORE 5487 90 SWAP1 5488 60 PUSH1 0x00 548A 52 MSTORE 548B 60 PUSH1 0x20 548D 60 PUSH1 0x00 548F 20 SHA3 5490 90 SWAP1 5491 81 DUP2 5492 01 ADD 5493 92 SWAP3 5494 82 DUP3 5495 15 ISZERO 5496 61 PUSH2 0x54d3 5499 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @5486 storage[stack[-3]] = stack[-1] // @548A memory[0x00:0x20] = stack[-3] // @5490 stack[0] = keccak256(memory[0x00:0x20]) // @5493 stack[1] = stack[-2] // @5493 stack[-2] = keccak256(memory[0x00:0x20]) + storage[stack[-3]] // } // Block ends with conditional jump to 0x54d3, if !stack[-1] label_549A: // Incoming jump from 0x5499, if not !stack[-1] // Inputs[2] // { // @549A stack[-1] // @549A stack[-3] // } 549A 91 SWAP2 549B 60 PUSH1 0x20 549D 02 MUL 549E 82 DUP3 549F 01 ADD 54A0 5B JUMPDEST 54A1 82 DUP3 54A2 81 DUP2 54A3 11 GT 54A4 15 ISZERO 54A5 61 PUSH2 0x54d3 54A8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @549A stack[-3] = stack[-1] // @549F stack[-1] = stack[-1] + 0x20 * stack[-3] // } // Block ends with conditional jump to 0x54d3, if !(stack[-1] + 0x20 * stack[-3] > stack[-1]) label_54A9: // Incoming jump from 0x54A8, if not !(stack[-1] + 0x20 * stack[-3] > stack[-1]) // Incoming jump from 0x54A8, if not !(stack[-1] > stack[-3]) // Inputs[5] // { // @54A9 stack[-2] // @54AA storage[stack[-2]] // @54BD stack[-3] // @54BE msg.data[stack[-3]:stack[-3] + 0x20] // @54C5 stack[-1] // } 54A9 81 DUP2 54AA 54 SLOAD 54AB 60 PUSH1 0x01 54AD 60 PUSH1 0x01 54AF 60 PUSH1 0xa0 54B1 1B SHL 54B2 03 SUB 54B3 19 NOT 54B4 16 AND 54B5 60 PUSH1 0x01 54B7 60 PUSH1 0x01 54B9 60 PUSH1 0xa0 54BB 1B SHL 54BC 03 SUB 54BD 84 DUP5 54BE 35 CALLDATALOAD 54BF 16 AND 54C0 17 OR 54C1 82 DUP3 54C2 55 SSTORE 54C3 60 PUSH1 0x20 54C5 90 SWAP1 54C6 92 SWAP3 54C7 01 ADD 54C8 91 SWAP2 54C9 60 PUSH1 0x01 54CB 90 SWAP1 54CC 91 SWAP2 54CD 01 ADD 54CE 90 SWAP1 54CF 61 PUSH2 0x54a0 54D2 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @54C2 storage[stack[-2]] = (msg.data[stack[-3]:stack[-3] + 0x20] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[stack[-2]]) // @54C8 stack[-3] = stack[-3] + 0x20 // @54CE stack[-2] = stack[-2] + 0x01 // @54CE stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x54a0 label_54D3: // Incoming jump from 0x54A8, if !(stack[-1] + 0x20 * stack[-3] > stack[-1]) // Incoming jump from 0x5499, if !stack[-1] // Incoming jump from 0x54A8, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @54D8 stack[-4] // @54D9 stack[-3] // } 54D3 5B JUMPDEST 54D4 50 POP 54D5 61 PUSH2 0x54df 54D8 92 SWAP3 54D9 91 SWAP2 54DA 50 POP 54DB 61 PUSH2 0x55ec 54DE 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @54D8 stack[-4] = 0x54df // @54D9 stack[-3] = stack[-4] // } // Block ends with call to 0x55ec, returns to 0x54DF label_54DF: // Incoming call from 0x55FA, returns to 0x148E, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x55EC at 0x54DE // Incoming call from 0x561E, returns to 0x148E, if !(stack[-2] > stack[-1]) // Incoming jump from 0x55FA, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x5610 at 0x555C // Incoming jump from 0x561E, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @54E1 stack[-3] // @54E1 stack[-2] // } 54DF 5B JUMPDEST 54E0 50 POP 54E1 90 SWAP1 54E2 56 *JUMP // Stack delta = -2 // Outputs[1] { @54E1 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_54E3: // Incoming jump from 0x2BB8 // Inputs[5] // { // @54E4 stack[-3] // @54E6 storage[stack[-3]] // @5500 memory[0x00:0x20] // @550B stack[-2] // @550C stack[-1] // } 54E3 5B JUMPDEST 54E4 82 DUP3 54E5 80 DUP1 54E6 54 SLOAD 54E7 60 PUSH1 0x01 54E9 81 DUP2 54EA 60 PUSH1 0x01 54EC 16 AND 54ED 15 ISZERO 54EE 61 PUSH2 0x0100 54F1 02 MUL 54F2 03 SUB 54F3 16 AND 54F4 60 PUSH1 0x02 54F6 90 SWAP1 54F7 04 DIV 54F8 90 SWAP1 54F9 60 PUSH1 0x00 54FB 52 MSTORE 54FC 60 PUSH1 0x20 54FE 60 PUSH1 0x00 5500 20 SHA3 5501 90 SWAP1 5502 60 PUSH1 0x1f 5504 01 ADD 5505 60 PUSH1 0x20 5507 90 SWAP1 5508 04 DIV 5509 81 DUP2 550A 01 ADD 550B 92 SWAP3 550C 82 DUP3 550D 60 PUSH1 0x1f 550F 10 LT 5510 61 PUSH2 0x5524 5513 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @54FB memory[0x00:0x20] = stack[-3] // @5501 stack[0] = keccak256(memory[0x00:0x20]) // @550B stack[1] = stack[-2] // @550B stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x5524, if 0x1f < stack[-1] label_5514: // Incoming jump from 0x5513, if not 0x1f < stack[-1] // Inputs[4] // { // @5514 stack[-3] // @551A stack[-1] // @551B msg.data[stack[-1]:stack[-1] + 0x20] // @551E stack[-5] // } 5514 82 DUP3 5515 80 DUP1 5516 01 ADD 5517 60 PUSH1 0xff 5519 19 NOT 551A 82 DUP3 551B 35 CALLDATALOAD 551C 16 AND 551D 17 OR 551E 85 DUP6 551F 55 SSTORE 5520 61 PUSH2 0x5551 5523 56 *JUMP // Stack delta = +0 // Outputs[1] { @551F storage[stack[-5]] = (msg.data[stack[-1]:stack[-1] + 0x20] & ~0xff) | stack[-3] + stack[-3] } // Block ends with unconditional jump to 0x5551 label_5524: // Incoming jump from 0x5513, if 0x1f < stack[-1] // Inputs[2] // { // @5525 stack[-3] // @552B stack[-5] // } 5524 5B JUMPDEST 5525 82 DUP3 5526 80 DUP1 5527 01 ADD 5528 60 PUSH1 0x01 552A 01 ADD 552B 85 DUP6 552C 55 SSTORE 552D 82 DUP3 552E 15 ISZERO 552F 61 PUSH2 0x5551 5532 57 *JUMPI // Stack delta = +0 // Outputs[1] { @552C storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x5551, if !stack[-3] label_5533: // Incoming jump from 0x5532, if not !stack[-3] // Inputs[2] // { // @5533 stack[-1] // @5533 stack[-3] // } 5533 91 SWAP2 5534 82 DUP3 5535 01 ADD // Stack delta = +0 // Outputs[2] // { // @5533 stack[-3] = stack[-1] // @5535 stack[-1] = stack[-1] + stack[-3] // } // Block continues label_5536: // Incoming jump from 0x5596 // Incoming jump from 0x5550 // Incoming jump from 0x5535 // Inputs[2] // { // @5537 stack[-3] // @5538 stack[-1] // } 5536 5B JUMPDEST 5537 82 DUP3 5538 81 DUP2 5539 11 GT 553A 15 ISZERO 553B 61 PUSH2 0x5551 553E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x5551, if !(stack[-1] > stack[-3]) label_553F: // Incoming jump from 0x553E, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @553F stack[-3] // @5540 msg.data[stack[-3]:stack[-3] + 0x20] // @5541 stack[-2] // @5543 stack[-1] // } 553F 82 DUP3 5540 35 CALLDATALOAD 5541 82 DUP3 5542 55 SSTORE 5543 91 SWAP2 5544 60 PUSH1 0x20 5546 01 ADD 5547 91 SWAP2 5548 90 SWAP1 5549 60 PUSH1 0x01 554B 01 ADD 554C 90 SWAP1 554D 61 PUSH2 0x5536 5550 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @5542 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @5547 stack[-3] = 0x20 + stack[-3] // @554C stack[-2] = 0x01 + stack[-2] // @554C stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x5536 label_5551: // Incoming jump from 0x5523 // Incoming jump from 0x553E, if !(stack[-1] > stack[-3]) // Incoming jump from 0x5576, if !stack[-1] // Incoming jump from 0x5532, if !stack[-3] // Incoming jump from 0x5584, if !(stack[-1] + 0x20 * stack[-3] > stack[-1]) // Inputs[2] // { // @5556 stack[-4] // @5557 stack[-3] // } 5551 5B JUMPDEST 5552 50 POP 5553 61 PUSH2 0x54df 5556 92 SWAP3 5557 91 SWAP2 5558 50 POP 5559 61 PUSH2 0x5610 555C 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @5556 stack[-4] = 0x54df // @5557 stack[-3] = stack[-4] // } // Block ends with call to 0x5610, returns to 0x54DF label_555D: // Incoming jump from 0x2CD5 // Inputs[5] // { // @555E stack[-3] // @5560 storage[stack[-3]] // @5561 stack[-1] // @556C memory[0x00:0x20] // @5570 stack[-2] // } 555D 5B JUMPDEST 555E 82 DUP3 555F 80 DUP1 5560 54 SLOAD 5561 82 DUP3 5562 82 DUP3 5563 55 SSTORE 5564 90 SWAP1 5565 60 PUSH1 0x00 5567 52 MSTORE 5568 60 PUSH1 0x20 556A 60 PUSH1 0x00 556C 20 SHA3 556D 90 SWAP1 556E 81 DUP2 556F 01 ADD 5570 92 SWAP3 5571 82 DUP3 5572 15 ISZERO 5573 61 PUSH2 0x5551 5576 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @5563 storage[stack[-3]] = stack[-1] // @5567 memory[0x00:0x20] = stack[-3] // @556D stack[0] = keccak256(memory[0x00:0x20]) // @5570 stack[1] = stack[-2] // @5570 stack[-2] = keccak256(memory[0x00:0x20]) + storage[stack[-3]] // } // Block ends with conditional jump to 0x5551, if !stack[-1] label_5577: // Incoming jump from 0x5576, if not !stack[-1] // Inputs[2] // { // @5577 stack[-1] // @5577 stack[-3] // } 5577 91 SWAP2 5578 60 PUSH1 0x20 557A 02 MUL 557B 82 DUP3 557C 01 ADD 557D 82 DUP3 557E 81 DUP2 557F 11 GT 5580 15 ISZERO 5581 61 PUSH2 0x5551 5584 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @5577 stack[-3] = stack[-1] // @557C stack[-1] = stack[-1] + 0x20 * stack[-3] // } // Block ends with conditional jump to 0x5551, if !(stack[-1] + 0x20 * stack[-3] > stack[-1]) label_5585: // Incoming jump from 0x5584, if not !(stack[-1] + 0x20 * stack[-3] > stack[-1]) // Inputs[4] // { // @5585 stack[-3] // @5586 msg.data[stack[-3]:stack[-3] + 0x20] // @5587 stack[-2] // @5589 stack[-1] // } 5585 82 DUP3 5586 35 CALLDATALOAD 5587 82 DUP3 5588 55 SSTORE 5589 91 SWAP2 558A 60 PUSH1 0x20 558C 01 ADD 558D 91 SWAP2 558E 90 SWAP1 558F 60 PUSH1 0x01 5591 01 ADD 5592 90 SWAP1 5593 61 PUSH2 0x5536 5596 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @5588 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @558D stack[-3] = 0x20 + stack[-3] // @5592 stack[-2] = 0x01 + stack[-2] // @5592 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x5536 5597 5B JUMPDEST 5598 82 DUP3 5599 80 DUP1 559A 54 SLOAD 559B 82 DUP3 559C 82 DUP3 559D 55 SSTORE 559E 90 SWAP1 559F 60 PUSH1 0x00 55A1 52 MSTORE 55A2 60 PUSH1 0x20 55A4 60 PUSH1 0x00 55A6 20 SHA3 55A7 90 SWAP1 55A8 81 DUP2 55A9 01 ADD 55AA 92 SWAP3 55AB 82 DUP3 55AC 15 ISZERO 55AD 61 PUSH2 0x54d3 55B0 57 *JUMPI 55B1 91 SWAP2 55B2 60 PUSH1 0x20 55B4 02 MUL 55B5 82 DUP3 55B6 01 ADD 55B7 5B JUMPDEST 55B8 82 DUP3 55B9 81 DUP2 55BA 11 GT 55BB 15 ISZERO 55BC 61 PUSH2 0x54d3 55BF 57 *JUMPI 55C0 82 DUP3 55C1 51 MLOAD 55C2 82 DUP3 55C3 54 SLOAD 55C4 60 PUSH1 0x01 55C6 60 PUSH1 0x01 55C8 60 PUSH1 0xa0 55CA 1B SHL 55CB 03 SUB 55CC 19 NOT 55CD 16 AND 55CE 60 PUSH1 0x01 55D0 60 PUSH1 0x01 55D2 60 PUSH1 0xa0 55D4 1B SHL 55D5 03 SUB 55D6 90 SWAP1 55D7 91 SWAP2 55D8 16 AND 55D9 17 OR 55DA 82 DUP3 55DB 55 SSTORE 55DC 60 PUSH1 0x20 55DE 90 SWAP1 55DF 92 SWAP3 55E0 01 ADD 55E1 91 SWAP2 55E2 60 PUSH1 0x01 55E4 90 SWAP1 55E5 91 SWAP2 55E6 01 ADD 55E7 90 SWAP1 55E8 61 PUSH2 0x55b7 55EB 56 *JUMP label_55EC: // Incoming call from 0x54DE, returns to 0x54DF // Inputs[2] // { // @55F0 stack[-2] // @55F1 stack[-1] // } 55EC 5B JUMPDEST 55ED 61 PUSH2 0x148e 55F0 91 SWAP2 55F1 90 SWAP1 55F2 5B JUMPDEST 55F3 80 DUP1 55F4 82 DUP3 55F5 11 GT 55F6 15 ISZERO 55F7 61 PUSH2 0x54df 55FA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @55F0 stack[-2] = 0x148e // @55F1 stack[-1] = stack[-2] // @55F1 stack[0] = stack[-1] // } // Block ends with conditional call to 0x54df, returns to 0x148E, if !(stack[-2] > stack[-1]) label_55FB: // Incoming jump from 0x55FA, if not !(stack[-2] > stack[-1]) // Incoming call from 0x55FA, returns to 0x148E, if not !(stack[-2] > stack[-1]) // Inputs[2] // { // @55FB stack[-1] // @55FC storage[stack[-1]] // } 55FB 80 DUP1 55FC 54 SLOAD 55FD 60 PUSH1 0x01 55FF 60 PUSH1 0x01 5601 60 PUSH1 0xa0 5603 1B SHL 5604 03 SUB 5605 19 NOT 5606 16 AND 5607 81 DUP2 5608 55 SSTORE 5609 60 PUSH1 0x01 560B 01 ADD 560C 61 PUSH2 0x55f2 560F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @5608 storage[stack[-1]] = ~((0x01 << 0xa0) - 0x01) & storage[stack[-1]] // @560B stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x55f2 label_5610: // Incoming call from 0x555C, returns to 0x54DF // Inputs[2] // { // @5614 stack[-2] // @5615 stack[-1] // } 5610 5B JUMPDEST 5611 61 PUSH2 0x148e 5614 91 SWAP2 5615 90 SWAP1 5616 5B JUMPDEST 5617 80 DUP1 5618 82 DUP3 5619 11 GT 561A 15 ISZERO 561B 61 PUSH2 0x54df 561E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @5614 stack[-2] = 0x148e // @5615 stack[-1] = stack[-2] // @5615 stack[0] = stack[-1] // } // Block ends with conditional call to 0x54df, returns to 0x148E, if !(stack[-2] > stack[-1]) label_561F: // Incoming jump from 0x561E, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x561E, if not !(stack[-2] > stack[-1]) // Inputs[1] { @5621 stack[-1] } 561F 60 PUSH1 0x00 5621 81 DUP2 5622 55 SSTORE 5623 60 PUSH1 0x01 5625 01 ADD 5626 61 PUSH2 0x5616 5629 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @5622 storage[stack[-1]] = 0x00 // @5625 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x5616 562A FE *ASSERT 562B 45 GASLIMIT 562C 43 NUMBER 562D 52 MSTORE 562E 65 PUSH6 0x636f7665723a 5635 20 SHA3 5636 69 PUSH10 0x6e76616c696420736967 5641 6E PUSH15 0x6174757265202776272076616c7565 5651 4F 4F 5652 77 PUSH24 0x6e61626c653a206e6577206f776e65722069732074686520 566B 7A PUSH27 0x65726f2061646472657373526f6c65733a206163636f756e742064 5687 6F PUSH16 0x6573206e6f74206861766520726f6c65 5698 53 MSTORE8 5699 61 PUSH2 0x6665 569C 4D 4D 569D 61 PUSH2 0x7468 56A0 3A GASPRICE 56A1 20 SHA3 56A2 6D PUSH14 0x756c7469706c69636174696f6e20 56B1 6F PUSH16 0x766572666c6f774f776e61626c653a20 56C2 63 PUSH4 0x616c6c65 56C7 72 PUSH19 0x206973206e6f7420746865206f776e6572526f 56DB 6C PUSH13 0x65733a206163636f756e742069 56E9 73 PUSH20 0x20746865207a65726f2061646472657373436f6e 56FE 74 PUSH21 0x7261637420696e7374616e63652068617320616c72 5714 65 PUSH6 0x616479206265 571B 65 PUSH6 0x6e20696e6974 5722 69 PUSH10 0x616c697a6564ddf252ad 572D 1B SHL 572E E2 E2 572F C8 C8 5730 9B SWAP12 5731 69 PUSH10 0xc2b068fc378daa952ba7 573C F1 CALL 573D 63 PUSH4 0xc4a11628 5742 F5 CREATE2 5743 5A GAS 5744 4D 4D 5745 F5 CREATE2 5746 23 23 5747 B3 B3 5748 EF EF 5749 45 GASLIMIT 574A 43 NUMBER 574B 52 MSTORE 574C 65 PUSH6 0x636f7665723a 5753 20 SHA3 5754 69 PUSH10 0x6e76616c696420736967 575F 6E PUSH15 0x6174757265202773272076616c7565 576F A2 LOG2 5770 64 PUSH5 0x6970667358 5776 22 22 5777 12 SLT 5778 20 SHA3 5779 26 26 577A 58 PC 577B 6C PUSH13 0x37be4619b7f3be11fb06fb6156 5789 EA EA 578A E2 E2 578B 40 BLOCKHASH 578C 78 PUSH25 0x1f0961f5bb85a1663ecb7bc564736f6c63430006020033