Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x019c 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x019c, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x5dbd6059 0019 11 GT 001A 61 PUSH2 0x00ec 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00ec, if 0x5dbd6059 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x5dbd6059 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa9059cbb 0024 11 GT 0025 61 PUSH2 0x008a 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008a, if 0xa9059cbb > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa9059cbb > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xde0e9a3e 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xde0e9a3e > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xde0e9a3e > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xde0e9a3e 003A 14 EQ 003B 61 PUSH2 0x06aa 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06aa, if 0xde0e9a3e == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xde0e9a3e == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xea598cb0 0045 14 EQ 0046 61 PUSH2 0x06d4 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d4, if 0xea598cb0 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xea598cb0 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf2fde38b 0050 14 EQ 0051 61 PUSH2 0x06fe 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fe, if 0xf2fde38b == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xfc0c546a 005B 14 EQ 005C 61 PUSH2 0x0731 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0731, if 0xfc0c546a == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xfc0c546a == stack[-1] 0060 61 PUSH2 0x019c 0063 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x019c label_0064: // Incoming jump from 0x0033, if 0xde0e9a3e > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xa9059cbb 006B 14 EQ 006C 61 PUSH2 0x05fd 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05fd, if 0xa9059cbb == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xa96623a8 0076 14 EQ 0077 61 PUSH2 0x0636 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0636, if 0xa96623a8 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xa96623a8 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xdd62ed3e 0081 14 EQ 0082 61 PUSH2 0x066f 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066f, if 0xdd62ed3e == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xdd62ed3e == stack[-1] 0086 61 PUSH2 0x019c 0089 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x019c label_008A: // Incoming jump from 0x0028, if 0xa9059cbb > stack[-1] // Inputs[1] { @008B stack[-1] } 008A 5B JUMPDEST 008B 80 DUP1 008C 63 PUSH4 0x7413a790 0091 11 GT 0092 61 PUSH2 0x00c6 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c6, if 0x7413a790 > stack[-1] label_0096: // Incoming jump from 0x0095, if not 0x7413a790 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0x7413a790 009C 14 EQ 009D 61 PUSH2 0x056d 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056d, if 0x7413a790 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x7413a790 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x8ca56fa5 00A7 14 EQ 00A8 61 PUSH2 0x05a0 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a0, if 0x8ca56fa5 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x8ca56fa5 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x8da5cb5b 00B2 14 EQ 00B3 61 PUSH2 0x05d3 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d3, if 0x8da5cb5b == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x95d89b41 00BD 14 EQ 00BE 61 PUSH2 0x05e8 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e8, if 0x95d89b41 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x95d89b41 == stack[-1] 00C2 61 PUSH2 0x019c 00C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x019c label_00C6: // Incoming jump from 0x0095, if 0x7413a790 > stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C6 5B JUMPDEST 00C7 80 DUP1 00C8 63 PUSH4 0x5dbd6059 00CD 14 EQ 00CE 61 PUSH2 0x04ec 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ec, if 0x5dbd6059 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0x5dbd6059 == stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D2 80 DUP1 00D3 63 PUSH4 0x70a08231 00D8 14 EQ 00D9 61 PUSH2 0x0525 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0525, if 0x70a08231 == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x70a08231 == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x715018a6 00E3 14 EQ 00E4 61 PUSH2 0x0558 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0558, if 0x715018a6 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x715018a6 == stack[-1] 00E8 61 PUSH2 0x019c 00EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x019c label_00EC: // Incoming jump from 0x001D, if 0x5dbd6059 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00ED stack[-1] } 00EC 5B JUMPDEST 00ED 80 DUP1 00EE 63 PUSH4 0x313ce567 00F3 11 GT 00F4 61 PUSH2 0x0159 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0159, if 0x313ce567 > stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x313ce567 > stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x42966c68 00FE 11 GT 00FF 61 PUSH2 0x0133 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0133, if 0x42966c68 > stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x42966c68 > stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x42966c68 0109 14 EQ 010A 61 PUSH2 0x042b 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042b, if 0x42966c68 == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x42966c68 == stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x51cff8d9 0114 14 EQ 0115 61 PUSH2 0x0455 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0455, if 0x51cff8d9 == stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x51cff8d9 == stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x55df2ee7 011F 14 EQ 0120 61 PUSH2 0x0488 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0488, if 0x55df2ee7 == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x55df2ee7 == stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x5d235e79 012A 14 EQ 012B 61 PUSH2 0x04b9 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b9, if 0x5d235e79 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x5d235e79 == stack[-1] 012F 61 PUSH2 0x019c 0132 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x019c label_0133: // Incoming jump from 0x0102, if 0x42966c68 > stack[-1] // Inputs[1] { @0134 stack[-1] } 0133 5B JUMPDEST 0134 80 DUP1 0135 63 PUSH4 0x313ce567 013A 14 EQ 013B 61 PUSH2 0x039d 013E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039d, if 0x313ce567 == stack[-1] label_013F: // Incoming jump from 0x013E, if not 0x313ce567 == stack[-1] // Inputs[1] { @013F stack[-1] } 013F 80 DUP1 0140 63 PUSH4 0x3fdb93f6 0145 14 EQ 0146 61 PUSH2 0x03c8 0149 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c8, if 0x3fdb93f6 == stack[-1] label_014A: // Incoming jump from 0x0149, if not 0x3fdb93f6 == stack[-1] // Inputs[1] { @014A stack[-1] } 014A 80 DUP1 014B 63 PUSH4 0x40c10f19 0150 14 EQ 0151 61 PUSH2 0x03f2 0154 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f2, if 0x40c10f19 == stack[-1] label_0155: // Incoming jump from 0x0154, if not 0x40c10f19 == stack[-1] 0155 61 PUSH2 0x019c 0158 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x019c label_0159: // Incoming jump from 0x00F7, if 0x313ce567 > stack[-1] // Inputs[1] { @015A stack[-1] } 0159 5B JUMPDEST 015A 80 DUP1 015B 63 PUSH4 0x06fdde03 0160 14 EQ 0161 61 PUSH2 0x01a1 0164 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a1, if 0x06fdde03 == stack[-1] label_0165: // Incoming jump from 0x0164, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0165 stack[-1] } 0165 80 DUP1 0166 63 PUSH4 0x095ea7b3 016B 14 EQ 016C 61 PUSH2 0x022b 016F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022b, if 0x095ea7b3 == stack[-1] label_0170: // Incoming jump from 0x016F, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0170 stack[-1] } 0170 80 DUP1 0171 63 PUSH4 0x1685cc17 0176 14 EQ 0177 61 PUSH2 0x0278 017A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0278, if 0x1685cc17 == stack[-1] label_017B: // Incoming jump from 0x017A, if not 0x1685cc17 == stack[-1] // Inputs[1] { @017B stack[-1] } 017B 80 DUP1 017C 63 PUSH4 0x18160ddd 0181 14 EQ 0182 61 PUSH2 0x02fa 0185 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fa, if 0x18160ddd == stack[-1] label_0186: // Incoming jump from 0x0185, if not 0x18160ddd == stack[-1] // Inputs[1] { @0186 stack[-1] } 0186 80 DUP1 0187 63 PUSH4 0x23b872dd 018C 14 EQ 018D 61 PUSH2 0x0321 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0321, if 0x23b872dd == stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x23b872dd == stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x26599850 0197 14 EQ 0198 61 PUSH2 0x0364 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0364, if 0x26599850 == stack[-1] label_019C: // Incoming jump from 0x0132 // Incoming jump from 0x00EB // Incoming jump from 0x019B, if not 0x26599850 == stack[-1] // Incoming jump from 0x0063 // Incoming jump from 0x0089 // Incoming jump from 0x0158 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x00C5 // Inputs[1] { @01A0 memory[0x00:0x00] } 019C 5B JUMPDEST 019D 60 PUSH1 0x00 019F 80 DUP1 01A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A0 revert(memory[0x00:0x00]); } // Block terminates label_01A1: // Incoming jump from 0x0164, if 0x06fdde03 == stack[-1] // Inputs[1] { @01A2 msg.value } 01A1 5B JUMPDEST 01A2 34 CALLVALUE 01A3 80 DUP1 01A4 15 ISZERO 01A5 61 PUSH2 0x01ad 01A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01A2 stack[0] = msg.value } // Block ends with conditional jump to 0x01ad, if !msg.value label_01A9: // Incoming jump from 0x01A8, if not !msg.value // Inputs[1] { @01AC memory[0x00:0x00] } 01A9 60 PUSH1 0x00 01AB 80 DUP1 01AC FD *REVERT // Stack delta = +0 // Outputs[1] { @01AC revert(memory[0x00:0x00]); } // Block terminates label_01AD: // Incoming jump from 0x01A8, if !msg.value 01AD 5B JUMPDEST 01AE 50 POP 01AF 61 PUSH2 0x01b6 01B2 61 PUSH2 0x0746 01B5 56 *JUMP // Stack delta = +0 // Outputs[1] { @01AF stack[-1] = 0x01b6 } // Block ends with call to 0x0746, returns to 0x01B6 label_01B6: // Incoming return from call to 0x0746 at 0x01B5 // Incoming return from call to 0x12A5 at 0x05FC // Inputs[4] // { // @01BA memory[0x40:0x60] // @01C0 stack[-1] // @01C1 memory[stack[-1]:stack[-1] + 0x20] // @01C7 memory[stack[-1]:stack[-1] + 0x20] // } 01B6 5B JUMPDEST 01B7 60 PUSH1 0x40 01B9 80 DUP1 01BA 51 MLOAD 01BB 60 PUSH1 0x20 01BD 80 DUP1 01BE 82 DUP3 01BF 52 MSTORE 01C0 83 DUP4 01C1 51 MLOAD 01C2 81 DUP2 01C3 83 DUP4 01C4 01 ADD 01C5 52 MSTORE 01C6 83 DUP4 01C7 51 MLOAD 01C8 91 SWAP2 01C9 92 SWAP3 01CA 83 DUP4 01CB 92 SWAP3 01CC 90 SWAP1 01CD 83 DUP4 01CE 01 ADD 01CF 91 SWAP2 01D0 85 DUP6 01D1 01 ADD 01D2 90 SWAP1 01D3 80 DUP1 01D4 83 DUP4 01D5 83 DUP4 01D6 60 PUSH1 0x00 01D8 5B JUMPDEST 01D9 83 DUP4 01DA 81 DUP2 01DB 10 LT 01DC 15 ISZERO 01DD 61 PUSH2 0x01f0 01E0 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @01C5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @01C9 stack[0] = memory[0x40:0x60] // @01CB stack[1] = memory[0x40:0x60] // @01CF stack[2] = memory[0x40:0x60] + 0x40 // @01D2 stack[3] = stack[-1] + 0x20 // @01D2 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @01D3 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @01D4 stack[6] = memory[0x40:0x60] + 0x40 // @01D5 stack[7] = stack[-1] + 0x20 // @01D6 stack[8] = 0x00 // } // Block ends with conditional jump to 0x01f0, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_01E1: // Incoming jump from 0x01E0, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x01E0, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @01E1 stack[-2] // @01E2 stack[-1] // @01E4 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01E5 stack[-3] // } 01E1 81 DUP2 01E2 81 DUP2 01E3 01 ADD 01E4 51 MLOAD 01E5 83 DUP4 01E6 82 DUP3 01E7 01 ADD 01E8 52 MSTORE 01E9 60 PUSH1 0x20 01EB 01 ADD 01EC 61 PUSH2 0x01d8 01EF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01E8 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01EB stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x01d8 label_01F0: // Incoming jump from 0x01E0, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x01E0, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @01F5 stack[-5] // @01F5 stack[-6] // @01F7 stack[-7] // } 01F0 5B JUMPDEST 01F1 50 POP 01F2 50 POP 01F3 50 POP 01F4 50 POP 01F5 90 SWAP1 01F6 50 POP 01F7 90 SWAP1 01F8 81 DUP2 01F9 01 ADD 01FA 90 SWAP1 01FB 60 PUSH1 0x1f 01FD 16 AND 01FE 80 DUP1 01FF 15 ISZERO 0200 61 PUSH2 0x021d 0203 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @01FA stack[-7] = stack[-5] + stack[-7] // @01FD stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x021d, if !(0x1f & stack[-5]) label_0204: // Incoming jump from 0x0203, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0204 stack[-1] // @0205 stack[-2] // @0208 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @021F stack[-5] // @0225 memory[0x40:0x60] // @022A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0204 80 DUP1 0205 82 DUP3 0206 03 SUB 0207 80 DUP1 0208 51 MLOAD 0209 60 PUSH1 0x01 020B 83 DUP4 020C 60 PUSH1 0x20 020E 03 SUB 020F 61 PUSH2 0x0100 0212 0A EXP 0213 03 SUB 0214 19 NOT 0215 16 AND 0216 81 DUP2 0217 52 MSTORE 0218 60 PUSH1 0x20 021A 01 ADD 021B 91 SWAP2 021C 50 POP 021D 5B JUMPDEST 021E 50 POP 021F 92 SWAP3 0220 50 POP 0221 50 POP 0222 50 POP 0223 60 PUSH1 0x40 0225 51 MLOAD 0226 80 DUP1 0227 91 SWAP2 0228 03 SUB 0229 90 SWAP1 022A F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0217 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] // @022A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_022B: // Incoming jump from 0x016F, if 0x095ea7b3 == stack[-1] // Inputs[1] { @022C msg.value } 022B 5B JUMPDEST 022C 34 CALLVALUE 022D 80 DUP1 022E 15 ISZERO 022F 61 PUSH2 0x0237 0232 57 *JUMPI // Stack delta = +1 // Outputs[1] { @022C stack[0] = msg.value } // Block ends with conditional jump to 0x0237, if !msg.value label_0233: // Incoming jump from 0x0232, if not !msg.value // Inputs[1] { @0236 memory[0x00:0x00] } 0233 60 PUSH1 0x00 0235 80 DUP1 0236 FD *REVERT // Stack delta = +0 // Outputs[1] { @0236 revert(memory[0x00:0x00]); } // Block terminates label_0237: // Incoming jump from 0x0232, if !msg.value // Inputs[1] { @023F msg.data.length } 0237 5B JUMPDEST 0238 50 POP 0239 61 PUSH2 0x0264 023C 60 PUSH1 0x04 023E 80 DUP1 023F 36 CALLDATASIZE 0240 03 SUB 0241 60 PUSH1 0x40 0243 81 DUP2 0244 10 LT 0245 15 ISZERO 0246 61 PUSH2 0x024e 0249 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0239 stack[-1] = 0x0264 // @023C stack[0] = 0x04 // @0240 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x024e, if !(msg.data.length - 0x04 < 0x40) label_024A: // Incoming jump from 0x0249, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @024D memory[0x00:0x00] } 024A 60 PUSH1 0x00 024C 80 DUP1 024D FD *REVERT // Stack delta = +0 // Outputs[1] { @024D revert(memory[0x00:0x00]); } // Block terminates label_024E: // Incoming jump from 0x0249, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0258 stack[-2] // @0259 msg.data[stack[-2]:stack[-2] + 0x20] // @025F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 024E 5B JUMPDEST 024F 50 POP 0250 60 PUSH1 0x01 0252 60 PUSH1 0x01 0254 60 PUSH1 0xa0 0256 1B SHL 0257 03 SUB 0258 81 DUP2 0259 35 CALLDATALOAD 025A 16 AND 025B 90 SWAP1 025C 60 PUSH1 0x20 025E 01 ADD 025F 35 CALLDATALOAD 0260 61 PUSH2 0x07d3 0263 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @025B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @025F stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x07d3 label_0264: // Incoming return from call to 0x0344 at 0x033F // Inputs[4] // { // @0268 memory[0x40:0x60] // @0269 stack[-1] // @026E memory[0x40:0x60] // @0277 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0264 5B JUMPDEST 0265 60 PUSH1 0x40 0267 80 DUP1 0268 51 MLOAD 0269 91 SWAP2 026A 15 ISZERO 026B 15 ISZERO 026C 82 DUP3 026D 52 MSTORE 026E 51 MLOAD 026F 90 SWAP1 0270 81 DUP2 0271 90 SWAP1 0272 03 SUB 0273 60 PUSH1 0x20 0275 01 ADD 0276 90 SWAP1 0277 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @026D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0277 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0278: // Incoming jump from 0x017A, if 0x1685cc17 == stack[-1] // Inputs[1] { @027F msg.data.length } 0278 5B JUMPDEST 0279 61 PUSH2 0x02f8 027C 60 PUSH1 0x04 027E 80 DUP1 027F 36 CALLDATASIZE 0280 03 SUB 0281 60 PUSH1 0x40 0283 81 DUP2 0284 10 LT 0285 15 ISZERO 0286 61 PUSH2 0x028e 0289 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0279 stack[0] = 0x02f8 // @027C stack[1] = 0x04 // @0280 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x028e, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x40) label_028A: // Incoming jump from 0x0289, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @028D memory[0x00:0x00] } 028A 60 PUSH1 0x00 028C 80 DUP1 028D FD *REVERT // Stack delta = +0 // Outputs[1] { @028D revert(memory[0x00:0x00]); } // Block terminates label_028E: // Incoming call from 0x0289, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0297 stack[-2] // @0298 msg.data[stack[-2]:stack[-2] + 0x20] // @029B stack[-1] // @02A7 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 028E 5B JUMPDEST 028F 60 PUSH1 0x01 0291 60 PUSH1 0x01 0293 60 PUSH1 0xa0 0295 1B SHL 0296 03 SUB 0297 82 DUP3 0298 35 CALLDATALOAD 0299 16 AND 029A 91 SWAP2 029B 90 SWAP1 029C 81 DUP2 029D 01 ADD 029E 90 SWAP1 029F 60 PUSH1 0x40 02A1 81 DUP2 02A2 01 ADD 02A3 60 PUSH1 0x20 02A5 82 DUP3 02A6 01 ADD 02A7 35 CALLDATALOAD 02A8 64 PUSH5 0x0100000000 02AE 81 DUP2 02AF 11 GT 02B0 15 ISZERO 02B1 61 PUSH2 0x02b9 02B4 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @029A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @029E stack[0] = stack[-2] // @029E stack[-1] = stack[-2] + stack[-1] // @02A2 stack[1] = stack[-2] + 0x40 // @02A7 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x02b9, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) label_02B5: // Incoming jump from 0x02B4, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[1] { @02B8 memory[0x00:0x00] } 02B5 60 PUSH1 0x00 02B7 80 DUP1 02B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B8 revert(memory[0x00:0x00]); } // Block terminates label_02B9: // Incoming jump from 0x02B4, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[3] // { // @02BA stack[-3] // @02BB stack[-1] // @02BC stack[-4] // } 02B9 5B JUMPDEST 02BA 82 DUP3 02BB 01 ADD 02BC 83 DUP4 02BD 60 PUSH1 0x20 02BF 82 DUP3 02C0 01 ADD 02C1 11 GT 02C2 15 ISZERO 02C3 61 PUSH2 0x02cb 02C6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @02BB stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x02cb, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_02C7: // Incoming jump from 0x02C6, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @02CA memory[0x00:0x00] } 02C7 60 PUSH1 0x00 02C9 80 DUP1 02CA FD *REVERT // Stack delta = +0 // Outputs[1] { @02CA revert(memory[0x00:0x00]); } // Block terminates label_02CB: // Incoming jump from 0x02C6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @02CC stack[-1] // @02CD msg.data[stack[-1]:stack[-1] + 0x20] // @02D2 stack[-2] // @02D3 stack[-4] // } 02CB 5B JUMPDEST 02CC 80 DUP1 02CD 35 CALLDATALOAD 02CE 90 SWAP1 02CF 60 PUSH1 0x20 02D1 01 ADD 02D2 91 SWAP2 02D3 84 DUP5 02D4 60 PUSH1 0x01 02D6 83 DUP4 02D7 02 MUL 02D8 84 DUP5 02D9 01 ADD 02DA 11 GT 02DB 64 PUSH5 0x0100000000 02E1 83 DUP4 02E2 11 GT 02E3 17 OR 02E4 15 ISZERO 02E5 61 PUSH2 0x02ed 02E8 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @02CE stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @02D2 stack[0] = stack[-2] // @02D2 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x02ed, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_02E9: // Incoming jump from 0x02E8, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @02EC memory[0x00:0x00] } 02E9 60 PUSH1 0x00 02EB 80 DUP1 02EC FD *REVERT // Stack delta = +0 // Outputs[1] { @02EC revert(memory[0x00:0x00]); } // Block terminates label_02ED: // Incoming jump from 0x02E8, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @02EF stack[-3] // @02EF stack[-2] // @02F0 stack[-5] // @02F2 stack[-4] // } 02ED 5B JUMPDEST 02EE 50 POP 02EF 90 SWAP1 02F0 92 SWAP3 02F1 50 POP 02F2 90 SWAP1 02F3 50 POP 02F4 61 PUSH2 0x07ea 02F7 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @02F0 stack[-5] = stack[-3] // @02F2 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x07ea label_02F8: // Incoming return from call to 0x04DC at 0x04D7 // Incoming return from call to 0x05C3 at 0x05BE // Incoming return from call to 0x0415 at 0x0410 // Incoming return from call to 0x111C at 0x056C // Incoming return from call to 0x03EB at 0x03E6 // Incoming return from call to 0x0590 at 0x058B // Incoming return from call to 0x0659 at 0x0654 // Incoming return from call to 0x044E at 0x0449 // Incoming return from call to 0x028E at 0x0289 // Incoming return from call to 0x0478 at 0x0473 02F8 5B JUMPDEST 02F9 00 *STOP // Stack delta = +0 // Outputs[1] { @02F9 stop(); } // Block terminates label_02FA: // Incoming jump from 0x0185, if 0x18160ddd == stack[-1] // Inputs[1] { @02FB msg.value } 02FA 5B JUMPDEST 02FB 34 CALLVALUE 02FC 80 DUP1 02FD 15 ISZERO 02FE 61 PUSH2 0x0306 0301 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02FB stack[0] = msg.value } // Block ends with conditional jump to 0x0306, if !msg.value label_0302: // Incoming jump from 0x0301, if not !msg.value // Inputs[1] { @0305 memory[0x00:0x00] } 0302 60 PUSH1 0x00 0304 80 DUP1 0305 FD *REVERT // Stack delta = +0 // Outputs[1] { @0305 revert(memory[0x00:0x00]); } // Block terminates label_0306: // Incoming jump from 0x0301, if !msg.value 0306 5B JUMPDEST 0307 50 POP 0308 61 PUSH2 0x030f 030B 61 PUSH2 0x08ef 030E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0308 stack[-1] = 0x030f } // Block ends with call to 0x08ef, returns to 0x030F label_030F: // Incoming return from call to 0x0692 at 0x068D // Incoming return from call to 0x08EF at 0x030E // Incoming return from call to 0x0387 at 0x0382 // Incoming return from call to 0x0548 at 0x0543 // Incoming return from call to 0x050F at 0x050A // Inputs[4] // { // @0313 memory[0x40:0x60] // @0314 stack[-1] // @0317 memory[0x40:0x60] // @0320 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 030F 5B JUMPDEST 0310 60 PUSH1 0x40 0312 80 DUP1 0313 51 MLOAD 0314 91 SWAP2 0315 82 DUP3 0316 52 MSTORE 0317 51 MLOAD 0318 90 SWAP1 0319 81 DUP2 031A 90 SWAP1 031B 03 SUB 031C 60 PUSH1 0x20 031E 01 ADD 031F 90 SWAP1 0320 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0316 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0320 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0321: // Incoming jump from 0x0190, if 0x23b872dd == stack[-1] // Inputs[1] { @0322 msg.value } 0321 5B JUMPDEST 0322 34 CALLVALUE 0323 80 DUP1 0324 15 ISZERO 0325 61 PUSH2 0x032d 0328 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0322 stack[0] = msg.value } // Block ends with conditional jump to 0x032d, if !msg.value label_0329: // Incoming jump from 0x0328, if not !msg.value // Inputs[1] { @032C memory[0x00:0x00] } 0329 60 PUSH1 0x00 032B 80 DUP1 032C FD *REVERT // Stack delta = +0 // Outputs[1] { @032C revert(memory[0x00:0x00]); } // Block terminates label_032D: // Incoming jump from 0x0328, if !msg.value // Inputs[1] { @0335 msg.data.length } 032D 5B JUMPDEST 032E 50 POP 032F 61 PUSH2 0x0264 0332 60 PUSH1 0x04 0334 80 DUP1 0335 36 CALLDATASIZE 0336 03 SUB 0337 60 PUSH1 0x60 0339 81 DUP2 033A 10 LT 033B 15 ISZERO 033C 61 PUSH2 0x0344 033F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @032F stack[-1] = 0x0264 // @0332 stack[0] = 0x04 // @0336 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0344, returns to 0x0264, if !(msg.data.length - 0x04 < 0x60) label_0340: // Incoming jump from 0x033F, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0343 memory[0x00:0x00] } 0340 60 PUSH1 0x00 0342 80 DUP1 0343 FD *REVERT // Stack delta = +0 // Outputs[1] { @0343 revert(memory[0x00:0x00]); } // Block terminates label_0344: // Incoming call from 0x033F, returns to 0x0264, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @034E stack[-2] // @034F msg.data[stack[-2]:stack[-2] + 0x20] // @0357 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @035F msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 0344 5B JUMPDEST 0345 50 POP 0346 60 PUSH1 0x01 0348 60 PUSH1 0x01 034A 60 PUSH1 0xa0 034C 1B SHL 034D 03 SUB 034E 81 DUP2 034F 35 CALLDATALOAD 0350 81 DUP2 0351 16 AND 0352 91 SWAP2 0353 60 PUSH1 0x20 0355 81 DUP2 0356 01 ADD 0357 35 CALLDATALOAD 0358 90 SWAP1 0359 91 SWAP2 035A 16 AND 035B 90 SWAP1 035C 60 PUSH1 0x40 035E 01 ADD 035F 35 CALLDATALOAD 0360 61 PUSH2 0x08f5 0363 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0352 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @035B stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @035F stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x08f5 label_0364: // Incoming jump from 0x019B, if 0x26599850 == stack[-1] // Inputs[1] { @0365 msg.value } 0364 5B JUMPDEST 0365 34 CALLVALUE 0366 80 DUP1 0367 15 ISZERO 0368 61 PUSH2 0x0370 036B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0365 stack[0] = msg.value } // Block ends with conditional jump to 0x0370, if !msg.value label_036C: // Incoming jump from 0x036B, if not !msg.value // Inputs[1] { @036F memory[0x00:0x00] } 036C 60 PUSH1 0x00 036E 80 DUP1 036F FD *REVERT // Stack delta = +0 // Outputs[1] { @036F revert(memory[0x00:0x00]); } // Block terminates label_0370: // Incoming jump from 0x036B, if !msg.value // Inputs[1] { @0378 msg.data.length } 0370 5B JUMPDEST 0371 50 POP 0372 61 PUSH2 0x030f 0375 60 PUSH1 0x04 0377 80 DUP1 0378 36 CALLDATASIZE 0379 03 SUB 037A 60 PUSH1 0x40 037C 81 DUP2 037D 10 LT 037E 15 ISZERO 037F 61 PUSH2 0x0387 0382 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0372 stack[-1] = 0x030f // @0375 stack[0] = 0x04 // @0379 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0387, returns to 0x030F, if !(msg.data.length - 0x04 < 0x40) label_0383: // Incoming jump from 0x0382, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0386 memory[0x00:0x00] } 0383 60 PUSH1 0x00 0385 80 DUP1 0386 FD *REVERT // Stack delta = +0 // Outputs[1] { @0386 revert(memory[0x00:0x00]); } // Block terminates label_0387: // Incoming call from 0x0382, returns to 0x030F, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0389 stack[-2] // @038A msg.data[stack[-2]:stack[-2] + 0x20] // @038F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0387 5B JUMPDEST 0388 50 POP 0389 80 DUP1 038A 35 CALLDATALOAD 038B 90 SWAP1 038C 60 PUSH1 0x20 038E 01 ADD 038F 35 CALLDATALOAD 0390 60 PUSH1 0x01 0392 60 PUSH1 0x01 0394 60 PUSH1 0xa0 0396 1B SHL 0397 03 SUB 0398 16 AND 0399 61 PUSH2 0x098f 039C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @038B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0398 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x098f label_039D: // Incoming jump from 0x013E, if 0x313ce567 == stack[-1] // Inputs[1] { @039E msg.value } 039D 5B JUMPDEST 039E 34 CALLVALUE 039F 80 DUP1 03A0 15 ISZERO 03A1 61 PUSH2 0x03a9 03A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @039E stack[0] = msg.value } // Block ends with conditional jump to 0x03a9, if !msg.value label_03A5: // Incoming jump from 0x03A4, if not !msg.value // Inputs[1] { @03A8 memory[0x00:0x00] } 03A5 60 PUSH1 0x00 03A7 80 DUP1 03A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A8 revert(memory[0x00:0x00]); } // Block terminates label_03A9: // Incoming jump from 0x03A4, if !msg.value 03A9 5B JUMPDEST 03AA 50 POP 03AB 61 PUSH2 0x03b2 03AE 61 PUSH2 0x0c2e 03B1 56 *JUMP // Stack delta = +0 // Outputs[1] { @03AB stack[-1] = 0x03b2 } // Block ends with call to 0x0c2e, returns to 0x03B2 label_03B2: // Incoming return from call to 0x0C2E at 0x03B1 // Inputs[4] // { // @03B6 memory[0x40:0x60] // @03BA stack[-1] // @03BE memory[0x40:0x60] // @03C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 03B2 5B JUMPDEST 03B3 60 PUSH1 0x40 03B5 80 DUP1 03B6 51 MLOAD 03B7 60 PUSH1 0xff 03B9 90 SWAP1 03BA 92 SWAP3 03BB 16 AND 03BC 82 DUP3 03BD 52 MSTORE 03BE 51 MLOAD 03BF 90 SWAP1 03C0 81 DUP2 03C1 90 SWAP1 03C2 03 SUB 03C3 60 PUSH1 0x20 03C5 01 ADD 03C6 90 SWAP1 03C7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @03C7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_03C8: // Incoming jump from 0x0149, if 0x3fdb93f6 == stack[-1] // Inputs[1] { @03C9 msg.value } 03C8 5B JUMPDEST 03C9 34 CALLVALUE 03CA 80 DUP1 03CB 15 ISZERO 03CC 61 PUSH2 0x03d4 03CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C9 stack[0] = msg.value } // Block ends with conditional jump to 0x03d4, if !msg.value label_03D0: // Incoming jump from 0x03CF, if not !msg.value // Inputs[1] { @03D3 memory[0x00:0x00] } 03D0 60 PUSH1 0x00 03D2 80 DUP1 03D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D3 revert(memory[0x00:0x00]); } // Block terminates label_03D4: // Incoming jump from 0x03CF, if !msg.value // Inputs[1] { @03DC msg.data.length } 03D4 5B JUMPDEST 03D5 50 POP 03D6 61 PUSH2 0x02f8 03D9 60 PUSH1 0x04 03DB 80 DUP1 03DC 36 CALLDATASIZE 03DD 03 SUB 03DE 60 PUSH1 0x20 03E0 81 DUP2 03E1 10 LT 03E2 15 ISZERO 03E3 61 PUSH2 0x03eb 03E6 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03D6 stack[-1] = 0x02f8 // @03D9 stack[0] = 0x04 // @03DD stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03eb, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) label_03E7: // Incoming jump from 0x03E6, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @03EA memory[0x00:0x00] } 03E7 60 PUSH1 0x00 03E9 80 DUP1 03EA FD *REVERT // Stack delta = +0 // Outputs[1] { @03EA revert(memory[0x00:0x00]); } // Block terminates label_03EB: // Incoming call from 0x03E6, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @03ED stack[-2] // @03ED msg.data[stack[-2]:stack[-2] + 0x20] // } 03EB 5B JUMPDEST 03EC 50 POP 03ED 35 CALLDATALOAD 03EE 61 PUSH2 0x0c37 03F1 56 *JUMP // Stack delta = -1 // Outputs[1] { @03ED stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0c37 label_03F2: // Incoming jump from 0x0154, if 0x40c10f19 == stack[-1] // Inputs[1] { @03F3 msg.value } 03F2 5B JUMPDEST 03F3 34 CALLVALUE 03F4 80 DUP1 03F5 15 ISZERO 03F6 61 PUSH2 0x03fe 03F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F3 stack[0] = msg.value } // Block ends with conditional jump to 0x03fe, if !msg.value label_03FA: // Incoming jump from 0x03F9, if not !msg.value // Inputs[1] { @03FD memory[0x00:0x00] } 03FA 60 PUSH1 0x00 03FC 80 DUP1 03FD FD *REVERT // Stack delta = +0 // Outputs[1] { @03FD revert(memory[0x00:0x00]); } // Block terminates label_03FE: // Incoming jump from 0x03F9, if !msg.value // Inputs[1] { @0406 msg.data.length } 03FE 5B JUMPDEST 03FF 50 POP 0400 61 PUSH2 0x02f8 0403 60 PUSH1 0x04 0405 80 DUP1 0406 36 CALLDATASIZE 0407 03 SUB 0408 60 PUSH1 0x40 040A 81 DUP2 040B 10 LT 040C 15 ISZERO 040D 61 PUSH2 0x0415 0410 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0400 stack[-1] = 0x02f8 // @0403 stack[0] = 0x04 // @0407 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0415, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x40) label_0411: // Incoming jump from 0x0410, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0414 memory[0x00:0x00] } 0411 60 PUSH1 0x00 0413 80 DUP1 0414 FD *REVERT // Stack delta = +0 // Outputs[1] { @0414 revert(memory[0x00:0x00]); } // Block terminates label_0415: // Incoming call from 0x0410, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @041F stack[-2] // @0420 msg.data[stack[-2]:stack[-2] + 0x20] // @0426 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0415 5B JUMPDEST 0416 50 POP 0417 60 PUSH1 0x01 0419 60 PUSH1 0x01 041B 60 PUSH1 0xa0 041D 1B SHL 041E 03 SUB 041F 81 DUP2 0420 35 CALLDATALOAD 0421 16 AND 0422 90 SWAP1 0423 60 PUSH1 0x20 0425 01 ADD 0426 35 CALLDATALOAD 0427 61 PUSH2 0x0cac 042A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0422 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0426 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0cac label_042B: // Incoming jump from 0x010D, if 0x42966c68 == stack[-1] // Inputs[1] { @042C msg.value } 042B 5B JUMPDEST 042C 34 CALLVALUE 042D 80 DUP1 042E 15 ISZERO 042F 61 PUSH2 0x0437 0432 57 *JUMPI // Stack delta = +1 // Outputs[1] { @042C stack[0] = msg.value } // Block ends with conditional jump to 0x0437, if !msg.value label_0433: // Incoming jump from 0x0432, if not !msg.value // Inputs[1] { @0436 memory[0x00:0x00] } 0433 60 PUSH1 0x00 0435 80 DUP1 0436 FD *REVERT // Stack delta = +0 // Outputs[1] { @0436 revert(memory[0x00:0x00]); } // Block terminates label_0437: // Incoming jump from 0x0432, if !msg.value // Inputs[1] { @043F msg.data.length } 0437 5B JUMPDEST 0438 50 POP 0439 61 PUSH2 0x02f8 043C 60 PUSH1 0x04 043E 80 DUP1 043F 36 CALLDATASIZE 0440 03 SUB 0441 60 PUSH1 0x20 0443 81 DUP2 0444 10 LT 0445 15 ISZERO 0446 61 PUSH2 0x044e 0449 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0439 stack[-1] = 0x02f8 // @043C stack[0] = 0x04 // @0440 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x044e, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) label_044A: // Incoming jump from 0x0449, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @044D memory[0x00:0x00] } 044A 60 PUSH1 0x00 044C 80 DUP1 044D FD *REVERT // Stack delta = +0 // Outputs[1] { @044D revert(memory[0x00:0x00]); } // Block terminates label_044E: // Incoming call from 0x0449, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0450 msg.data[stack[-2]:stack[-2] + 0x20] // @0450 stack[-2] // } 044E 5B JUMPDEST 044F 50 POP 0450 35 CALLDATALOAD 0451 61 PUSH2 0x0d50 0454 56 *JUMP // Stack delta = -1 // Outputs[1] { @0450 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0d50 label_0455: // Incoming jump from 0x0118, if 0x51cff8d9 == stack[-1] // Inputs[1] { @0456 msg.value } 0455 5B JUMPDEST 0456 34 CALLVALUE 0457 80 DUP1 0458 15 ISZERO 0459 61 PUSH2 0x0461 045C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0456 stack[0] = msg.value } // Block ends with conditional jump to 0x0461, if !msg.value label_045D: // Incoming jump from 0x045C, if not !msg.value // Inputs[1] { @0460 memory[0x00:0x00] } 045D 60 PUSH1 0x00 045F 80 DUP1 0460 FD *REVERT // Stack delta = +0 // Outputs[1] { @0460 revert(memory[0x00:0x00]); } // Block terminates label_0461: // Incoming jump from 0x045C, if !msg.value // Inputs[1] { @0469 msg.data.length } 0461 5B JUMPDEST 0462 50 POP 0463 61 PUSH2 0x02f8 0466 60 PUSH1 0x04 0468 80 DUP1 0469 36 CALLDATASIZE 046A 03 SUB 046B 60 PUSH1 0x20 046D 81 DUP2 046E 10 LT 046F 15 ISZERO 0470 61 PUSH2 0x0478 0473 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0463 stack[-1] = 0x02f8 // @0466 stack[0] = 0x04 // @046A stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0478, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) label_0474: // Incoming jump from 0x0473, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0477 memory[0x00:0x00] } 0474 60 PUSH1 0x00 0476 80 DUP1 0477 FD *REVERT // Stack delta = +0 // Outputs[1] { @0477 revert(memory[0x00:0x00]); } // Block terminates label_0478: // Incoming call from 0x0473, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @047A msg.data[stack[-2]:stack[-2] + 0x20] // @047A stack[-2] // } 0478 5B JUMPDEST 0479 50 POP 047A 35 CALLDATALOAD 047B 60 PUSH1 0x01 047D 60 PUSH1 0x01 047F 60 PUSH1 0xa0 0481 1B SHL 0482 03 SUB 0483 16 AND 0484 61 PUSH2 0x0d83 0487 56 *JUMP // Stack delta = -1 // Outputs[1] { @0483 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0d83 label_0488: // Incoming jump from 0x0123, if 0x55df2ee7 == stack[-1] // Inputs[1] { @0489 msg.value } 0488 5B JUMPDEST 0489 34 CALLVALUE 048A 80 DUP1 048B 15 ISZERO 048C 61 PUSH2 0x0494 048F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0489 stack[0] = msg.value } // Block ends with conditional jump to 0x0494, if !msg.value label_0490: // Incoming jump from 0x048F, if not !msg.value // Inputs[1] { @0493 memory[0x00:0x00] } 0490 60 PUSH1 0x00 0492 80 DUP1 0493 FD *REVERT // Stack delta = +0 // Outputs[1] { @0493 revert(memory[0x00:0x00]); } // Block terminates label_0494: // Incoming jump from 0x048F, if !msg.value 0494 5B JUMPDEST 0495 50 POP 0496 61 PUSH2 0x049d 0499 61 PUSH2 0x0f51 049C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0496 stack[-1] = 0x049d } // Block ends with call to 0x0f51, returns to 0x049D label_049D: // Incoming return from call to 0x1296 at 0x05E7 // Incoming return from call to 0x0F51 at 0x049C // Incoming return from call to 0x1442 at 0x0745 // Inputs[4] // { // @04A1 memory[0x40:0x60] // @04AB stack[-1] // @04AF memory[0x40:0x60] // @04B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 049D 5B JUMPDEST 049E 60 PUSH1 0x40 04A0 80 DUP1 04A1 51 MLOAD 04A2 60 PUSH1 0x01 04A4 60 PUSH1 0x01 04A6 60 PUSH1 0xa0 04A8 1B SHL 04A9 03 SUB 04AA 90 SWAP1 04AB 92 SWAP3 04AC 16 AND 04AD 82 DUP3 04AE 52 MSTORE 04AF 51 MLOAD 04B0 90 SWAP1 04B1 81 DUP2 04B2 90 SWAP1 04B3 03 SUB 04B4 60 PUSH1 0x20 04B6 01 ADD 04B7 90 SWAP1 04B8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @04B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_04B9: // Incoming jump from 0x012E, if 0x5d235e79 == stack[-1] // Inputs[1] { @04BA msg.value } 04B9 5B JUMPDEST 04BA 34 CALLVALUE 04BB 80 DUP1 04BC 15 ISZERO 04BD 61 PUSH2 0x04c5 04C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04BA stack[0] = msg.value } // Block ends with conditional jump to 0x04c5, if !msg.value label_04C1: // Incoming jump from 0x04C0, if not !msg.value // Inputs[1] { @04C4 memory[0x00:0x00] } 04C1 60 PUSH1 0x00 04C3 80 DUP1 04C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C4 revert(memory[0x00:0x00]); } // Block terminates label_04C5: // Incoming jump from 0x04C0, if !msg.value // Inputs[1] { @04CD msg.data.length } 04C5 5B JUMPDEST 04C6 50 POP 04C7 61 PUSH2 0x02f8 04CA 60 PUSH1 0x04 04CC 80 DUP1 04CD 36 CALLDATASIZE 04CE 03 SUB 04CF 60 PUSH1 0x20 04D1 81 DUP2 04D2 10 LT 04D3 15 ISZERO 04D4 61 PUSH2 0x04dc 04D7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04C7 stack[-1] = 0x02f8 // @04CA stack[0] = 0x04 // @04CE stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04dc, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) label_04D8: // Incoming jump from 0x04D7, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04DB memory[0x00:0x00] } 04D8 60 PUSH1 0x00 04DA 80 DUP1 04DB FD *REVERT // Stack delta = +0 // Outputs[1] { @04DB revert(memory[0x00:0x00]); } // Block terminates label_04DC: // Incoming call from 0x04D7, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04DE stack[-2] // @04DE msg.data[stack[-2]:stack[-2] + 0x20] // } 04DC 5B JUMPDEST 04DD 50 POP 04DE 35 CALLDATALOAD 04DF 60 PUSH1 0x01 04E1 60 PUSH1 0x01 04E3 60 PUSH1 0xa0 04E5 1B SHL 04E6 03 SUB 04E7 16 AND 04E8 61 PUSH2 0x0f60 04EB 56 *JUMP // Stack delta = -1 // Outputs[1] { @04E7 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0f60 label_04EC: // Incoming jump from 0x00D1, if 0x5dbd6059 == stack[-1] // Inputs[1] { @04ED msg.value } 04EC 5B JUMPDEST 04ED 34 CALLVALUE 04EE 80 DUP1 04EF 15 ISZERO 04F0 61 PUSH2 0x04f8 04F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04ED stack[0] = msg.value } // Block ends with conditional jump to 0x04f8, if !msg.value label_04F4: // Incoming jump from 0x04F3, if not !msg.value // Inputs[1] { @04F7 memory[0x00:0x00] } 04F4 60 PUSH1 0x00 04F6 80 DUP1 04F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F7 revert(memory[0x00:0x00]); } // Block terminates label_04F8: // Incoming jump from 0x04F3, if !msg.value // Inputs[1] { @0500 msg.data.length } 04F8 5B JUMPDEST 04F9 50 POP 04FA 61 PUSH2 0x030f 04FD 60 PUSH1 0x04 04FF 80 DUP1 0500 36 CALLDATASIZE 0501 03 SUB 0502 60 PUSH1 0x40 0504 81 DUP2 0505 10 LT 0506 15 ISZERO 0507 61 PUSH2 0x050f 050A 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04FA stack[-1] = 0x030f // @04FD stack[0] = 0x04 // @0501 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x050f, returns to 0x030F, if !(msg.data.length - 0x04 < 0x40) label_050B: // Incoming jump from 0x050A, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @050E memory[0x00:0x00] } 050B 60 PUSH1 0x00 050D 80 DUP1 050E FD *REVERT // Stack delta = +0 // Outputs[1] { @050E revert(memory[0x00:0x00]); } // Block terminates label_050F: // Incoming call from 0x050A, returns to 0x030F, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0511 stack[-2] // @0512 msg.data[stack[-2]:stack[-2] + 0x20] // @0517 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 050F 5B JUMPDEST 0510 50 POP 0511 80 DUP1 0512 35 CALLDATALOAD 0513 90 SWAP1 0514 60 PUSH1 0x20 0516 01 ADD 0517 35 CALLDATALOAD 0518 60 PUSH1 0x01 051A 60 PUSH1 0x01 051C 60 PUSH1 0xa0 051E 1B SHL 051F 03 SUB 0520 16 AND 0521 61 PUSH2 0x1062 0524 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0513 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0520 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1062 label_0525: // Incoming jump from 0x00DC, if 0x70a08231 == stack[-1] // Inputs[1] { @0526 msg.value } 0525 5B JUMPDEST 0526 34 CALLVALUE 0527 80 DUP1 0528 15 ISZERO 0529 61 PUSH2 0x0531 052C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0526 stack[0] = msg.value } // Block ends with conditional jump to 0x0531, if !msg.value label_052D: // Incoming jump from 0x052C, if not !msg.value // Inputs[1] { @0530 memory[0x00:0x00] } 052D 60 PUSH1 0x00 052F 80 DUP1 0530 FD *REVERT // Stack delta = +0 // Outputs[1] { @0530 revert(memory[0x00:0x00]); } // Block terminates label_0531: // Incoming jump from 0x052C, if !msg.value // Inputs[1] { @0539 msg.data.length } 0531 5B JUMPDEST 0532 50 POP 0533 61 PUSH2 0x030f 0536 60 PUSH1 0x04 0538 80 DUP1 0539 36 CALLDATASIZE 053A 03 SUB 053B 60 PUSH1 0x20 053D 81 DUP2 053E 10 LT 053F 15 ISZERO 0540 61 PUSH2 0x0548 0543 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0533 stack[-1] = 0x030f // @0536 stack[0] = 0x04 // @053A stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0548, returns to 0x030F, if !(msg.data.length - 0x04 < 0x20) label_0544: // Incoming jump from 0x0543, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0547 memory[0x00:0x00] } 0544 60 PUSH1 0x00 0546 80 DUP1 0547 FD *REVERT // Stack delta = +0 // Outputs[1] { @0547 revert(memory[0x00:0x00]); } // Block terminates label_0548: // Incoming call from 0x0543, returns to 0x030F, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @054A stack[-2] // @054A msg.data[stack[-2]:stack[-2] + 0x20] // } 0548 5B JUMPDEST 0549 50 POP 054A 35 CALLDATALOAD 054B 60 PUSH1 0x01 054D 60 PUSH1 0x01 054F 60 PUSH1 0xa0 0551 1B SHL 0552 03 SUB 0553 16 AND 0554 61 PUSH2 0x110a 0557 56 *JUMP // Stack delta = -1 // Outputs[1] { @0553 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x110a label_0558: // Incoming jump from 0x00E7, if 0x715018a6 == stack[-1] // Inputs[1] { @0559 msg.value } 0558 5B JUMPDEST 0559 34 CALLVALUE 055A 80 DUP1 055B 15 ISZERO 055C 61 PUSH2 0x0564 055F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0559 stack[0] = msg.value } // Block ends with conditional jump to 0x0564, if !msg.value label_0560: // Incoming jump from 0x055F, if not !msg.value // Inputs[1] { @0563 memory[0x00:0x00] } 0560 60 PUSH1 0x00 0562 80 DUP1 0563 FD *REVERT // Stack delta = +0 // Outputs[1] { @0563 revert(memory[0x00:0x00]); } // Block terminates label_0564: // Incoming jump from 0x055F, if !msg.value 0564 5B JUMPDEST 0565 50 POP 0566 61 PUSH2 0x02f8 0569 61 PUSH2 0x111c 056C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0566 stack[-1] = 0x02f8 } // Block ends with call to 0x111c, returns to 0x02F8 label_056D: // Incoming jump from 0x00A0, if 0x7413a790 == stack[-1] // Inputs[1] { @056E msg.value } 056D 5B JUMPDEST 056E 34 CALLVALUE 056F 80 DUP1 0570 15 ISZERO 0571 61 PUSH2 0x0579 0574 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056E stack[0] = msg.value } // Block ends with conditional jump to 0x0579, if !msg.value label_0575: // Incoming jump from 0x0574, if not !msg.value // Inputs[1] { @0578 memory[0x00:0x00] } 0575 60 PUSH1 0x00 0577 80 DUP1 0578 FD *REVERT // Stack delta = +0 // Outputs[1] { @0578 revert(memory[0x00:0x00]); } // Block terminates label_0579: // Incoming jump from 0x0574, if !msg.value // Inputs[1] { @0581 msg.data.length } 0579 5B JUMPDEST 057A 50 POP 057B 61 PUSH2 0x02f8 057E 60 PUSH1 0x04 0580 80 DUP1 0581 36 CALLDATASIZE 0582 03 SUB 0583 60 PUSH1 0x20 0585 81 DUP2 0586 10 LT 0587 15 ISZERO 0588 61 PUSH2 0x0590 058B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @057B stack[-1] = 0x02f8 // @057E stack[0] = 0x04 // @0582 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0590, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) label_058C: // Incoming jump from 0x058B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @058F memory[0x00:0x00] } 058C 60 PUSH1 0x00 058E 80 DUP1 058F FD *REVERT // Stack delta = +0 // Outputs[1] { @058F revert(memory[0x00:0x00]); } // Block terminates label_0590: // Incoming call from 0x058B, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0592 msg.data[stack[-2]:stack[-2] + 0x20] // @0592 stack[-2] // } 0590 5B JUMPDEST 0591 50 POP 0592 35 CALLDATALOAD 0593 60 PUSH1 0x01 0595 60 PUSH1 0x01 0597 60 PUSH1 0xa0 0599 1B SHL 059A 03 SUB 059B 16 AND 059C 61 PUSH2 0x119c 059F 56 *JUMP // Stack delta = -1 // Outputs[1] { @059B stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x119c label_05A0: // Incoming jump from 0x00AB, if 0x8ca56fa5 == stack[-1] // Inputs[1] { @05A1 msg.value } 05A0 5B JUMPDEST 05A1 34 CALLVALUE 05A2 80 DUP1 05A3 15 ISZERO 05A4 61 PUSH2 0x05ac 05A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A1 stack[0] = msg.value } // Block ends with conditional jump to 0x05ac, if !msg.value label_05A8: // Incoming jump from 0x05A7, if not !msg.value // Inputs[1] { @05AB memory[0x00:0x00] } 05A8 60 PUSH1 0x00 05AA 80 DUP1 05AB FD *REVERT // Stack delta = +0 // Outputs[1] { @05AB revert(memory[0x00:0x00]); } // Block terminates label_05AC: // Incoming jump from 0x05A7, if !msg.value // Inputs[1] { @05B4 msg.data.length } 05AC 5B JUMPDEST 05AD 50 POP 05AE 61 PUSH2 0x02f8 05B1 60 PUSH1 0x04 05B3 80 DUP1 05B4 36 CALLDATASIZE 05B5 03 SUB 05B6 60 PUSH1 0x20 05B8 81 DUP2 05B9 10 LT 05BA 15 ISZERO 05BB 61 PUSH2 0x05c3 05BE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @05AE stack[-1] = 0x02f8 // @05B1 stack[0] = 0x04 // @05B5 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05c3, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) label_05BF: // Incoming jump from 0x05BE, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05C2 memory[0x00:0x00] } 05BF 60 PUSH1 0x00 05C1 80 DUP1 05C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C2 revert(memory[0x00:0x00]); } // Block terminates label_05C3: // Incoming call from 0x05BE, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05C5 stack[-2] // @05C5 msg.data[stack[-2]:stack[-2] + 0x20] // } 05C3 5B JUMPDEST 05C4 50 POP 05C5 35 CALLDATALOAD 05C6 60 PUSH1 0x01 05C8 60 PUSH1 0x01 05CA 60 PUSH1 0xa0 05CC 1B SHL 05CD 03 SUB 05CE 16 AND 05CF 61 PUSH2 0x1219 05D2 56 *JUMP // Stack delta = -1 // Outputs[1] { @05CE stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1219 label_05D3: // Incoming jump from 0x00B6, if 0x8da5cb5b == stack[-1] // Inputs[1] { @05D4 msg.value } 05D3 5B JUMPDEST 05D4 34 CALLVALUE 05D5 80 DUP1 05D6 15 ISZERO 05D7 61 PUSH2 0x05df 05DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D4 stack[0] = msg.value } // Block ends with conditional jump to 0x05df, if !msg.value label_05DB: // Incoming jump from 0x05DA, if not !msg.value // Inputs[1] { @05DE memory[0x00:0x00] } 05DB 60 PUSH1 0x00 05DD 80 DUP1 05DE FD *REVERT // Stack delta = +0 // Outputs[1] { @05DE revert(memory[0x00:0x00]); } // Block terminates label_05DF: // Incoming jump from 0x05DA, if !msg.value 05DF 5B JUMPDEST 05E0 50 POP 05E1 61 PUSH2 0x049d 05E4 61 PUSH2 0x1296 05E7 56 *JUMP // Stack delta = +0 // Outputs[1] { @05E1 stack[-1] = 0x049d } // Block ends with call to 0x1296, returns to 0x049D label_05E8: // Incoming jump from 0x00C1, if 0x95d89b41 == stack[-1] // Inputs[1] { @05E9 msg.value } 05E8 5B JUMPDEST 05E9 34 CALLVALUE 05EA 80 DUP1 05EB 15 ISZERO 05EC 61 PUSH2 0x05f4 05EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E9 stack[0] = msg.value } // Block ends with conditional jump to 0x05f4, if !msg.value label_05F0: // Incoming jump from 0x05EF, if not !msg.value // Inputs[1] { @05F3 memory[0x00:0x00] } 05F0 60 PUSH1 0x00 05F2 80 DUP1 05F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F3 revert(memory[0x00:0x00]); } // Block terminates label_05F4: // Incoming jump from 0x05EF, if !msg.value 05F4 5B JUMPDEST 05F5 50 POP 05F6 61 PUSH2 0x01b6 05F9 61 PUSH2 0x12a5 05FC 56 *JUMP // Stack delta = +0 // Outputs[1] { @05F6 stack[-1] = 0x01b6 } // Block ends with call to 0x12a5, returns to 0x01B6 label_05FD: // Incoming jump from 0x006F, if 0xa9059cbb == stack[-1] // Inputs[1] { @05FE msg.value } 05FD 5B JUMPDEST 05FE 34 CALLVALUE 05FF 80 DUP1 0600 15 ISZERO 0601 61 PUSH2 0x0609 0604 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05FE stack[0] = msg.value } // Block ends with conditional jump to 0x0609, if !msg.value label_0605: // Incoming jump from 0x0604, if not !msg.value // Inputs[1] { @0608 memory[0x00:0x00] } 0605 60 PUSH1 0x00 0607 80 DUP1 0608 FD *REVERT // Stack delta = +0 // Outputs[1] { @0608 revert(memory[0x00:0x00]); } // Block terminates label_0609: // Incoming jump from 0x0604, if !msg.value // Inputs[1] { @0611 msg.data.length } 0609 5B JUMPDEST 060A 50 POP 060B 61 PUSH2 0x0264 060E 60 PUSH1 0x04 0610 80 DUP1 0611 36 CALLDATASIZE 0612 03 SUB 0613 60 PUSH1 0x40 0615 81 DUP2 0616 10 LT 0617 15 ISZERO 0618 61 PUSH2 0x0620 061B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @060B stack[-1] = 0x0264 // @060E stack[0] = 0x04 // @0612 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0620, if !(msg.data.length - 0x04 < 0x40) label_061C: // Incoming jump from 0x061B, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @061F memory[0x00:0x00] } 061C 60 PUSH1 0x00 061E 80 DUP1 061F FD *REVERT // Stack delta = +0 // Outputs[1] { @061F revert(memory[0x00:0x00]); } // Block terminates label_0620: // Incoming jump from 0x061B, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @062A stack[-2] // @062B msg.data[stack[-2]:stack[-2] + 0x20] // @0631 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0620 5B JUMPDEST 0621 50 POP 0622 60 PUSH1 0x01 0624 60 PUSH1 0x01 0626 60 PUSH1 0xa0 0628 1B SHL 0629 03 SUB 062A 81 DUP2 062B 35 CALLDATALOAD 062C 16 AND 062D 90 SWAP1 062E 60 PUSH1 0x20 0630 01 ADD 0631 35 CALLDATALOAD 0632 61 PUSH2 0x12fd 0635 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @062D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0631 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x12fd label_0636: // Incoming jump from 0x007A, if 0xa96623a8 == stack[-1] // Inputs[1] { @0637 msg.value } 0636 5B JUMPDEST 0637 34 CALLVALUE 0638 80 DUP1 0639 15 ISZERO 063A 61 PUSH2 0x0642 063D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0637 stack[0] = msg.value } // Block ends with conditional jump to 0x0642, if !msg.value label_063E: // Incoming jump from 0x063D, if not !msg.value // Inputs[1] { @0641 memory[0x00:0x00] } 063E 60 PUSH1 0x00 0640 80 DUP1 0641 FD *REVERT // Stack delta = +0 // Outputs[1] { @0641 revert(memory[0x00:0x00]); } // Block terminates label_0642: // Incoming jump from 0x063D, if !msg.value // Inputs[1] { @064A msg.data.length } 0642 5B JUMPDEST 0643 50 POP 0644 61 PUSH2 0x02f8 0647 60 PUSH1 0x04 0649 80 DUP1 064A 36 CALLDATASIZE 064B 03 SUB 064C 60 PUSH1 0x40 064E 81 DUP2 064F 10 LT 0650 15 ISZERO 0651 61 PUSH2 0x0659 0654 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0644 stack[-1] = 0x02f8 // @0647 stack[0] = 0x04 // @064B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0659, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x40) label_0655: // Incoming jump from 0x0654, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0658 memory[0x00:0x00] } 0655 60 PUSH1 0x00 0657 80 DUP1 0658 FD *REVERT // Stack delta = +0 // Outputs[1] { @0658 revert(memory[0x00:0x00]); } // Block terminates label_0659: // Incoming call from 0x0654, returns to 0x02F8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0663 stack[-2] // @0664 msg.data[stack[-2]:stack[-2] + 0x20] // @066A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0659 5B JUMPDEST 065A 50 POP 065B 60 PUSH1 0x01 065D 60 PUSH1 0x01 065F 60 PUSH1 0xa0 0661 1B SHL 0662 03 SUB 0663 81 DUP2 0664 35 CALLDATALOAD 0665 16 AND 0666 90 SWAP1 0667 60 PUSH1 0x20 0669 01 ADD 066A 35 CALLDATALOAD 066B 61 PUSH2 0x130a 066E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0666 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @066A stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x130a label_066F: // Incoming jump from 0x0085, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0670 msg.value } 066F 5B JUMPDEST 0670 34 CALLVALUE 0671 80 DUP1 0672 15 ISZERO 0673 61 PUSH2 0x067b 0676 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0670 stack[0] = msg.value } // Block ends with conditional jump to 0x067b, if !msg.value label_0677: // Incoming jump from 0x0676, if not !msg.value // Inputs[1] { @067A memory[0x00:0x00] } 0677 60 PUSH1 0x00 0679 80 DUP1 067A FD *REVERT // Stack delta = +0 // Outputs[1] { @067A revert(memory[0x00:0x00]); } // Block terminates label_067B: // Incoming jump from 0x0676, if !msg.value // Inputs[1] { @0683 msg.data.length } 067B 5B JUMPDEST 067C 50 POP 067D 61 PUSH2 0x030f 0680 60 PUSH1 0x04 0682 80 DUP1 0683 36 CALLDATASIZE 0684 03 SUB 0685 60 PUSH1 0x40 0687 81 DUP2 0688 10 LT 0689 15 ISZERO 068A 61 PUSH2 0x0692 068D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @067D stack[-1] = 0x030f // @0680 stack[0] = 0x04 // @0684 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0692, returns to 0x030F, if !(msg.data.length - 0x04 < 0x40) label_068E: // Incoming jump from 0x068D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0691 memory[0x00:0x00] } 068E 60 PUSH1 0x00 0690 80 DUP1 0691 FD *REVERT // Stack delta = +0 // Outputs[1] { @0691 revert(memory[0x00:0x00]); } // Block terminates label_0692: // Incoming call from 0x068D, returns to 0x030F, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @069C stack[-2] // @069D msg.data[stack[-2]:stack[-2] + 0x20] // @06A4 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0692 5B JUMPDEST 0693 50 POP 0694 60 PUSH1 0x01 0696 60 PUSH1 0x01 0698 60 PUSH1 0xa0 069A 1B SHL 069B 03 SUB 069C 81 DUP2 069D 35 CALLDATALOAD 069E 81 DUP2 069F 16 AND 06A0 91 SWAP2 06A1 60 PUSH1 0x20 06A3 01 ADD 06A4 35 CALLDATALOAD 06A5 16 AND 06A6 61 PUSH2 0x134b 06A9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06A0 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @06A5 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x134b label_06AA: // Incoming jump from 0x003E, if 0xde0e9a3e == stack[-1] // Inputs[1] { @06AB msg.value } 06AA 5B JUMPDEST 06AB 34 CALLVALUE 06AC 80 DUP1 06AD 15 ISZERO 06AE 61 PUSH2 0x06b6 06B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06AB stack[0] = msg.value } // Block ends with conditional jump to 0x06b6, if !msg.value label_06B2: // Incoming jump from 0x06B1, if not !msg.value // Inputs[1] { @06B5 memory[0x00:0x00] } 06B2 60 PUSH1 0x00 06B4 80 DUP1 06B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B5 revert(memory[0x00:0x00]); } // Block terminates label_06B6: // Incoming jump from 0x06B1, if !msg.value // Inputs[1] { @06BE msg.data.length } 06B6 5B JUMPDEST 06B7 50 POP 06B8 61 PUSH2 0x030f 06BB 60 PUSH1 0x04 06BD 80 DUP1 06BE 36 CALLDATASIZE 06BF 03 SUB 06C0 60 PUSH1 0x20 06C2 81 DUP2 06C3 10 LT 06C4 15 ISZERO 06C5 61 PUSH2 0x06cd 06C8 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @06B8 stack[-1] = 0x030f // @06BB stack[0] = 0x04 // @06BF stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x06cd, if !(msg.data.length - 0x04 < 0x20) label_06C9: // Incoming jump from 0x06C8, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06CC memory[0x00:0x00] } 06C9 60 PUSH1 0x00 06CB 80 DUP1 06CC FD *REVERT // Stack delta = +0 // Outputs[1] { @06CC revert(memory[0x00:0x00]); } // Block terminates label_06CD: // Incoming jump from 0x06C8, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @06CF stack[-2] // @06CF msg.data[stack[-2]:stack[-2] + 0x20] // } 06CD 5B JUMPDEST 06CE 50 POP 06CF 35 CALLDATALOAD 06D0 61 PUSH2 0x1368 06D3 56 *JUMP // Stack delta = -1 // Outputs[1] { @06CF stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1368 label_06D4: // Incoming jump from 0x0049, if 0xea598cb0 == stack[-1] // Inputs[1] { @06D5 msg.value } 06D4 5B JUMPDEST 06D5 34 CALLVALUE 06D6 80 DUP1 06D7 15 ISZERO 06D8 61 PUSH2 0x06e0 06DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06D5 stack[0] = msg.value } // Block ends with conditional jump to 0x06e0, if !msg.value label_06DC: // Incoming jump from 0x06DB, if not !msg.value // Inputs[1] { @06DF memory[0x00:0x00] } 06DC 60 PUSH1 0x00 06DE 80 DUP1 06DF FD *REVERT // Stack delta = +0 // Outputs[1] { @06DF revert(memory[0x00:0x00]); } // Block terminates label_06E0: // Incoming jump from 0x06DB, if !msg.value // Inputs[1] { @06E8 msg.data.length } 06E0 5B JUMPDEST 06E1 50 POP 06E2 61 PUSH2 0x030f 06E5 60 PUSH1 0x04 06E7 80 DUP1 06E8 36 CALLDATASIZE 06E9 03 SUB 06EA 60 PUSH1 0x20 06EC 81 DUP2 06ED 10 LT 06EE 15 ISZERO 06EF 61 PUSH2 0x06f7 06F2 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @06E2 stack[-1] = 0x030f // @06E5 stack[0] = 0x04 // @06E9 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x06f7, if !(msg.data.length - 0x04 < 0x20) label_06F3: // Incoming jump from 0x06F2, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06F6 memory[0x00:0x00] } 06F3 60 PUSH1 0x00 06F5 80 DUP1 06F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F6 revert(memory[0x00:0x00]); } // Block terminates label_06F7: // Incoming jump from 0x06F2, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @06F9 stack[-2] // @06F9 msg.data[stack[-2]:stack[-2] + 0x20] // } 06F7 5B JUMPDEST 06F8 50 POP 06F9 35 CALLDATALOAD 06FA 61 PUSH2 0x1374 06FD 56 *JUMP // Stack delta = -1 // Outputs[1] { @06F9 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1374 label_06FE: // Incoming jump from 0x0054, if 0xf2fde38b == stack[-1] // Inputs[1] { @06FF msg.value } 06FE 5B JUMPDEST 06FF 34 CALLVALUE 0700 80 DUP1 0701 15 ISZERO 0702 61 PUSH2 0x070a 0705 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06FF stack[0] = msg.value } // Block ends with conditional jump to 0x070a, if !msg.value label_0706: // Incoming jump from 0x0705, if not !msg.value // Inputs[1] { @0709 memory[0x00:0x00] } 0706 60 PUSH1 0x00 0708 80 DUP1 0709 FD *REVERT // Stack delta = +0 // Outputs[1] { @0709 revert(memory[0x00:0x00]); } // Block terminates label_070A: // Incoming jump from 0x0705, if !msg.value // Inputs[1] { @0712 msg.data.length } 070A 5B JUMPDEST 070B 50 POP 070C 61 PUSH2 0x02f8 070F 60 PUSH1 0x04 0711 80 DUP1 0712 36 CALLDATASIZE 0713 03 SUB 0714 60 PUSH1 0x20 0716 81 DUP2 0717 10 LT 0718 15 ISZERO 0719 61 PUSH2 0x0721 071C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @070C stack[-1] = 0x02f8 // @070F stack[0] = 0x04 // @0713 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0721, if !(msg.data.length - 0x04 < 0x20) label_071D: // Incoming jump from 0x071C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0720 memory[0x00:0x00] } 071D 60 PUSH1 0x00 071F 80 DUP1 0720 FD *REVERT // Stack delta = +0 // Outputs[1] { @0720 revert(memory[0x00:0x00]); } // Block terminates label_0721: // Incoming jump from 0x071C, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0723 stack[-2] // @0723 msg.data[stack[-2]:stack[-2] + 0x20] // } 0721 5B JUMPDEST 0722 50 POP 0723 35 CALLDATALOAD 0724 60 PUSH1 0x01 0726 60 PUSH1 0x01 0728 60 PUSH1 0xa0 072A 1B SHL 072B 03 SUB 072C 16 AND 072D 61 PUSH2 0x1380 0730 56 *JUMP // Stack delta = -1 // Outputs[1] { @072C stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1380 label_0731: // Incoming jump from 0x005F, if 0xfc0c546a == stack[-1] // Inputs[1] { @0732 msg.value } 0731 5B JUMPDEST 0732 34 CALLVALUE 0733 80 DUP1 0734 15 ISZERO 0735 61 PUSH2 0x073d 0738 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0732 stack[0] = msg.value } // Block ends with conditional jump to 0x073d, if !msg.value label_0739: // Incoming jump from 0x0738, if not !msg.value // Inputs[1] { @073C memory[0x00:0x00] } 0739 60 PUSH1 0x00 073B 80 DUP1 073C FD *REVERT // Stack delta = +0 // Outputs[1] { @073C revert(memory[0x00:0x00]); } // Block terminates label_073D: // Incoming jump from 0x0738, if !msg.value 073D 5B JUMPDEST 073E 50 POP 073F 61 PUSH2 0x049d 0742 61 PUSH2 0x1442 0745 56 *JUMP // Stack delta = +0 // Outputs[1] { @073F stack[-1] = 0x049d } // Block ends with call to 0x1442, returns to 0x049D label_0746: // Incoming call from 0x01B5, returns to 0x01B6 // Inputs[2] // { // @074A storage[0x01] // @074E memory[0x40:0x60] // } 0746 5B JUMPDEST 0747 60 PUSH1 0x01 0749 80 DUP1 074A 54 SLOAD 074B 60 PUSH1 0x40 074D 80 DUP1 074E 51 MLOAD 074F 60 PUSH1 0x20 0751 60 PUSH1 0x02 0753 84 DUP5 0754 86 DUP7 0755 16 AND 0756 15 ISZERO 0757 61 PUSH2 0x0100 075A 02 MUL 075B 60 PUSH1 0x00 075D 19 NOT 075E 01 ADD 075F 90 SWAP1 0760 94 SWAP5 0761 16 AND 0762 93 SWAP4 0763 90 SWAP1 0764 93 SWAP4 0765 04 DIV 0766 60 PUSH1 0x1f 0768 81 DUP2 0769 01 ADD 076A 84 DUP5 076B 90 SWAP1 076C 04 DIV 076D 84 DUP5 076E 02 MUL 076F 82 DUP3 0770 01 ADD 0771 84 DUP5 0772 01 ADD 0773 90 SWAP1 0774 92 SWAP3 0775 52 MSTORE 0776 81 DUP2 0777 81 DUP2 0778 52 MSTORE 0779 92 SWAP3 077A 91 SWAP2 077B 83 DUP4 077C 01 ADD 077D 82 DUP3 077E 82 DUP3 077F 80 DUP1 0780 15 ISZERO 0781 61 PUSH2 0x07cb 0784 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0774 stack[2] = (storage[0x01] & ~0x00 + 0x0100 * !(0x01 & storage[0x01])) / 0x02 // @0775 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x01] & ~0x00 + 0x0100 * !(0x01 & storage[0x01])) / 0x02 + 0x1f) / 0x20) // @0778 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x01] & ~0x00 + 0x0100 * !(0x01 & storage[0x01])) / 0x02 // @0779 stack[0] = memory[0x40:0x60] // @077A stack[1] = 0x01 // @077C stack[3] = memory[0x40:0x60] + 0x20 // @077D stack[4] = 0x01 // @077E stack[5] = (storage[0x01] & ~0x00 + 0x0100 * !(0x01 & storage[0x01])) / 0x02 // } // Block ends with conditional jump to 0x07cb, if !((storage[0x01] & ~0x00 + 0x0100 * !(0x01 & storage[0x01])) / 0x02) label_0785: // Incoming jump from 0x0784, if not !((storage[0x01] & ~0x00 + 0x0100 * !(0x01 & storage[0x01])) / 0x02) // Inputs[1] { @0785 stack[-1] } 0785 80 DUP1 0786 60 PUSH1 0x1f 0788 10 LT 0789 61 PUSH2 0x07a0 078C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a0, if 0x1f < stack[-1] label_078D: // Incoming jump from 0x078C, if not 0x1f < stack[-1] // Inputs[4] // { // @0791 stack[-2] // @0792 storage[stack[-2]] // @0795 stack[-3] // @0797 stack[-1] // } 078D 61 PUSH2 0x0100 0790 80 DUP1 0791 83 DUP4 0792 54 SLOAD 0793 04 DIV 0794 02 MUL 0795 83 DUP4 0796 52 MSTORE 0797 91 SWAP2 0798 60 PUSH1 0x20 079A 01 ADD 079B 91 SWAP2 079C 61 PUSH2 0x07cb 079F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0796 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @079B stack[-1] = stack[-1] // @079B stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07cb label_07A0: // Incoming jump from 0x12E9, if 0x1f < stack[-1] // Incoming jump from 0x078C, if 0x1f < stack[-1] // Inputs[5] // { // @07A1 stack[-3] // @07A2 stack[-1] // @07A4 stack[-2] // @07AC memory[0x00:0x20] // @07B0 storage[keccak256(memory[0x00:0x20])] // } 07A0 5B JUMPDEST 07A1 82 DUP3 07A2 01 ADD 07A3 91 SWAP2 07A4 90 SWAP1 07A5 60 PUSH1 0x00 07A7 52 MSTORE 07A8 60 PUSH1 0x20 07AA 60 PUSH1 0x00 07AC 20 SHA3 07AD 90 SWAP1 07AE 5B JUMPDEST 07AF 81 DUP2 07B0 54 SLOAD 07B1 81 DUP2 07B2 52 MSTORE 07B3 90 SWAP1 07B4 60 PUSH1 0x01 07B6 01 ADD 07B7 90 SWAP1 07B8 60 PUSH1 0x20 07BA 01 ADD 07BB 80 DUP1 07BC 83 DUP4 07BD 11 GT 07BE 61 PUSH2 0x07ae 07C1 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @07A3 stack[-3] = stack[-3] + stack[-1] // @07A7 memory[0x00:0x20] = stack[-2] // @07B2 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07B7 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07BA stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x07ae, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07C2: // Incoming jump from 0x07C1, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x07C1, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @07C2 stack[-3] // @07C3 stack[-1] // } 07C2 82 DUP3 07C3 90 SWAP1 07C4 03 SUB 07C5 60 PUSH1 0x1f 07C7 16 AND 07C8 82 DUP3 07C9 01 ADD 07CA 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07CA stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07CA stack[-1] = stack[-3] // } // Block continues label_07CB: // Incoming jump from 0x12E1, if !((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02) // Incoming jump from 0x12FC // Incoming jump from 0x07CA // Incoming jump from 0x079F // Incoming jump from 0x0784, if !((storage[0x01] & ~0x00 + 0x0100 * !(0x01 & storage[0x01])) / 0x02) // Inputs[1] { @07D1 stack[-7] } 07CB 5B JUMPDEST 07CC 50 POP 07CD 50 POP 07CE 50 POP 07CF 50 POP 07D0 50 POP 07D1 81 DUP2 07D2 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_07D3: // Incoming jump from 0x0263 // Inputs[3] // { // @07D9 msg.sender // @07DA stack[-2] // @07DB stack[-1] // } 07D3 5B JUMPDEST 07D4 60 PUSH1 0x00 07D6 61 PUSH2 0x07e0 07D9 33 CALLER 07DA 84 DUP5 07DB 84 DUP5 07DC 61 PUSH2 0x1451 07DF 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @07D4 stack[0] = 0x00 // @07D6 stack[1] = 0x07e0 // @07D9 stack[2] = msg.sender // @07DA stack[3] = stack[-2] // @07DB stack[4] = stack[-1] // } // Block ends with call to 0x1451, returns to 0x07E0 label_07E0: // Incoming return from call to 0x1451 at 0x07DF // Incoming return from call to 0x1503 at 0x1309 07E0 5B JUMPDEST 07E1 50 POP 07E2 60 PUSH1 0x01 // Stack delta = +0 // Outputs[1] { @07E2 stack[-1] = 0x01 } // Block continues label_07E4: // Incoming jump from 0x07E2 // Incoming return from call to 0x1062 at 0x1373 // Incoming jump from 0x14BE, if !(stack[-2] - stack[-1] > stack[-2]) // Incoming return from call to 0x098F at 0x137F // Incoming jump from 0x18FA, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @07E5 stack[-1] // @07E5 stack[-4] // @07E6 stack[-3] // } 07E4 5B JUMPDEST 07E5 92 SWAP3 07E6 91 SWAP2 07E7 50 POP 07E8 50 POP 07E9 56 *JUMP // Stack delta = -3 // Outputs[1] { @07E5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_07EA: // Incoming jump from 0x02F7 07EA 5B JUMPDEST 07EB 61 PUSH2 0x07f2 07EE 61 PUSH2 0x1296 07F1 56 *JUMP // Stack delta = +1 // Outputs[1] { @07EB stack[0] = 0x07f2 } // Block ends with call to 0x1296, returns to 0x07F2 label_07F2: // Incoming return from call to 0x1296 at 0x07F1 // Inputs[2] // { // @07FB stack[-1] // @07FC tx.origin // } 07F2 5B JUMPDEST 07F3 60 PUSH1 0x01 07F5 60 PUSH1 0x01 07F7 60 PUSH1 0xa0 07F9 1B SHL 07FA 03 SUB 07FB 16 AND 07FC 32 ORIGIN 07FD 60 PUSH1 0x01 07FF 60 PUSH1 0x01 0801 60 PUSH1 0xa0 0803 1B SHL 0804 03 SUB 0805 16 AND 0806 14 EQ 0807 61 PUSH2 0x0845 080A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0845, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] label_080B: // Incoming jump from 0x080A, if not (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[5] // { // @080E memory[0x40:0x60] // @0829 memory[0x00:0x20] // @0832 memory[0x00:0x20] // @083B memory[0x40:0x60] // @0844 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 080B 60 PUSH1 0x40 080D 80 DUP1 080E 51 MLOAD 080F 62 PUSH3 0x461bcd 0813 60 PUSH1 0xe5 0815 1B SHL 0816 81 DUP2 0817 52 MSTORE 0818 60 PUSH1 0x20 081A 60 PUSH1 0x04 081C 82 DUP3 081D 01 ADD 081E 52 MSTORE 081F 60 PUSH1 0x1f 0821 60 PUSH1 0x24 0823 82 DUP3 0824 01 ADD 0825 52 MSTORE 0826 60 PUSH1 0x00 0828 80 DUP1 0829 51 MLOAD 082A 60 PUSH1 0x20 082C 61 PUSH2 0x1bb7 082F 83 DUP4 0830 39 CODECOPY 0831 81 DUP2 0832 51 MLOAD 0833 91 SWAP2 0834 52 MSTORE 0835 60 PUSH1 0x44 0837 82 DUP3 0838 01 ADD 0839 52 MSTORE 083A 90 SWAP1 083B 51 MLOAD 083C 90 SWAP1 083D 81 DUP2 083E 90 SWAP1 083F 03 SUB 0840 60 PUSH1 0x64 0842 01 ADD 0843 90 SWAP1 0844 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @0817 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @081E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0825 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0830 memory[0x00:0x20] = code[0x1bb7:0x1bd7] // @0834 memory[0x00:0x20] = memory[0x00:0x20] // @0839 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0844 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0845: // Incoming jump from 0x080A, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[11] // { // @0848 stack[-3] // @0852 msg.value // @0853 stack[-2] // @0854 stack[-1] // @0857 memory[0x40:0x60] // @085E msg.data[stack[-2]:stack[-2] + stack[-1]] // @0861 memory[0x40:0x60] // @0874 msg.gas // @0875 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]] // @0875 address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // @087A returndata.length // } 0845 5B JUMPDEST 0846 60 PUSH1 0x00 0848 83 DUP4 0849 60 PUSH1 0x01 084B 60 PUSH1 0x01 084D 60 PUSH1 0xa0 084F 1B SHL 0850 03 SUB 0851 16 AND 0852 34 CALLVALUE 0853 84 DUP5 0854 84 DUP5 0855 60 PUSH1 0x40 0857 51 MLOAD 0858 80 DUP1 0859 83 DUP4 085A 83 DUP4 085B 80 DUP1 085C 82 DUP3 085D 84 DUP5 085E 37 CALLDATACOPY 085F 60 PUSH1 0x40 0861 51 MLOAD 0862 92 SWAP3 0863 01 ADD 0864 94 SWAP5 0865 50 POP 0866 60 PUSH1 0x00 0868 93 SWAP4 0869 50 POP 086A 90 SWAP1 086B 91 SWAP2 086C 50 POP 086D 50 POP 086E 80 DUP1 086F 83 DUP4 0870 03 SUB 0871 81 DUP2 0872 85 DUP6 0873 87 DUP8 0874 5A GAS 0875 F1 CALL 0876 92 SWAP3 0877 50 POP 0878 50 POP 0879 50 POP 087A 3D RETURNDATASIZE 087B 80 DUP1 087C 60 PUSH1 0x00 087E 81 DUP2 087F 14 EQ 0880 61 PUSH2 0x08a5 0883 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0846 stack[0] = 0x00 // @085E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @0875 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // @0876 stack[1] = address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]) // @087A stack[2] = returndata.length // @087B stack[3] = returndata.length // } // Block ends with conditional jump to 0x08a5, if returndata.length == 0x00 label_0884: // Incoming jump from 0x0883, if not returndata.length == 0x00 // Inputs[6] // { // @0886 memory[0x40:0x60] // @0887 stack[-2] // @088E returndata.length // @0896 returndata.length // @0899 returndata.length // @08A0 returndata[0x00:0x00 + returndata.length] // } 0884 60 PUSH1 0x40 0886 51 MLOAD 0887 91 SWAP2 0888 50 POP 0889 60 PUSH1 0x1f 088B 19 NOT 088C 60 PUSH1 0x3f 088E 3D RETURNDATASIZE 088F 01 ADD 0890 16 AND 0891 82 DUP3 0892 01 ADD 0893 60 PUSH1 0x40 0895 52 MSTORE 0896 3D RETURNDATASIZE 0897 82 DUP3 0898 52 MSTORE 0899 3D RETURNDATASIZE 089A 60 PUSH1 0x00 089C 60 PUSH1 0x20 089E 84 DUP5 089F 01 ADD 08A0 3E RETURNDATACOPY 08A1 61 PUSH2 0x08aa 08A4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0887 stack[-2] = memory[0x40:0x60] // @0895 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0898 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @08A0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x08aa label_08A5: // Incoming jump from 0x0883, if returndata.length == 0x00 // Inputs[3] // { // @08A8 stack[-2] // @08AD stack[-4] // @08AD stack[-3] // } 08A5 5B JUMPDEST 08A6 60 PUSH1 0x60 08A8 91 SWAP2 08A9 50 POP 08AA 5B JUMPDEST 08AB 50 POP 08AC 50 POP 08AD 90 SWAP1 08AE 50 POP 08AF 80 DUP1 08B0 61 PUSH2 0x08e9 08B3 57 *JUMPI // Stack delta = -3 // Outputs[1] { @08AD stack[-4] = stack[-3] } // Block ends with conditional jump to 0x08e9, if stack[-3] label_08B4: // Incoming jump from 0x08B3, if not stack[-3] // Incoming jump from 0x08B3, if not stack[-3] // Inputs[3] // { // @08B7 memory[0x40:0x60] // @08DF memory[0x40:0x60] // @08E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 08B4 60 PUSH1 0x40 08B6 80 DUP1 08B7 51 MLOAD 08B8 62 PUSH3 0x461bcd 08BC 60 PUSH1 0xe5 08BE 1B SHL 08BF 81 DUP2 08C0 52 MSTORE 08C1 60 PUSH1 0x20 08C3 60 PUSH1 0x04 08C5 82 DUP3 08C6 01 ADD 08C7 52 MSTORE 08C8 60 PUSH1 0x06 08CA 60 PUSH1 0x24 08CC 82 DUP3 08CD 01 ADD 08CE 52 MSTORE 08CF 65 PUSH6 0x19985a5b1959 08D6 60 PUSH1 0xd2 08D8 1B SHL 08D9 60 PUSH1 0x44 08DB 82 DUP3 08DC 01 ADD 08DD 52 MSTORE 08DE 90 SWAP1 08DF 51 MLOAD 08E0 90 SWAP1 08E1 81 DUP2 08E2 90 SWAP1 08E3 03 SUB 08E4 60 PUSH1 0x64 08E6 01 ADD 08E7 90 SWAP1 08E8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @08C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08C7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08CE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @08DD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x19985a5b1959 << 0xd2 // @08E8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_08E9: // Incoming jump from 0x08B3, if stack[-3] // Incoming jump from 0x08B3, if stack[-3] // Inputs[1] { @08EE stack[-5] } 08E9 5B JUMPDEST 08EA 50 POP 08EB 50 POP 08EC 50 POP 08ED 50 POP 08EE 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_08EF: // Incoming call from 0x030E, returns to 0x030F // Inputs[2] // { // @08F2 storage[0x04] // @08F3 stack[-1] // } 08EF 5B JUMPDEST 08F0 60 PUSH1 0x04 08F2 54 SLOAD 08F3 81 DUP2 08F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @08F2 stack[0] = storage[0x04] } // Block ends with unconditional jump to stack[-1] label_08F5: // Incoming jump from 0x0363 // Inputs[5] // { // @08FE stack[-3] // @0910 memory[0x00:0x40] // @0911 msg.sender // @0918 memory[0x00:0x40] // @0919 storage[keccak256(memory[0x00:0x40])] // } 08F5 5B JUMPDEST 08F6 60 PUSH1 0x01 08F8 60 PUSH1 0x01 08FA 60 PUSH1 0xa0 08FC 1B SHL 08FD 03 SUB 08FE 83 DUP4 08FF 16 AND 0900 60 PUSH1 0x00 0902 90 SWAP1 0903 81 DUP2 0904 52 MSTORE 0905 60 PUSH1 0x06 0907 60 PUSH1 0x20 0909 90 SWAP1 090A 81 DUP2 090B 52 MSTORE 090C 60 PUSH1 0x40 090E 80 DUP1 090F 83 DUP4 0910 20 SHA3 0911 33 CALLER 0912 84 DUP5 0913 52 MSTORE 0914 90 SWAP1 0915 91 SWAP2 0916 52 MSTORE 0917 81 DUP2 0918 20 SHA3 0919 54 SLOAD 091A 60 PUSH1 0x00 091C 19 NOT 091D 14 EQ 091E 61 PUSH2 0x097a 0921 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0902 stack[0] = 0x00 // @0904 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @090B memory[0x20:0x40] = 0x06 // @0913 memory[0x00:0x20] = msg.sender // @0916 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x097a, if ~0x00 == storage[keccak256(memory[0x00:0x40])] label_0922: // Incoming jump from 0x0921, if not ~0x00 == storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @092A stack[-4] // @093C memory[0x00:0x40] // @093D msg.sender // @0944 memory[0x00:0x40] // @0945 storage[keccak256(memory[0x00:0x40])] // @094A stack[-2] // } 0922 60 PUSH1 0x01 0924 60 PUSH1 0x01 0926 60 PUSH1 0xa0 0928 1B SHL 0929 03 SUB 092A 84 DUP5 092B 16 AND 092C 60 PUSH1 0x00 092E 90 SWAP1 092F 81 DUP2 0930 52 MSTORE 0931 60 PUSH1 0x06 0933 60 PUSH1 0x20 0935 90 SWAP1 0936 81 DUP2 0937 52 MSTORE 0938 60 PUSH1 0x40 093A 80 DUP1 093B 83 DUP4 093C 20 SHA3 093D 33 CALLER 093E 84 DUP5 093F 52 MSTORE 0940 90 SWAP1 0941 91 SWAP2 0942 52 MSTORE 0943 90 SWAP1 0944 20 SHA3 0945 54 SLOAD 0946 61 PUSH2 0x0955 0949 90 SWAP1 094A 83 DUP4 094B 63 PUSH4 0xffffffff 0950 61 PUSH2 0x14b3 0953 16 AND 0954 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @0930 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0937 memory[0x20:0x40] = 0x06 // @093F memory[0x00:0x20] = msg.sender // @0942 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0949 stack[0] = 0x0955 // @0949 stack[1] = storage[keccak256(memory[0x00:0x40])] // @094A stack[2] = stack[-2] // } // Block ends with call to 0x14b3 & 0xffffffff, returns to 0x0955 label_0955: // Incoming return from call to 0x14B3 at 0x0954 // Inputs[5] // { // @095E stack[-5] // @0970 memory[0x00:0x40] // @0971 msg.sender // @0978 memory[0x00:0x40] // @0979 stack[-1] // } 0955 5B JUMPDEST 0956 60 PUSH1 0x01 0958 60 PUSH1 0x01 095A 60 PUSH1 0xa0 095C 1B SHL 095D 03 SUB 095E 85 DUP6 095F 16 AND 0960 60 PUSH1 0x00 0962 90 SWAP1 0963 81 DUP2 0964 52 MSTORE 0965 60 PUSH1 0x06 0967 60 PUSH1 0x20 0969 90 SWAP1 096A 81 DUP2 096B 52 MSTORE 096C 60 PUSH1 0x40 096E 80 DUP1 096F 83 DUP4 0970 20 SHA3 0971 33 CALLER 0972 84 DUP5 0973 52 MSTORE 0974 90 SWAP1 0975 91 SWAP2 0976 52 MSTORE 0977 90 SWAP1 0978 20 SHA3 0979 55 SSTORE // Stack delta = -1 // Outputs[5] // { // @0964 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @096B memory[0x20:0x40] = 0x06 // @0973 memory[0x00:0x20] = msg.sender // @0976 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0979 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block continues label_097A: // Incoming jump from 0x0921, if ~0x00 == storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0979 // Inputs[3] // { // @097E stack[-4] // @097F stack[-3] // @0980 stack[-2] // } 097A 5B JUMPDEST 097B 61 PUSH2 0x0985 097E 84 DUP5 097F 84 DUP5 0980 84 DUP5 0981 61 PUSH2 0x1503 0984 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @097B stack[0] = 0x0985 // @097E stack[1] = stack[-4] // @097F stack[2] = stack[-3] // @0980 stack[3] = stack[-2] // } // Block ends with call to 0x1503, returns to 0x0985 label_0985: // Incoming return from call to 0x1503 at 0x0984 // Inputs[2] // { // @0989 stack[-5] // @098A stack[-4] // } 0985 5B JUMPDEST 0986 50 POP 0987 60 PUSH1 0x01 0989 93 SWAP4 098A 92 SWAP3 098B 50 POP 098C 50 POP 098D 50 POP 098E 56 *JUMP // Stack delta = -4 // Outputs[1] { @0989 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_098F: // Incoming call from 0x137F, returns to 0x07E4 // Incoming jump from 0x039C // Inputs[1] { @0993 stack[-2] } 098F 5B JUMPDEST 0990 60 PUSH1 0x00 0992 80 DUP1 0993 83 DUP4 0994 11 GT 0995 61 PUSH2 0x09e5 0998 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0990 stack[0] = 0x00 } // Block ends with conditional jump to 0x09e5, if stack[-2] > 0x00 label_0999: // Incoming jump from 0x0998, if not stack[-2] > 0x00 // Inputs[3] // { // @099C memory[0x40:0x60] // @09DB memory[0x40:0x60] // @09E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0999 60 PUSH1 0x40 099B 80 DUP1 099C 51 MLOAD 099D 62 PUSH3 0x461bcd 09A1 60 PUSH1 0xe5 09A3 1B SHL 09A4 81 DUP2 09A5 52 MSTORE 09A6 60 PUSH1 0x20 09A8 60 PUSH1 0x04 09AA 82 DUP3 09AB 01 ADD 09AC 52 MSTORE 09AD 60 PUSH1 0x1a 09AF 60 PUSH1 0x24 09B1 82 DUP3 09B2 01 ADD 09B3 52 MSTORE 09B4 7F PUSH32 0x4665773a2063616e27742077726170207a65726f20746f6b656e000000000000 09D5 60 PUSH1 0x44 09D7 82 DUP3 09D8 01 ADD 09D9 52 MSTORE 09DA 90 SWAP1 09DB 51 MLOAD 09DC 90 SWAP1 09DD 81 DUP2 09DE 90 SWAP1 09DF 03 SUB 09E0 60 PUSH1 0x64 09E2 01 ADD 09E3 90 SWAP1 09E4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @09A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09AC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09B3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @09D9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4665773a2063616e27742077726170207a65726f20746f6b656e000000000000 // @09E4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_09E5: // Incoming jump from 0x0998, if stack[-2] > 0x00 // Inputs[1] { @09E8 storage[0x0a] } 09E5 5B JUMPDEST 09E6 60 PUSH1 0x0a 09E8 54 SLOAD 09E9 60 PUSH1 0x01 09EB 60 PUSH1 0x01 09ED 60 PUSH1 0xa0 09EF 1B SHL 09F0 03 SUB 09F1 16 AND 09F2 15 ISZERO 09F3 61 PUSH2 0x0bc5 09F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bc5, if !((0x01 << 0xa0) - 0x01 & storage[0x0a]) label_09F7: // Incoming jump from 0x09F6, if not !((0x01 << 0xa0) - 0x01 & storage[0x0a]) // Inputs[4] // { // @09FC storage[0x0a] // @0A1D memory[0x40:0x60] // @0A31 memory[0x40:0x60] // @0A38 address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 ** 0x00).code.length // } 09F7 60 PUSH1 0x0a 09F9 60 PUSH1 0x00 09FB 90 SWAP1 09FC 54 SLOAD 09FD 90 SWAP1 09FE 61 PUSH2 0x0100 0A01 0A EXP 0A02 90 SWAP1 0A03 04 DIV 0A04 60 PUSH1 0x01 0A06 60 PUSH1 0x01 0A08 60 PUSH1 0xa0 0A0A 1B SHL 0A0B 03 SUB 0A0C 16 AND 0A0D 60 PUSH1 0x01 0A0F 60 PUSH1 0x01 0A11 60 PUSH1 0xa0 0A13 1B SHL 0A14 03 SUB 0A15 16 AND 0A16 63 PUSH4 0x4e69d560 0A1B 60 PUSH1 0x40 0A1D 51 MLOAD 0A1E 81 DUP2 0A1F 63 PUSH4 0xffffffff 0A24 16 AND 0A25 60 PUSH1 0xe0 0A27 1B SHL 0A28 81 DUP2 0A29 52 MSTORE 0A2A 60 PUSH1 0x04 0A2C 01 ADD 0A2D 60 PUSH1 0x20 0A2F 60 PUSH1 0x40 0A31 51 MLOAD 0A32 80 DUP1 0A33 83 DUP4 0A34 03 SUB 0A35 81 DUP2 0A36 86 DUP7 0A37 80 DUP1 0A38 3B EXTCODESIZE 0A39 15 ISZERO 0A3A 80 DUP1 0A3B 15 ISZERO 0A3C 61 PUSH2 0x0a44 0A3F 57 *JUMPI // Stack delta = +9 // Outputs[10] // { // @0A15 stack[0] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 ** 0x00 // @0A16 stack[1] = 0x4e69d560 // @0A29 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x4e69d560) << 0xe0 // @0A2C stack[2] = 0x04 + memory[0x40:0x60] // @0A2D stack[3] = 0x20 // @0A31 stack[4] = memory[0x40:0x60] // @0A34 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0A35 stack[6] = memory[0x40:0x60] // @0A36 stack[7] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 ** 0x00 // @0A39 stack[8] = !address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x0a44, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 ** 0x00).code.length label_0A40: // Incoming jump from 0x0A3F, if not !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 ** 0x00).code.length // Inputs[1] { @0A43 memory[0x00:0x00] } 0A40 60 PUSH1 0x00 0A42 80 DUP1 0A43 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A43 revert(memory[0x00:0x00]); } // Block terminates label_0A44: // Incoming jump from 0x0A3F, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x0a] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @0A46 msg.gas // @0A47 stack[-5] // @0A47 stack[-3] // @0A47 memory[stack[-3]:stack[-3] + stack[-4]] // @0A47 stack[-2] // @0A47 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0A47 stack[-6] // @0A47 stack[-4] // } 0A44 5B JUMPDEST 0A45 50 POP 0A46 5A GAS 0A47 FA STATICCALL 0A48 15 ISZERO 0A49 80 DUP1 0A4A 15 ISZERO 0A4B 61 PUSH2 0x0a58 0A4E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0A47 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0A48 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0a58, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0A4F: // Incoming jump from 0x0A4E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0A4F returndata.length // @0A53 returndata[0x00:0x00 + returndata.length] // @0A54 returndata.length // @0A57 memory[0x00:0x00 + returndata.length] // } 0A4F 3D RETURNDATASIZE 0A50 60 PUSH1 0x00 0A52 80 DUP1 0A53 3E RETURNDATACOPY 0A54 3D RETURNDATASIZE 0A55 60 PUSH1 0x00 0A57 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A53 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A57 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A58: // Incoming jump from 0x0A4E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0A5F memory[0x40:0x60] // @0A60 returndata.length // } 0A58 5B JUMPDEST 0A59 50 POP 0A5A 50 POP 0A5B 50 POP 0A5C 50 POP 0A5D 60 PUSH1 0x40 0A5F 51 MLOAD 0A60 3D RETURNDATASIZE 0A61 60 PUSH1 0x20 0A63 81 DUP2 0A64 10 LT 0A65 15 ISZERO 0A66 61 PUSH2 0x0a6e 0A69 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0A5F stack[-4] = memory[0x40:0x60] // @0A60 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0a6e, if !(returndata.length < 0x20) label_0A6A: // Incoming jump from 0x0A69, if not !(returndata.length < 0x20) // Inputs[1] { @0A6D memory[0x00:0x00] } 0A6A 60 PUSH1 0x00 0A6C 80 DUP1 0A6D FD *REVERT // Stack delta = +0 // Outputs[1] { @0A6D revert(memory[0x00:0x00]); } // Block terminates label_0A6E: // Incoming jump from 0x0A69, if !(returndata.length < 0x20) // Inputs[2] // { // @0A70 stack[-2] // @0A70 memory[stack[-2]:stack[-2] + 0x20] // } 0A6E 5B JUMPDEST 0A6F 50 POP 0A70 51 MLOAD 0A71 15 ISZERO 0A72 61 PUSH2 0x0b43 0A75 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0b43, if !memory[stack[-2]:stack[-2] + 0x20] label_0A76: // Incoming jump from 0x0A75, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @0A78 storage[0x0a] // @0A7C memory[0x40:0x60] // @0A87 address(this) // @0A8E memory[0x40:0x60] // @0AB5 address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // } 0A76 60 PUSH1 0x0a 0A78 54 SLOAD 0A79 60 PUSH1 0x40 0A7B 80 DUP1 0A7C 51 MLOAD 0A7D 63 PUSH4 0x495faf43 0A82 60 PUSH1 0xe1 0A84 1B SHL 0A85 81 DUP2 0A86 52 MSTORE 0A87 30 ADDRESS 0A88 60 PUSH1 0x04 0A8A 82 DUP3 0A8B 01 ADD 0A8C 52 MSTORE 0A8D 90 SWAP1 0A8E 51 MLOAD 0A8F 60 PUSH1 0x01 0A91 60 PUSH1 0x01 0A93 60 PUSH1 0xa0 0A95 1B SHL 0A96 03 SUB 0A97 90 SWAP1 0A98 92 SWAP3 0A99 16 AND 0A9A 91 SWAP2 0A9B 63 PUSH4 0x92bf5e86 0AA0 91 SWAP2 0AA1 60 PUSH1 0x24 0AA3 80 DUP1 0AA4 82 DUP3 0AA5 01 ADD 0AA6 92 SWAP3 0AA7 60 PUSH1 0x00 0AA9 92 SWAP3 0AAA 90 SWAP1 0AAB 91 SWAP2 0AAC 90 SWAP1 0AAD 82 DUP3 0AAE 90 SWAP1 0AAF 03 SUB 0AB0 01 ADD 0AB1 81 DUP2 0AB2 83 DUP4 0AB3 87 DUP8 0AB4 80 DUP1 0AB5 3B EXTCODESIZE 0AB6 15 ISZERO 0AB7 80 DUP1 0AB8 15 ISZERO 0AB9 61 PUSH2 0x0ac1 0ABC 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0A86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x495faf43 << 0xe1 // @0A8C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0A9A stack[0] = storage[0x0a] & (0x01 << 0xa0) - 0x01 // @0AA0 stack[1] = 0x92bf5e86 // @0AA6 stack[2] = memory[0x40:0x60] + 0x24 // @0AA9 stack[3] = 0x00 // @0AAB stack[4] = memory[0x40:0x60] // @0AB0 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0AB1 stack[6] = memory[0x40:0x60] // @0AB2 stack[7] = 0x00 // @0AB3 stack[8] = storage[0x0a] & (0x01 << 0xa0) - 0x01 // @0AB6 stack[9] = !address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0ac1, if !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length label_0ABD: // Incoming jump from 0x0ABC, if not !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0AC0 memory[0x00:0x00] } 0ABD 60 PUSH1 0x00 0ABF 80 DUP1 0AC0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AC0 revert(memory[0x00:0x00]); } // Block terminates label_0AC1: // Incoming jump from 0x0ABC, if !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @0AC3 msg.gas // @0AC4 stack[-3] // @0AC4 stack[-6] // @0AC4 stack[-7] // @0AC4 memory[stack[-4]:stack[-4] + stack[-5]] // @0AC4 stack[-2] // @0AC4 stack[-5] // @0AC4 stack[-4] // @0AC4 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0AC1 5B JUMPDEST 0AC2 50 POP 0AC3 5A GAS 0AC4 F1 CALL 0AC5 15 ISZERO 0AC6 80 DUP1 0AC7 15 ISZERO 0AC8 61 PUSH2 0x0ad5 0ACB 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0AC4 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0AC5 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 0x0ad5, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0ACC: // Incoming jump from 0x0ACB, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0ACC returndata.length // @0AD0 returndata[0x00:0x00 + returndata.length] // @0AD1 returndata.length // @0AD4 memory[0x00:0x00 + returndata.length] // } 0ACC 3D RETURNDATASIZE 0ACD 60 PUSH1 0x00 0ACF 80 DUP1 0AD0 3E RETURNDATACOPY 0AD1 3D RETURNDATASIZE 0AD2 60 PUSH1 0x00 0AD4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AD0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0AD4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0AD5: // Incoming jump from 0x0ACB, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[7] // { // @0ADA storage[0x0a] // @0ADE memory[0x40:0x60] // @0AED stack[-7] // @0AF1 memory[0x40:0x60] // @0AFD stack[-4] // @0B04 stack[-3] // @0B1A address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // } 0AD5 5B JUMPDEST 0AD6 50 POP 0AD7 50 POP 0AD8 60 PUSH1 0x0a 0ADA 54 SLOAD 0ADB 60 PUSH1 0x40 0ADD 80 DUP1 0ADE 51 MLOAD 0ADF 63 PUSH4 0x0437b7ab 0AE4 60 PUSH1 0xe1 0AE6 1B SHL 0AE7 81 DUP2 0AE8 52 MSTORE 0AE9 60 PUSH1 0x04 0AEB 81 DUP2 0AEC 01 ADD 0AED 88 DUP9 0AEE 90 SWAP1 0AEF 52 MSTORE 0AF0 90 SWAP1 0AF1 51 MLOAD 0AF2 60 PUSH1 0x01 0AF4 60 PUSH1 0x01 0AF6 60 PUSH1 0xa0 0AF8 1B SHL 0AF9 03 SUB 0AFA 90 SWAP1 0AFB 92 SWAP3 0AFC 16 AND 0AFD 93 SWAP4 0AFE 50 POP 0AFF 63 PUSH4 0x086f6f56 0B04 92 SWAP3 0B05 50 POP 0B06 60 PUSH1 0x24 0B08 80 DUP1 0B09 82 DUP3 0B0A 01 ADD 0B0B 92 SWAP3 0B0C 60 PUSH1 0x00 0B0E 92 SWAP3 0B0F 90 SWAP1 0B10 91 SWAP2 0B11 90 SWAP1 0B12 82 DUP3 0B13 90 SWAP1 0B14 03 SUB 0B15 01 ADD 0B16 81 DUP2 0B17 83 DUP4 0B18 87 DUP8 0B19 80 DUP1 0B1A 3B EXTCODESIZE 0B1B 15 ISZERO 0B1C 80 DUP1 0B1D 15 ISZERO 0B1E 61 PUSH2 0x0b26 0B21 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @0AE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0437b7ab << 0xe1 // @0AEF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-7] // @0AFD stack[-4] = storage[0x0a] & (0x01 << 0xa0) - 0x01 // @0B04 stack[-3] = 0x086f6f56 // @0B0B stack[-2] = memory[0x40:0x60] + 0x24 // @0B0E stack[-1] = 0x00 // @0B10 stack[0] = memory[0x40:0x60] // @0B15 stack[1] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0B16 stack[2] = memory[0x40:0x60] // @0B17 stack[3] = 0x00 // @0B18 stack[4] = storage[0x0a] & (0x01 << 0xa0) - 0x01 // @0B1B stack[5] = !address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0b26, if !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length label_0B22: // Incoming jump from 0x0B21, if not !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0B25 memory[0x00:0x00] } 0B22 60 PUSH1 0x00 0B24 80 DUP1 0B25 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B25 revert(memory[0x00:0x00]); } // Block terminates label_0B26: // Incoming jump from 0x0B21, if !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @0B28 msg.gas // @0B29 stack[-3] // @0B29 stack[-6] // @0B29 stack[-7] // @0B29 stack[-5] // @0B29 stack[-4] // @0B29 stack[-2] // @0B29 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0B29 memory[stack[-4]:stack[-4] + stack[-5]] // } 0B26 5B JUMPDEST 0B27 50 POP 0B28 5A GAS 0B29 F1 CALL 0B2A 15 ISZERO 0B2B 80 DUP1 0B2C 15 ISZERO 0B2D 61 PUSH2 0x0b3a 0B30 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0B29 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0B2A 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 0x0b3a, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0B31: // Incoming jump from 0x0B30, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0B31 returndata.length // @0B35 returndata[0x00:0x00 + returndata.length] // @0B36 returndata.length // @0B39 memory[0x00:0x00 + returndata.length] // } 0B31 3D RETURNDATASIZE 0B32 60 PUSH1 0x00 0B34 80 DUP1 0B35 3E RETURNDATACOPY 0B36 3D RETURNDATASIZE 0B37 60 PUSH1 0x00 0B39 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B35 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0B39 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0B3A: // Incoming jump from 0x0B30, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 0B3A 5B JUMPDEST 0B3B 50 POP 0B3C 50 POP 0B3D 50 POP 0B3E 50 POP 0B3F 61 PUSH2 0x0bc0 0B42 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to 0x0bc0 label_0B43: // Incoming jump from 0x0A75, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @0B46 storage[0x0a] // @0B4A memory[0x40:0x60] // @0B55 address(this) // @0B5C memory[0x40:0x60] // @0B83 address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // } 0B43 5B JUMPDEST 0B44 60 PUSH1 0x0a 0B46 54 SLOAD 0B47 60 PUSH1 0x40 0B49 80 DUP1 0B4A 51 MLOAD 0B4B 63 PUSH4 0x495faf43 0B50 60 PUSH1 0xe1 0B52 1B SHL 0B53 81 DUP2 0B54 52 MSTORE 0B55 30 ADDRESS 0B56 60 PUSH1 0x04 0B58 82 DUP3 0B59 01 ADD 0B5A 52 MSTORE 0B5B 90 SWAP1 0B5C 51 MLOAD 0B5D 60 PUSH1 0x01 0B5F 60 PUSH1 0x01 0B61 60 PUSH1 0xa0 0B63 1B SHL 0B64 03 SUB 0B65 90 SWAP1 0B66 92 SWAP3 0B67 16 AND 0B68 91 SWAP2 0B69 63 PUSH4 0x92bf5e86 0B6E 91 SWAP2 0B6F 60 PUSH1 0x24 0B71 80 DUP1 0B72 82 DUP3 0B73 01 ADD 0B74 92 SWAP3 0B75 60 PUSH1 0x00 0B77 92 SWAP3 0B78 90 SWAP1 0B79 91 SWAP2 0B7A 90 SWAP1 0B7B 82 DUP3 0B7C 90 SWAP1 0B7D 03 SUB 0B7E 01 ADD 0B7F 81 DUP2 0B80 83 DUP4 0B81 87 DUP8 0B82 80 DUP1 0B83 3B EXTCODESIZE 0B84 15 ISZERO 0B85 80 DUP1 0B86 15 ISZERO 0B87 61 PUSH2 0x0b8f 0B8A 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0B54 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x495faf43 << 0xe1 // @0B5A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0B68 stack[0] = storage[0x0a] & (0x01 << 0xa0) - 0x01 // @0B6E stack[1] = 0x92bf5e86 // @0B74 stack[2] = memory[0x40:0x60] + 0x24 // @0B77 stack[3] = 0x00 // @0B79 stack[4] = memory[0x40:0x60] // @0B7E stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0B7F stack[6] = memory[0x40:0x60] // @0B80 stack[7] = 0x00 // @0B81 stack[8] = storage[0x0a] & (0x01 << 0xa0) - 0x01 // @0B84 stack[9] = !address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0b8f, if !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length label_0B8B: // Incoming jump from 0x0B8A, if not !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // 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 !!address(storage[0x0a] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @0B91 msg.gas // @0B92 stack[-3] // @0B92 memory[stack[-4]:stack[-4] + stack[-5]] // @0B92 stack[-6] // @0B92 stack[-5] // @0B92 stack[-4] // @0B92 stack[-2] // @0B92 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0B92 stack[-7] // } 0B8F 5B JUMPDEST 0B90 50 POP 0B91 5A GAS 0B92 F1 CALL 0B93 15 ISZERO 0B94 80 DUP1 0B95 15 ISZERO 0B96 61 PUSH2 0x0ba3 0B99 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0B92 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0B93 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 0x0ba3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0B9A: // Incoming jump from 0x0B99, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0B9A returndata.length // @0B9E returndata[0x00:0x00 + returndata.length] // @0B9F returndata.length // @0BA2 memory[0x00:0x00 + returndata.length] // } 0B9A 3D RETURNDATASIZE 0B9B 60 PUSH1 0x00 0B9D 80 DUP1 0B9E 3E RETURNDATACOPY 0B9F 3D RETURNDATASIZE 0BA0 60 PUSH1 0x00 0BA2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B9E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BA2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BA3: // Incoming jump from 0x0B99, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[6] // { // @0BA8 storage[0x07] // @0BAC stack[-4] // @0BB7 stack[-3] // @0BB9 msg.sender // @0BBA address(this) // @0BBB stack[-7] // } 0BA3 5B JUMPDEST 0BA4 50 POP 0BA5 50 POP 0BA6 60 PUSH1 0x07 0BA8 54 SLOAD 0BA9 61 PUSH2 0x0bc0 0BAC 92 SWAP3 0BAD 50 POP 0BAE 60 PUSH1 0x01 0BB0 60 PUSH1 0x01 0BB2 60 PUSH1 0xa0 0BB4 1B SHL 0BB5 03 SUB 0BB6 16 AND 0BB7 90 SWAP1 0BB8 50 POP 0BB9 33 CALLER 0BBA 30 ADDRESS 0BBB 86 DUP7 0BBC 61 PUSH2 0x15bd 0BBF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BAC stack[-4] = 0x0bc0 // @0BB7 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[0x07] // @0BB9 stack[-2] = msg.sender // @0BBA stack[-1] = address(this) // @0BBB stack[0] = stack[-7] // } // Block ends with call to 0x15bd, returns to 0x0BC0 label_0BC0: // Incoming jump from 0x0B42 // Incoming return from call to 0x15BD at 0x0BBF 0BC0 5B JUMPDEST 0BC1 61 PUSH2 0x0bdd 0BC4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bdd label_0BC5: // Incoming jump from 0x09F6, if !((0x01 << 0xa0) - 0x01 & storage[0x0a]) // Inputs[4] // { // @0BC8 storage[0x07] // @0BD6 msg.sender // @0BD7 address(this) // @0BD8 stack[-3] // } 0BC5 5B JUMPDEST 0BC6 60 PUSH1 0x07 0BC8 54 SLOAD 0BC9 61 PUSH2 0x0bdd 0BCC 90 SWAP1 0BCD 60 PUSH1 0x01 0BCF 60 PUSH1 0x01 0BD1 60 PUSH1 0xa0 0BD3 1B SHL 0BD4 03 SUB 0BD5 16 AND 0BD6 33 CALLER 0BD7 30 ADDRESS 0BD8 86 DUP7 0BD9 61 PUSH2 0x15bd 0BDC 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0BCC stack[0] = 0x0bdd // @0BD5 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // @0BD6 stack[2] = msg.sender // @0BD7 stack[3] = address(this) // @0BD8 stack[4] = stack[-3] // } // Block ends with call to 0x15bd, returns to 0x0BDD label_0BDD: // Incoming return from call to 0x15BD at 0x0BDC // Incoming jump from 0x0BC4 // Inputs[2] // { // @0BE1 stack[-2] // @0BE2 stack[-3] // } 0BDD 5B JUMPDEST 0BDE 61 PUSH2 0x0be7 0BE1 82 DUP3 0BE2 84 DUP5 0BE3 61 PUSH2 0x171a 0BE6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BDE stack[0] = 0x0be7 // @0BE1 stack[1] = stack[-2] // @0BE2 stack[2] = stack[-3] // } // Block ends with call to 0x171a, returns to 0x0BE7 label_0BE7: // Incoming return from call to 0x171A at 0x0BE6 // Inputs[7] // { // @0BEB memory[0x40:0x60] // @0BEC stack[-3] // @0BF0 memory[0x40:0x60] // @0BF9 stack[-2] // @0BFC msg.sender // @0C27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @0C2A stack[-4] // } 0BE7 5B JUMPDEST 0BE8 60 PUSH1 0x40 0BEA 80 DUP1 0BEB 51 MLOAD 0BEC 84 DUP5 0BED 81 DUP2 0BEE 52 MSTORE 0BEF 90 SWAP1 0BF0 51 MLOAD 0BF1 60 PUSH1 0x01 0BF3 60 PUSH1 0x01 0BF5 60 PUSH1 0xa0 0BF7 1B SHL 0BF8 03 SUB 0BF9 84 DUP5 0BFA 16 AND 0BFB 91 SWAP2 0BFC 33 CALLER 0BFD 91 SWAP2 0BFE 7F PUSH32 0xeb5580a0908e96b78bdcb1a3c5638793b491a6073c3ff56061a069cb20581773 0C1F 91 SWAP2 0C20 81 DUP2 0C21 90 SWAP1 0C22 03 SUB 0C23 60 PUSH1 0x20 0C25 01 ADD 0C26 90 SWAP1 0C27 A3 LOG3 0C28 50 POP 0C29 90 SWAP1 0C2A 91 SWAP2 0C2B 90 SWAP1 0C2C 50 POP 0C2D 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0BEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0C27 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xeb5580a0908e96b78bdcb1a3c5638793b491a6073c3ff56061a069cb20581773, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // @0C2A stack[-4] = stack[-3] // } // Block ends with unconditional jump to stack[-4] label_0C2E: // Incoming call from 0x03B1, returns to 0x03B2 // Inputs[2] // { // @0C31 storage[0x03] // @0C35 stack[-1] // } 0C2E 5B JUMPDEST 0C2F 60 PUSH1 0x03 0C31 54 SLOAD 0C32 60 PUSH1 0xff 0C34 16 AND 0C35 81 DUP2 0C36 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C34 stack[0] = 0xff & storage[0x03] } // Block ends with unconditional jump to stack[-1] label_0C37: // Incoming jump from 0x03F1 0C37 5B JUMPDEST 0C38 61 PUSH2 0x0c3f 0C3B 61 PUSH2 0x1296 0C3E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C38 stack[0] = 0x0c3f } // Block ends with call to 0x1296, returns to 0x0C3F label_0C3F: // Incoming return from call to 0x1296 at 0x0C3E // Inputs[2] // { // @0C48 stack[-1] // @0C49 tx.origin // } 0C3F 5B JUMPDEST 0C40 60 PUSH1 0x01 0C42 60 PUSH1 0x01 0C44 60 PUSH1 0xa0 0C46 1B SHL 0C47 03 SUB 0C48 16 AND 0C49 32 ORIGIN 0C4A 60 PUSH1 0x01 0C4C 60 PUSH1 0x01 0C4E 60 PUSH1 0xa0 0C50 1B SHL 0C51 03 SUB 0C52 16 AND 0C53 14 EQ 0C54 61 PUSH2 0x0c92 0C57 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c92, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] label_0C58: // Incoming jump from 0x0C57, if not (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[5] // { // @0C5B memory[0x40:0x60] // @0C76 memory[0x00:0x20] // @0C7F memory[0x00:0x20] // @0C88 memory[0x40:0x60] // @0C91 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0C58 60 PUSH1 0x40 0C5A 80 DUP1 0C5B 51 MLOAD 0C5C 62 PUSH3 0x461bcd 0C60 60 PUSH1 0xe5 0C62 1B SHL 0C63 81 DUP2 0C64 52 MSTORE 0C65 60 PUSH1 0x20 0C67 60 PUSH1 0x04 0C69 82 DUP3 0C6A 01 ADD 0C6B 52 MSTORE 0C6C 60 PUSH1 0x1f 0C6E 60 PUSH1 0x24 0C70 82 DUP3 0C71 01 ADD 0C72 52 MSTORE 0C73 60 PUSH1 0x00 0C75 80 DUP1 0C76 51 MLOAD 0C77 60 PUSH1 0x20 0C79 61 PUSH2 0x1bb7 0C7C 83 DUP4 0C7D 39 CODECOPY 0C7E 81 DUP2 0C7F 51 MLOAD 0C80 91 SWAP2 0C81 52 MSTORE 0C82 60 PUSH1 0x44 0C84 82 DUP3 0C85 01 ADD 0C86 52 MSTORE 0C87 90 SWAP1 0C88 51 MLOAD 0C89 90 SWAP1 0C8A 81 DUP2 0C8B 90 SWAP1 0C8C 03 SUB 0C8D 60 PUSH1 0x64 0C8F 01 ADD 0C90 90 SWAP1 0C91 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @0C64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C6B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C72 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0C7D memory[0x00:0x20] = code[0x1bb7:0x1bd7] // @0C81 memory[0x00:0x20] = memory[0x00:0x20] // @0C86 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0C91 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0C92: // Incoming jump from 0x0C57, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @0C95 storage[0x07] // @0CA3 tx.origin // @0CA4 stack[-1] // } 0C92 5B JUMPDEST 0C93 60 PUSH1 0x07 0C95 54 SLOAD 0C96 61 PUSH2 0x0ca9 0C99 90 SWAP1 0C9A 60 PUSH1 0x01 0C9C 60 PUSH1 0x01 0C9E 60 PUSH1 0xa0 0CA0 1B SHL 0CA1 03 SUB 0CA2 16 AND 0CA3 32 ORIGIN 0CA4 83 DUP4 0CA5 61 PUSH2 0x179b 0CA8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C99 stack[0] = 0x0ca9 // @0CA2 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // @0CA3 stack[2] = tx.origin // @0CA4 stack[3] = stack[-1] // } // Block ends with call to 0x179b, returns to 0x0CA9 label_0CA9: // Incoming return from call to 0x179B at 0x0CA8 // Incoming return from call to 0x1B0F at 0x1441 // Inputs[1] { @0CAB stack[-2] } 0CA9 5B JUMPDEST 0CAA 50 POP 0CAB 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0CAC: // Incoming jump from 0x042A 0CAC 5B JUMPDEST 0CAD 61 PUSH2 0x0cb4 0CB0 61 PUSH2 0x1296 0CB3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CAD stack[0] = 0x0cb4 } // Block ends with call to 0x1296, returns to 0x0CB4 label_0CB4: // Incoming return from call to 0x1296 at 0x0CB3 // Inputs[2] // { // @0CBD stack[-1] // @0CBE tx.origin // } 0CB4 5B JUMPDEST 0CB5 60 PUSH1 0x01 0CB7 60 PUSH1 0x01 0CB9 60 PUSH1 0xa0 0CBB 1B SHL 0CBC 03 SUB 0CBD 16 AND 0CBE 32 ORIGIN 0CBF 60 PUSH1 0x01 0CC1 60 PUSH1 0x01 0CC3 60 PUSH1 0xa0 0CC5 1B SHL 0CC6 03 SUB 0CC7 16 AND 0CC8 14 EQ 0CC9 61 PUSH2 0x0d07 0CCC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d07, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] label_0CCD: // Incoming jump from 0x0CCC, if not (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[5] // { // @0CD0 memory[0x40:0x60] // @0CEB memory[0x00:0x20] // @0CF4 memory[0x00:0x20] // @0CFD memory[0x40:0x60] // @0D06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0CCD 60 PUSH1 0x40 0CCF 80 DUP1 0CD0 51 MLOAD 0CD1 62 PUSH3 0x461bcd 0CD5 60 PUSH1 0xe5 0CD7 1B SHL 0CD8 81 DUP2 0CD9 52 MSTORE 0CDA 60 PUSH1 0x20 0CDC 60 PUSH1 0x04 0CDE 82 DUP3 0CDF 01 ADD 0CE0 52 MSTORE 0CE1 60 PUSH1 0x1f 0CE3 60 PUSH1 0x24 0CE5 82 DUP3 0CE6 01 ADD 0CE7 52 MSTORE 0CE8 60 PUSH1 0x00 0CEA 80 DUP1 0CEB 51 MLOAD 0CEC 60 PUSH1 0x20 0CEE 61 PUSH2 0x1bb7 0CF1 83 DUP4 0CF2 39 CODECOPY 0CF3 81 DUP2 0CF4 51 MLOAD 0CF5 91 SWAP2 0CF6 52 MSTORE 0CF7 60 PUSH1 0x44 0CF9 82 DUP3 0CFA 01 ADD 0CFB 52 MSTORE 0CFC 90 SWAP1 0CFD 51 MLOAD 0CFE 90 SWAP1 0CFF 81 DUP2 0D00 90 SWAP1 0D01 03 SUB 0D02 60 PUSH1 0x64 0D04 01 ADD 0D05 90 SWAP1 0D06 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @0CD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CE0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CE7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0CF2 memory[0x00:0x20] = code[0x1bb7:0x1bd7] // @0CF6 memory[0x00:0x20] = memory[0x00:0x20] // @0CFB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0D06 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0D07: // Incoming jump from 0x0CCC, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[4] // { // @0D10 stack[-2] // @0D1F memory[0x00:0x40] // @0D20 storage[keccak256(memory[0x00:0x40])] // @0D25 stack[-1] // } 0D07 5B JUMPDEST 0D08 60 PUSH1 0x01 0D0A 60 PUSH1 0x01 0D0C 60 PUSH1 0xa0 0D0E 1B SHL 0D0F 03 SUB 0D10 82 DUP3 0D11 16 AND 0D12 60 PUSH1 0x00 0D14 90 SWAP1 0D15 81 DUP2 0D16 52 MSTORE 0D17 60 PUSH1 0x05 0D19 60 PUSH1 0x20 0D1B 52 MSTORE 0D1C 60 PUSH1 0x40 0D1E 90 SWAP1 0D1F 20 SHA3 0D20 54 SLOAD 0D21 61 PUSH2 0x0d30 0D24 90 SWAP1 0D25 82 DUP3 0D26 63 PUSH4 0xffffffff 0D2B 61 PUSH2 0x18ef 0D2E 16 AND 0D2F 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0D16 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0D1B memory[0x20:0x40] = 0x05 // @0D24 stack[0] = 0x0d30 // @0D24 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0D25 stack[2] = stack[-1] // } // Block ends with call to 0x18ef & 0xffffffff, returns to 0x0D30 label_0D30: // Incoming return from call to 0x18EF at 0x0D2F // Inputs[5] // { // @0D39 stack[-1] // @0D3A stack[-3] // @0D49 memory[0x00:0x40] // @0D4B stack[-2] // @0D4F stack[-4] // } 0D30 5B JUMPDEST 0D31 60 PUSH1 0x01 0D33 60 PUSH1 0x01 0D35 60 PUSH1 0xa0 0D37 1B SHL 0D38 03 SUB 0D39 90 SWAP1 0D3A 92 SWAP3 0D3B 16 AND 0D3C 60 PUSH1 0x00 0D3E 90 SWAP1 0D3F 81 DUP2 0D40 52 MSTORE 0D41 60 PUSH1 0x05 0D43 60 PUSH1 0x20 0D45 52 MSTORE 0D46 60 PUSH1 0x40 0D48 90 SWAP1 0D49 20 SHA3 0D4A 91 SWAP2 0D4B 90 SWAP1 0D4C 91 SWAP2 0D4D 55 SSTORE 0D4E 50 POP 0D4F 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0D40 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0D45 memory[0x20:0x40] = 0x05 // @0D4D storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-4] label_0D50: // Incoming jump from 0x0454 // Inputs[4] // { // @0D51 msg.sender // @0D5F memory[0x00:0x40] // @0D60 storage[keccak256(memory[0x00:0x40])] // @0D65 stack[-1] // } 0D50 5B JUMPDEST 0D51 33 CALLER 0D52 60 PUSH1 0x00 0D54 90 SWAP1 0D55 81 DUP2 0D56 52 MSTORE 0D57 60 PUSH1 0x05 0D59 60 PUSH1 0x20 0D5B 52 MSTORE 0D5C 60 PUSH1 0x40 0D5E 90 SWAP1 0D5F 20 SHA3 0D60 54 SLOAD 0D61 61 PUSH2 0x0d70 0D64 90 SWAP1 0D65 82 DUP3 0D66 63 PUSH4 0xffffffff 0D6B 61 PUSH2 0x14b3 0D6E 16 AND 0D6F 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0D56 memory[0x00:0x20] = msg.sender // @0D5B memory[0x20:0x40] = 0x05 // @0D64 stack[0] = 0x0d70 // @0D64 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0D65 stack[2] = stack[-1] // } // Block ends with call to 0x14b3 & 0xffffffff, returns to 0x0D70 label_0D70: // Incoming return from call to 0x14B3 at 0x0D6F // Inputs[4] // { // @0D71 msg.sender // @0D7F memory[0x00:0x40] // @0D80 stack[-1] // @0D82 stack[-3] // } 0D70 5B JUMPDEST 0D71 33 CALLER 0D72 60 PUSH1 0x00 0D74 90 SWAP1 0D75 81 DUP2 0D76 52 MSTORE 0D77 60 PUSH1 0x05 0D79 60 PUSH1 0x20 0D7B 52 MSTORE 0D7C 60 PUSH1 0x40 0D7E 90 SWAP1 0D7F 20 SHA3 0D80 55 SSTORE 0D81 50 POP 0D82 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0D76 memory[0x00:0x20] = msg.sender // @0D7B memory[0x20:0x40] = 0x05 // @0D80 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_0D83: // Incoming jump from 0x0487 // Inputs[2] // { // @0D86 storage[0x0a] // @0D90 msg.sender // } 0D83 5B JUMPDEST 0D84 60 PUSH1 0x0a 0D86 54 SLOAD 0D87 60 PUSH1 0x01 0D89 60 PUSH1 0x01 0D8B 60 PUSH1 0xa0 0D8D 1B SHL 0D8E 03 SUB 0D8F 16 AND 0D90 33 CALLER 0D91 14 EQ 0D92 80 DUP1 0D93 61 PUSH2 0x0db4 0D96 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D91 stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] } // Block ends with conditional jump to 0x0db4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0D97: // Incoming jump from 0x0D96, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] 0D97 50 POP 0D98 61 PUSH2 0x0d9f 0D9B 61 PUSH2 0x1296 0D9E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D98 stack[-1] = 0x0d9f } // Block ends with call to 0x1296, returns to 0x0D9F label_0D9F: // Incoming return from call to 0x1296 at 0x0D9E // Inputs[2] // { // @0DA8 stack[-1] // @0DA9 tx.origin // } 0D9F 5B JUMPDEST 0DA0 60 PUSH1 0x01 0DA2 60 PUSH1 0x01 0DA4 60 PUSH1 0xa0 0DA6 1B SHL 0DA7 03 SUB 0DA8 16 AND 0DA9 32 ORIGIN 0DAA 60 PUSH1 0x01 0DAC 60 PUSH1 0x01 0DAE 60 PUSH1 0xa0 0DB0 1B SHL 0DB1 03 SUB 0DB2 16 AND 0DB3 14 EQ // Stack delta = +0 // Outputs[1] { @0DB3 stack[-1] = (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_0DB4: // Incoming jump from 0x0D96, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Incoming jump from 0x0DB3 // Inputs[1] { @0DB8 stack[-1] } 0DB4 5B JUMPDEST 0DB5 61 PUSH2 0x0dea 0DB8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dea, if stack[-1] label_0DB9: // Incoming jump from 0x0DB8, if not stack[-1] // Inputs[3] // { // @0DBC memory[0x40:0x60] // @0DE0 memory[0x40:0x60] // @0DE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0DB9 60 PUSH1 0x40 0DBB 80 DUP1 0DBC 51 MLOAD 0DBD 62 PUSH3 0x461bcd 0DC1 60 PUSH1 0xe5 0DC3 1B SHL 0DC4 81 DUP2 0DC5 52 MSTORE 0DC6 60 PUSH1 0x20 0DC8 60 PUSH1 0x04 0DCA 82 DUP3 0DCB 01 ADD 0DCC 52 MSTORE 0DCD 60 PUSH1 0x02 0DCF 60 PUSH1 0x24 0DD1 82 DUP3 0DD2 01 ADD 0DD3 52 MSTORE 0DD4 61 PUSH2 0x3333 0DD7 60 PUSH1 0xf1 0DD9 1B SHL 0DDA 60 PUSH1 0x44 0DDC 82 DUP3 0DDD 01 ADD 0DDE 52 MSTORE 0DDF 90 SWAP1 0DE0 51 MLOAD 0DE1 90 SWAP1 0DE2 81 DUP2 0DE3 90 SWAP1 0DE4 03 SUB 0DE5 60 PUSH1 0x64 0DE7 01 ADD 0DE8 90 SWAP1 0DE9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0DC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DCC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DD3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @0DDE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x3333 << 0xf1 // @0DE9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0DEA: // Incoming jump from 0x0DB8, if stack[-1] // Inputs[5] // { // @0DED storage[0x07] // @0DF1 memory[0x40:0x60] // @0E04 stack[-1] // @0E0D memory[0x40:0x60] // @0E2F address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // } 0DEA 5B JUMPDEST 0DEB 60 PUSH1 0x07 0DED 54 SLOAD 0DEE 60 PUSH1 0x40 0DF0 80 DUP1 0DF1 51 MLOAD 0DF2 63 PUSH4 0x70a08231 0DF7 60 PUSH1 0xe0 0DF9 1B SHL 0DFA 81 DUP2 0DFB 52 MSTORE 0DFC 60 PUSH1 0x01 0DFE 60 PUSH1 0x01 0E00 60 PUSH1 0xa0 0E02 1B SHL 0E03 03 SUB 0E04 84 DUP5 0E05 81 DUP2 0E06 16 AND 0E07 60 PUSH1 0x04 0E09 83 DUP4 0E0A 01 ADD 0E0B 52 MSTORE 0E0C 91 SWAP2 0E0D 51 MLOAD 0E0E 60 PUSH1 0x00 0E10 93 SWAP4 0E11 92 SWAP3 0E12 90 SWAP1 0E13 92 SWAP3 0E14 16 AND 0E15 91 SWAP2 0E16 63 PUSH4 0x70a08231 0E1B 91 SWAP2 0E1C 60 PUSH1 0x24 0E1E 80 DUP1 0E1F 82 DUP3 0E20 01 ADD 0E21 92 SWAP3 0E22 60 PUSH1 0x20 0E24 92 SWAP3 0E25 90 SWAP1 0E26 91 SWAP2 0E27 90 SWAP1 0E28 82 DUP3 0E29 90 SWAP1 0E2A 03 SUB 0E2B 01 ADD 0E2C 81 DUP2 0E2D 86 DUP7 0E2E 80 DUP1 0E2F 3B EXTCODESIZE 0E30 15 ISZERO 0E31 80 DUP1 0E32 15 ISZERO 0E33 61 PUSH2 0x0e3b 0E36 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0DFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @0E0B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0E10 stack[0] = 0x00 // @0E15 stack[1] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @0E1B stack[2] = 0x70a08231 // @0E21 stack[3] = memory[0x40:0x60] + 0x24 // @0E24 stack[4] = 0x20 // @0E26 stack[5] = memory[0x40:0x60] // @0E2B stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0E2C stack[7] = memory[0x40:0x60] // @0E2D stack[8] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @0E30 stack[9] = !address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0e3b, if !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length label_0E37: // Incoming jump from 0x0E36, if not !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0E3A memory[0x00:0x00] } 0E37 60 PUSH1 0x00 0E39 80 DUP1 0E3A FD *REVERT // Stack delta = +0 // Outputs[1] { @0E3A revert(memory[0x00:0x00]); } // Block terminates label_0E3B: // Incoming jump from 0x0E36, if !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @0E3D msg.gas // @0E3E memory[stack[-3]:stack[-3] + stack[-4]] // @0E3E stack[-2] // @0E3E stack[-6] // @0E3E stack[-3] // @0E3E stack[-5] // @0E3E stack[-4] // @0E3E address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 0E3B 5B JUMPDEST 0E3C 50 POP 0E3D 5A GAS 0E3E FA STATICCALL 0E3F 15 ISZERO 0E40 80 DUP1 0E41 15 ISZERO 0E42 61 PUSH2 0x0e4f 0E45 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0E3E memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0E3F stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0e4f, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0E46: // Incoming jump from 0x0E45, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0E46 returndata.length // @0E4A returndata[0x00:0x00 + returndata.length] // @0E4B returndata.length // @0E4E memory[0x00:0x00 + returndata.length] // } 0E46 3D RETURNDATASIZE 0E47 60 PUSH1 0x00 0E49 80 DUP1 0E4A 3E RETURNDATACOPY 0E4B 3D RETURNDATASIZE 0E4C 60 PUSH1 0x00 0E4E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E4A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0E4E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0E4F: // Incoming jump from 0x0E45, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0E56 memory[0x40:0x60] // @0E57 returndata.length // } 0E4F 5B JUMPDEST 0E50 50 POP 0E51 50 POP 0E52 50 POP 0E53 50 POP 0E54 60 PUSH1 0x40 0E56 51 MLOAD 0E57 3D RETURNDATASIZE 0E58 60 PUSH1 0x20 0E5A 81 DUP2 0E5B 10 LT 0E5C 15 ISZERO 0E5D 61 PUSH2 0x0e65 0E60 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0E56 stack[-4] = memory[0x40:0x60] // @0E57 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0e65, if !(returndata.length < 0x20) label_0E61: // Incoming jump from 0x0E60, if not !(returndata.length < 0x20) // Inputs[1] { @0E64 memory[0x00:0x00] } 0E61 60 PUSH1 0x00 0E63 80 DUP1 0E64 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E64 revert(memory[0x00:0x00]); } // Block terminates label_0E65: // Incoming jump from 0x0E60, if !(returndata.length < 0x20) // Inputs[9] // { // @0E67 memory[stack[-2]:stack[-2] + 0x20] // @0E67 stack[-2] // @0E6A storage[0x07] // @0E6E memory[0x40:0x60] // @0E81 stack[-4] // @0E89 address(this) // @0E90 memory[0x40:0x60] // @0E92 stack[-3] // @0EB4 address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // } 0E65 5B JUMPDEST 0E66 50 POP 0E67 51 MLOAD 0E68 60 PUSH1 0x07 0E6A 54 SLOAD 0E6B 60 PUSH1 0x40 0E6D 80 DUP1 0E6E 51 MLOAD 0E6F 63 PUSH4 0x6eb1769f 0E74 60 PUSH1 0xe1 0E76 1B SHL 0E77 81 DUP2 0E78 52 MSTORE 0E79 60 PUSH1 0x01 0E7B 60 PUSH1 0x01 0E7D 60 PUSH1 0xa0 0E7F 1B SHL 0E80 03 SUB 0E81 86 DUP7 0E82 81 DUP2 0E83 16 AND 0E84 60 PUSH1 0x04 0E86 83 DUP4 0E87 01 ADD 0E88 52 MSTORE 0E89 30 ADDRESS 0E8A 60 PUSH1 0x24 0E8C 83 DUP4 0E8D 01 ADD 0E8E 52 MSTORE 0E8F 91 SWAP2 0E90 51 MLOAD 0E91 93 SWAP4 0E92 94 SWAP5 0E93 50 POP 0E94 60 PUSH1 0x00 0E96 93 SWAP4 0E97 91 SWAP2 0E98 90 SWAP1 0E99 92 SWAP3 0E9A 16 AND 0E9B 91 SWAP2 0E9C 63 PUSH4 0xdd62ed3e 0EA1 91 SWAP2 0EA2 60 PUSH1 0x44 0EA4 80 DUP1 0EA5 83 DUP4 0EA6 01 ADD 0EA7 92 SWAP3 0EA8 60 PUSH1 0x20 0EAA 92 SWAP3 0EAB 91 SWAP2 0EAC 90 SWAP1 0EAD 82 DUP3 0EAE 90 SWAP1 0EAF 03 SUB 0EB0 01 ADD 0EB1 81 DUP2 0EB2 86 DUP7 0EB3 80 DUP1 0EB4 3B EXTCODESIZE 0EB5 15 ISZERO 0EB6 80 DUP1 0EB7 15 ISZERO 0EB8 61 PUSH2 0x0ec0 0EBB 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @0E78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6eb1769f << 0xe1 // @0E88 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @0E8E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @0E92 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0E96 stack[-2] = 0x00 // @0E9B stack[-1] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @0EA1 stack[0] = 0xdd62ed3e // @0EA7 stack[1] = memory[0x40:0x60] + 0x44 // @0EAA stack[2] = 0x20 // @0EAB stack[3] = memory[0x40:0x60] // @0EB0 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @0EB1 stack[5] = memory[0x40:0x60] // @0EB2 stack[6] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @0EB5 stack[7] = !address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0ec0, if !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length label_0EBC: // Incoming jump from 0x0EBB, if not !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0EBF memory[0x00:0x00] } 0EBC 60 PUSH1 0x00 0EBE 80 DUP1 0EBF FD *REVERT // Stack delta = +0 // Outputs[1] { @0EBF revert(memory[0x00:0x00]); } // Block terminates label_0EC0: // Incoming jump from 0x0EBB, if !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @0EC2 msg.gas // @0EC3 stack[-2] // @0EC3 stack[-4] // @0EC3 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0EC3 memory[stack[-3]:stack[-3] + stack[-4]] // @0EC3 stack[-6] // @0EC3 stack[-5] // @0EC3 stack[-3] // } 0EC0 5B JUMPDEST 0EC1 50 POP 0EC2 5A GAS 0EC3 FA STATICCALL 0EC4 15 ISZERO 0EC5 80 DUP1 0EC6 15 ISZERO 0EC7 61 PUSH2 0x0ed4 0ECA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0EC3 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0EC4 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0ed4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0ECB: // Incoming jump from 0x0ECA, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0ECB returndata.length // @0ECF returndata[0x00:0x00 + returndata.length] // @0ED0 returndata.length // @0ED3 memory[0x00:0x00 + returndata.length] // } 0ECB 3D RETURNDATASIZE 0ECC 60 PUSH1 0x00 0ECE 80 DUP1 0ECF 3E RETURNDATACOPY 0ED0 3D RETURNDATASIZE 0ED1 60 PUSH1 0x00 0ED3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0ECF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0ED3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0ED4: // Incoming jump from 0x0ECA, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0EDB memory[0x40:0x60] // @0EDC returndata.length // } 0ED4 5B JUMPDEST 0ED5 50 POP 0ED6 50 POP 0ED7 50 POP 0ED8 50 POP 0ED9 60 PUSH1 0x40 0EDB 51 MLOAD 0EDC 3D RETURNDATASIZE 0EDD 60 PUSH1 0x20 0EDF 81 DUP2 0EE0 10 LT 0EE1 15 ISZERO 0EE2 61 PUSH2 0x0eea 0EE5 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0EDB stack[-4] = memory[0x40:0x60] // @0EDC stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0eea, if !(returndata.length < 0x20) label_0EE6: // Incoming jump from 0x0EE5, if not !(returndata.length < 0x20) // Inputs[1] { @0EE9 memory[0x00:0x00] } 0EE6 60 PUSH1 0x00 0EE8 80 DUP1 0EE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EE9 revert(memory[0x00:0x00]); } // Block terminates label_0EEA: // Incoming jump from 0x0EE5, if !(returndata.length < 0x20) // Inputs[3] // { // @0EEC stack[-2] // @0EEC memory[stack[-2]:stack[-2] + 0x20] // @0EED stack[-3] // } 0EEA 5B JUMPDEST 0EEB 50 POP 0EEC 51 MLOAD 0EED 90 SWAP1 0EEE 50 POP 0EEF 80 DUP1 0EF0 15 ISZERO 0EF1 80 DUP1 0EF2 15 ISZERO 0EF3 90 SWAP1 0EF4 61 PUSH2 0x0efd 0EF7 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0EED stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0EF3 stack[-2] = !!memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0efd, if !memory[stack[-2]:stack[-2] + 0x20] label_0EF8: // Incoming jump from 0x0EF7, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @0EFB stack[-3] } 0EF8 50 POP 0EF9 60 PUSH1 0x00 0EFB 82 DUP3 0EFC 11 GT 0EFD 5B JUMPDEST 0EFE 15 ISZERO 0EFF 61 PUSH2 0x0f4c 0F02 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f4c, if !(stack[-3] > 0x00) label_0F03: // Incoming jump from 0x0F02, if not !stack[-1] // Incoming jump from 0x0F02, if not !(stack[-3] > 0x00) // Inputs[2] // { // @0F03 stack[-1] // @0F04 stack[-2] // } 0F03 80 DUP1 0F04 82 DUP3 0F05 10 LT 0F06 61 PUSH2 0x0f2d 0F09 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f2d, if stack[-2] < stack[-1] label_0F0A: // Incoming jump from 0x0F09, if not stack[-2] < stack[-1] // Inputs[2] // { // @0F0C storage[0x07] // @0F1A stack[-3] // } 0F0A 60 PUSH1 0x07 0F0C 54 SLOAD 0F0D 61 PUSH2 0x0f28 0F10 90 SWAP1 0F11 60 PUSH1 0x01 0F13 60 PUSH1 0x01 0F15 60 PUSH1 0xa0 0F17 1B SHL 0F18 03 SUB 0F19 16 AND 0F1A 84 DUP5 0F1B 61 PUSH2 0x0f22 0F1E 61 PUSH2 0x1296 0F21 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F10 stack[0] = 0x0f28 // @0F19 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // @0F1A stack[2] = stack[-3] // @0F1B stack[3] = 0x0f22 // } // Block ends with call to 0x1296, returns to 0x0F22 label_0F22: // Incoming return from call to 0x1296 at 0x0F21 // Inputs[1] { @0F23 stack[-5] } 0F22 5B JUMPDEST 0F23 84 DUP5 0F24 61 PUSH2 0x15bd 0F27 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F23 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x15bd label_0F28: // Incoming return from call to 0x0F22 at 0x0F21 0F28 5B JUMPDEST 0F29 61 PUSH2 0x0f4c 0F2C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f4c label_0F2D: // Incoming jump from 0x0F09, if stack[-2] < stack[-1] // Inputs[2] // { // @0F30 storage[0x07] // @0F3E stack[-3] // } 0F2D 5B JUMPDEST 0F2E 60 PUSH1 0x07 0F30 54 SLOAD 0F31 61 PUSH2 0x0f4c 0F34 90 SWAP1 0F35 60 PUSH1 0x01 0F37 60 PUSH1 0x01 0F39 60 PUSH1 0xa0 0F3B 1B SHL 0F3C 03 SUB 0F3D 16 AND 0F3E 84 DUP5 0F3F 61 PUSH2 0x0f46 0F42 61 PUSH2 0x1296 0F45 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F34 stack[0] = 0x0f4c // @0F3D stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // @0F3E stack[2] = stack[-3] // @0F3F stack[3] = 0x0f46 // } // Block ends with call to 0x1296, returns to 0x0F46 label_0F46: // Incoming return from call to 0x1296 at 0x0F45 // Inputs[1] { @0F47 stack[-6] } 0F46 5B JUMPDEST 0F47 85 DUP6 0F48 61 PUSH2 0x15bd 0F4B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F47 stack[0] = stack[-6] } // Block ends with unconditional jump to 0x15bd label_0F4C: // Incoming jump from 0x0F02, if !stack[-1] // Incoming return from call to 0x0F46 at 0x0F45 // Incoming jump from 0x0F2C // Incoming jump from 0x0F02, if !(stack[-3] > 0x00) // Inputs[1] { @0F50 stack[-4] } 0F4C 5B JUMPDEST 0F4D 50 POP 0F4E 50 POP 0F4F 50 POP 0F50 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0F51: // Incoming call from 0x049C, returns to 0x049D // Inputs[2] // { // @0F54 storage[0x08] // @0F5E stack[-1] // } 0F51 5B JUMPDEST 0F52 60 PUSH1 0x08 0F54 54 SLOAD 0F55 60 PUSH1 0x01 0F57 60 PUSH1 0x01 0F59 60 PUSH1 0xa0 0F5B 1B SHL 0F5C 03 SUB 0F5D 16 AND 0F5E 81 DUP2 0F5F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F5D stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to stack[-1] label_0F60: // Incoming jump from 0x04EB 0F60 5B JUMPDEST 0F61 61 PUSH2 0x0f68 0F64 61 PUSH2 0x1296 0F67 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F61 stack[0] = 0x0f68 } // Block ends with call to 0x1296, returns to 0x0F68 label_0F68: // Incoming return from call to 0x1296 at 0x0F67 // Inputs[2] // { // @0F71 stack[-1] // @0F72 tx.origin // } 0F68 5B JUMPDEST 0F69 60 PUSH1 0x01 0F6B 60 PUSH1 0x01 0F6D 60 PUSH1 0xa0 0F6F 1B SHL 0F70 03 SUB 0F71 16 AND 0F72 32 ORIGIN 0F73 60 PUSH1 0x01 0F75 60 PUSH1 0x01 0F77 60 PUSH1 0xa0 0F79 1B SHL 0F7A 03 SUB 0F7B 16 AND 0F7C 14 EQ 0F7D 61 PUSH2 0x0fbb 0F80 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fbb, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] label_0F81: // Incoming jump from 0x0F80, if not (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[5] // { // @0F84 memory[0x40:0x60] // @0F9F memory[0x00:0x20] // @0FA8 memory[0x00:0x20] // @0FB1 memory[0x40:0x60] // @0FBA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F81 60 PUSH1 0x40 0F83 80 DUP1 0F84 51 MLOAD 0F85 62 PUSH3 0x461bcd 0F89 60 PUSH1 0xe5 0F8B 1B SHL 0F8C 81 DUP2 0F8D 52 MSTORE 0F8E 60 PUSH1 0x20 0F90 60 PUSH1 0x04 0F92 82 DUP3 0F93 01 ADD 0F94 52 MSTORE 0F95 60 PUSH1 0x1f 0F97 60 PUSH1 0x24 0F99 82 DUP3 0F9A 01 ADD 0F9B 52 MSTORE 0F9C 60 PUSH1 0x00 0F9E 80 DUP1 0F9F 51 MLOAD 0FA0 60 PUSH1 0x20 0FA2 61 PUSH2 0x1bb7 0FA5 83 DUP4 0FA6 39 CODECOPY 0FA7 81 DUP2 0FA8 51 MLOAD 0FA9 91 SWAP2 0FAA 52 MSTORE 0FAB 60 PUSH1 0x44 0FAD 82 DUP3 0FAE 01 ADD 0FAF 52 MSTORE 0FB0 90 SWAP1 0FB1 51 MLOAD 0FB2 90 SWAP1 0FB3 81 DUP2 0FB4 90 SWAP1 0FB5 03 SUB 0FB6 60 PUSH1 0x64 0FB8 01 ADD 0FB9 90 SWAP1 0FBA FD *REVERT // Stack delta = +0 // Outputs[7] // { // @0F8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F94 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F9B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0FA6 memory[0x00:0x20] = code[0x1bb7:0x1bd7] // @0FAA memory[0x00:0x20] = memory[0x00:0x20] // @0FAF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0FBA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0FBB: // Incoming jump from 0x0F80, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[6] // { // @0FBE storage[0x07] // @0FC2 memory[0x40:0x60] // @0FCD address(this) // @0FDB stack[-1] // @0FE4 memory[0x40:0x60] // @1006 address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // } 0FBB 5B JUMPDEST 0FBC 60 PUSH1 0x07 0FBE 54 SLOAD 0FBF 60 PUSH1 0x40 0FC1 80 DUP1 0FC2 51 MLOAD 0FC3 63 PUSH4 0x6eb1769f 0FC8 60 PUSH1 0xe1 0FCA 1B SHL 0FCB 81 DUP2 0FCC 52 MSTORE 0FCD 30 ADDRESS 0FCE 60 PUSH1 0x04 0FD0 82 DUP3 0FD1 01 ADD 0FD2 52 MSTORE 0FD3 60 PUSH1 0x01 0FD5 60 PUSH1 0x01 0FD7 60 PUSH1 0xa0 0FD9 1B SHL 0FDA 03 SUB 0FDB 84 DUP5 0FDC 81 DUP2 0FDD 16 AND 0FDE 60 PUSH1 0x24 0FE0 83 DUP4 0FE1 01 ADD 0FE2 52 MSTORE 0FE3 91 SWAP2 0FE4 51 MLOAD 0FE5 60 PUSH1 0x00 0FE7 93 SWAP4 0FE8 92 SWAP3 0FE9 90 SWAP1 0FEA 92 SWAP3 0FEB 16 AND 0FEC 91 SWAP2 0FED 63 PUSH4 0xdd62ed3e 0FF2 91 SWAP2 0FF3 60 PUSH1 0x44 0FF5 80 DUP1 0FF6 82 DUP3 0FF7 01 ADD 0FF8 92 SWAP3 0FF9 60 PUSH1 0x20 0FFB 92 SWAP3 0FFC 90 SWAP1 0FFD 91 SWAP2 0FFE 90 SWAP1 0FFF 82 DUP3 1000 90 SWAP1 1001 03 SUB 1002 01 ADD 1003 81 DUP2 1004 86 DUP7 1005 80 DUP1 1006 3B EXTCODESIZE 1007 15 ISZERO 1008 80 DUP1 1009 15 ISZERO 100A 61 PUSH2 0x1012 100D 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @0FCC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6eb1769f << 0xe1 // @0FD2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0FE2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0FE7 stack[0] = 0x00 // @0FEC stack[1] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @0FF2 stack[2] = 0xdd62ed3e // @0FF8 stack[3] = memory[0x40:0x60] + 0x44 // @0FFB stack[4] = 0x20 // @0FFD stack[5] = memory[0x40:0x60] // @1002 stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1003 stack[7] = memory[0x40:0x60] // @1004 stack[8] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @1007 stack[9] = !address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1012, if !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length label_100E: // Incoming jump from 0x100D, if not !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1011 memory[0x00:0x00] } 100E 60 PUSH1 0x00 1010 80 DUP1 1011 FD *REVERT // Stack delta = +0 // Outputs[1] { @1011 revert(memory[0x00:0x00]); } // Block terminates label_1012: // Incoming jump from 0x100D, if !!address(storage[0x07] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @1014 msg.gas // @1015 stack[-6] // @1015 memory[stack[-3]:stack[-3] + stack[-4]] // @1015 stack[-3] // @1015 stack[-5] // @1015 stack[-2] // @1015 stack[-4] // @1015 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 1012 5B JUMPDEST 1013 50 POP 1014 5A GAS 1015 FA STATICCALL 1016 15 ISZERO 1017 80 DUP1 1018 15 ISZERO 1019 61 PUSH2 0x1026 101C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1015 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1016 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1026, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_101D: // Incoming jump from 0x101C, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @101D returndata.length // @1021 returndata[0x00:0x00 + returndata.length] // @1022 returndata.length // @1025 memory[0x00:0x00 + returndata.length] // } 101D 3D RETURNDATASIZE 101E 60 PUSH1 0x00 1020 80 DUP1 1021 3E RETURNDATACOPY 1022 3D RETURNDATASIZE 1023 60 PUSH1 0x00 1025 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1021 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1025 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1026: // Incoming jump from 0x101C, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @102D memory[0x40:0x60] // @102E returndata.length // } 1026 5B JUMPDEST 1027 50 POP 1028 50 POP 1029 50 POP 102A 50 POP 102B 60 PUSH1 0x40 102D 51 MLOAD 102E 3D RETURNDATASIZE 102F 60 PUSH1 0x20 1031 81 DUP2 1032 10 LT 1033 15 ISZERO 1034 61 PUSH2 0x103c 1037 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @102D stack[-4] = memory[0x40:0x60] // @102E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x103c, if !(returndata.length < 0x20) label_1038: // Incoming jump from 0x1037, if not !(returndata.length < 0x20) // Inputs[1] { @103B memory[0x00:0x00] } 1038 60 PUSH1 0x00 103A 80 DUP1 103B FD *REVERT // Stack delta = +0 // Outputs[1] { @103B revert(memory[0x00:0x00]); } // Block terminates label_103C: // Incoming jump from 0x1037, if !(returndata.length < 0x20) // Inputs[3] // { // @103E memory[stack[-2]:stack[-2] + 0x20] // @103E stack[-2] // @103F stack[-3] // } 103C 5B JUMPDEST 103D 50 POP 103E 51 MLOAD 103F 90 SWAP1 1040 50 POP 1041 80 DUP1 1042 61 PUSH2 0x105e 1045 57 *JUMPI // Stack delta = -2 // Outputs[1] { @103F stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x105e, if memory[stack[-2]:stack[-2] + 0x20] label_1046: // Incoming jump from 0x1045, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @1048 storage[0x07] // @1056 stack[-2] // } 1046 60 PUSH1 0x07 1048 54 SLOAD 1049 61 PUSH2 0x105e 104C 90 SWAP1 104D 60 PUSH1 0x01 104F 60 PUSH1 0x01 1051 60 PUSH1 0xa0 1053 1B SHL 1054 03 SUB 1055 16 AND 1056 83 DUP4 1057 60 PUSH1 0x01 1059 19 NOT 105A 61 PUSH2 0x193e 105D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @104C stack[0] = 0x105e // @1055 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // @1056 stack[2] = stack[-2] // @1059 stack[3] = ~0x01 // } // Block ends with call to 0x193e, returns to 0x105E label_105E: // Incoming jump from 0x1045, if memory[stack[-2]:stack[-2] + 0x20] // Incoming return from call to 0x193E at 0x105D // Inputs[1] { @1061 stack[-3] } 105E 5B JUMPDEST 105F 50 POP 1060 50 POP 1061 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1062: // Incoming jump from 0x0524 // Incoming call from 0x1373, returns to 0x07E4 // Inputs[1] { @1066 stack[-2] } 1062 5B JUMPDEST 1063 60 PUSH1 0x00 1065 80 DUP1 1066 83 DUP4 1067 11 GT 1068 61 PUSH2 0x10a2 106B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1063 stack[0] = 0x00 } // Block ends with conditional jump to 0x10a2, if stack[-2] > 0x00 label_106C: // Incoming jump from 0x106B, if not stack[-2] > 0x00 // Inputs[3] // { // @106E memory[0x40:0x60] // @109C memory[0x40:0x60] // @10A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 106C 60 PUSH1 0x40 106E 51 MLOAD 106F 62 PUSH3 0x461bcd 1073 60 PUSH1 0xe5 1075 1B SHL 1076 81 DUP2 1077 52 MSTORE 1078 60 PUSH1 0x04 107A 01 ADD 107B 80 DUP1 107C 80 DUP1 107D 60 PUSH1 0x20 107F 01 ADD 1080 82 DUP3 1081 81 DUP2 1082 03 SUB 1083 82 DUP3 1084 52 MSTORE 1085 60 PUSH1 0x23 1087 81 DUP2 1088 52 MSTORE 1089 60 PUSH1 0x20 108B 01 ADD 108C 80 DUP1 108D 61 PUSH2 0x1c02 1090 60 PUSH1 0x23 1092 91 SWAP2 1093 39 CODECOPY 1094 60 PUSH1 0x40 1096 01 ADD 1097 91 SWAP2 1098 50 POP 1099 50 POP 109A 60 PUSH1 0x40 109C 51 MLOAD 109D 80 DUP1 109E 91 SWAP2 109F 03 SUB 10A0 90 SWAP1 10A1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1077 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1084 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1088 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1093 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x1c02:0x1c25] // @10A1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_10A2: // Incoming jump from 0x106B, if stack[-2] > 0x00 // Inputs[2] // { // @10A6 msg.sender // @10A7 stack[-3] // } 10A2 5B JUMPDEST 10A3 61 PUSH2 0x10ac 10A6 33 CALLER 10A7 84 DUP5 10A8 61 PUSH2 0x1a8b 10AB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10A3 stack[0] = 0x10ac // @10A6 stack[1] = msg.sender // @10A7 stack[2] = stack[-3] // } // Block ends with call to 0x1a8b, returns to 0x10AC label_10AC: // Incoming return from call to 0x1A8B at 0x10AB // Inputs[3] // { // @10AF storage[0x07] // @10BD stack[-2] // @10BE stack[-3] // } 10AC 5B JUMPDEST 10AD 60 PUSH1 0x07 10AF 54 SLOAD 10B0 61 PUSH2 0x10c3 10B3 90 SWAP1 10B4 60 PUSH1 0x01 10B6 60 PUSH1 0x01 10B8 60 PUSH1 0xa0 10BA 1B SHL 10BB 03 SUB 10BC 16 AND 10BD 83 DUP4 10BE 85 DUP6 10BF 61 PUSH2 0x179b 10C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10B3 stack[0] = 0x10c3 // @10BC stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // @10BD stack[2] = stack[-2] // @10BE stack[3] = stack[-3] // } // Block ends with call to 0x179b, returns to 0x10C3 label_10C3: // Incoming return from call to 0x179B at 0x10C2 // Inputs[7] // { // @10C7 memory[0x40:0x60] // @10C8 stack[-3] // @10CC memory[0x40:0x60] // @10D5 stack[-2] // @10D8 msg.sender // @1103 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1106 stack[-4] // } 10C3 5B JUMPDEST 10C4 60 PUSH1 0x40 10C6 80 DUP1 10C7 51 MLOAD 10C8 84 DUP5 10C9 81 DUP2 10CA 52 MSTORE 10CB 90 SWAP1 10CC 51 MLOAD 10CD 60 PUSH1 0x01 10CF 60 PUSH1 0x01 10D1 60 PUSH1 0xa0 10D3 1B SHL 10D4 03 SUB 10D5 84 DUP5 10D6 16 AND 10D7 91 SWAP2 10D8 33 CALLER 10D9 91 SWAP2 10DA 7F PUSH32 0x12d6424519838e57637c6db9df31af32d7926ff0a53dd37007c191d0fe302818 10FB 91 SWAP2 10FC 81 DUP2 10FD 90 SWAP1 10FE 03 SUB 10FF 60 PUSH1 0x20 1101 01 ADD 1102 90 SWAP1 1103 A3 LOG3 1104 50 POP 1105 90 SWAP1 1106 91 SWAP2 1107 90 SWAP1 1108 50 POP 1109 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @10CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @1103 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x12d6424519838e57637c6db9df31af32d7926ff0a53dd37007c191d0fe302818, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // @1106 stack[-4] = stack[-3] // } // Block ends with unconditional jump to stack[-4] label_110A: // Incoming jump from 0x0557 // Inputs[4] // { // @1112 stack[-1] // @1118 memory[0x00:0x40] // @1119 storage[keccak256(memory[0x00:0x40])] // @111A stack[-2] // } 110A 5B JUMPDEST 110B 60 PUSH1 0x05 110D 60 PUSH1 0x20 110F 52 MSTORE 1110 60 PUSH1 0x00 1112 90 SWAP1 1113 81 DUP2 1114 52 MSTORE 1115 60 PUSH1 0x40 1117 90 SWAP1 1118 20 SHA3 1119 54 SLOAD 111A 81 DUP2 111B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @110F memory[0x20:0x40] = 0x05 // @1114 memory[0x00:0x20] = stack[-1] // @1119 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_111C: // Incoming call from 0x056C, returns to 0x02F8 111C 5B JUMPDEST 111D 61 PUSH2 0x1124 1120 61 PUSH2 0x1b0b 1123 56 *JUMP // Stack delta = +1 // Outputs[1] { @111D stack[0] = 0x1124 } // Block ends with call to 0x1b0b, returns to 0x1124 label_1124: // Incoming return from call to 0x1B0B at 0x1123 // Inputs[1] { @112D stack[-1] } 1124 5B JUMPDEST 1125 60 PUSH1 0x01 1127 60 PUSH1 0x01 1129 60 PUSH1 0xa0 112B 1B SHL 112C 03 SUB 112D 16 AND 112E 61 PUSH2 0x1135 1131 61 PUSH2 0x1296 1134 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @112D stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @112E stack[0] = 0x1135 // } // Block ends with call to 0x1296, returns to 0x1135 label_1135: // Incoming return from call to 0x1296 at 0x1134 // Inputs[2] // { // @113E stack[-1] // @113F stack[-2] // } 1135 5B JUMPDEST 1136 60 PUSH1 0x01 1138 60 PUSH1 0x01 113A 60 PUSH1 0xa0 113C 1B SHL 113D 03 SUB 113E 16 AND 113F 14 EQ 1140 61 PUSH2 0x1190 1143 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1190, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1144: // Incoming jump from 0x1143, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @1147 memory[0x40:0x60] // @1186 memory[0x40:0x60] // @118F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1144 60 PUSH1 0x40 1146 80 DUP1 1147 51 MLOAD 1148 62 PUSH3 0x461bcd 114C 60 PUSH1 0xe5 114E 1B SHL 114F 81 DUP2 1150 52 MSTORE 1151 60 PUSH1 0x20 1153 60 PUSH1 0x04 1155 82 DUP3 1156 01 ADD 1157 81 DUP2 1158 90 SWAP1 1159 52 MSTORE 115A 60 PUSH1 0x24 115C 82 DUP3 115D 01 ADD 115E 52 MSTORE 115F 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1180 60 PUSH1 0x44 1182 82 DUP3 1183 01 ADD 1184 52 MSTORE 1185 90 SWAP1 1186 51 MLOAD 1187 90 SWAP1 1188 81 DUP2 1189 90 SWAP1 118A 03 SUB 118B 60 PUSH1 0x64 118D 01 ADD 118E 90 SWAP1 118F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1150 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1159 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @115E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1184 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @118F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1190: // Incoming jump from 0x1143, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 1190 5B JUMPDEST 1191 61 PUSH2 0x119a 1194 60 PUSH1 0x00 1196 61 PUSH2 0x1b0f 1199 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1191 stack[0] = 0x119a // @1194 stack[1] = 0x00 // } // Block ends with call to 0x1b0f, returns to 0x119A label_119A: // Incoming return from call to 0x1B0F at 0x1199 // Inputs[1] { @119B stack[-1] } 119A 5B JUMPDEST 119B 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_119C: // Incoming jump from 0x059F 119C 5B JUMPDEST 119D 61 PUSH2 0x11a4 11A0 61 PUSH2 0x1296 11A3 56 *JUMP // Stack delta = +1 // Outputs[1] { @119D stack[0] = 0x11a4 } // Block ends with call to 0x1296, returns to 0x11A4 label_11A4: // Incoming return from call to 0x1296 at 0x11A3 // Inputs[2] // { // @11AD stack[-1] // @11AE tx.origin // } 11A4 5B JUMPDEST 11A5 60 PUSH1 0x01 11A7 60 PUSH1 0x01 11A9 60 PUSH1 0xa0 11AB 1B SHL 11AC 03 SUB 11AD 16 AND 11AE 32 ORIGIN 11AF 60 PUSH1 0x01 11B1 60 PUSH1 0x01 11B3 60 PUSH1 0xa0 11B5 1B SHL 11B6 03 SUB 11B7 16 AND 11B8 14 EQ 11B9 61 PUSH2 0x11f7 11BC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11f7, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] label_11BD: // Incoming jump from 0x11BC, if not (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[5] // { // @11C0 memory[0x40:0x60] // @11DB memory[0x00:0x20] // @11E4 memory[0x00:0x20] // @11ED memory[0x40:0x60] // @11F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 11BD 60 PUSH1 0x40 11BF 80 DUP1 11C0 51 MLOAD 11C1 62 PUSH3 0x461bcd 11C5 60 PUSH1 0xe5 11C7 1B SHL 11C8 81 DUP2 11C9 52 MSTORE 11CA 60 PUSH1 0x20 11CC 60 PUSH1 0x04 11CE 82 DUP3 11CF 01 ADD 11D0 52 MSTORE 11D1 60 PUSH1 0x1f 11D3 60 PUSH1 0x24 11D5 82 DUP3 11D6 01 ADD 11D7 52 MSTORE 11D8 60 PUSH1 0x00 11DA 80 DUP1 11DB 51 MLOAD 11DC 60 PUSH1 0x20 11DE 61 PUSH2 0x1bb7 11E1 83 DUP4 11E2 39 CODECOPY 11E3 81 DUP2 11E4 51 MLOAD 11E5 91 SWAP2 11E6 52 MSTORE 11E7 60 PUSH1 0x44 11E9 82 DUP3 11EA 01 ADD 11EB 52 MSTORE 11EC 90 SWAP1 11ED 51 MLOAD 11EE 90 SWAP1 11EF 81 DUP2 11F0 90 SWAP1 11F1 03 SUB 11F2 60 PUSH1 0x64 11F4 01 ADD 11F5 90 SWAP1 11F6 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @11C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11D0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11D7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @11E2 memory[0x00:0x20] = code[0x1bb7:0x1bd7] // @11E6 memory[0x00:0x20] = memory[0x00:0x20] // @11EB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @11F6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_11F7: // Incoming jump from 0x11BC, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @11FB storage[0x0a] // @120E stack[-1] // @1218 stack[-2] // } 11F7 5B JUMPDEST 11F8 60 PUSH1 0x0a 11FA 80 DUP1 11FB 54 SLOAD 11FC 60 PUSH1 0x01 11FE 60 PUSH1 0x01 1200 60 PUSH1 0xa0 1202 1B SHL 1203 03 SUB 1204 19 NOT 1205 16 AND 1206 60 PUSH1 0x01 1208 60 PUSH1 0x01 120A 60 PUSH1 0xa0 120C 1B SHL 120D 03 SUB 120E 92 SWAP3 120F 90 SWAP1 1210 92 SWAP3 1211 16 AND 1212 91 SWAP2 1213 90 SWAP1 1214 91 SWAP2 1215 17 OR 1216 90 SWAP1 1217 55 SSTORE 1218 56 *JUMP // Stack delta = -2 // Outputs[1] { @1217 storage[0x0a] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x0a]) } // Block ends with unconditional jump to stack[-2] label_1219: // Incoming jump from 0x05D2 1219 5B JUMPDEST 121A 61 PUSH2 0x1221 121D 61 PUSH2 0x1296 1220 56 *JUMP // Stack delta = +1 // Outputs[1] { @121A stack[0] = 0x1221 } // Block ends with call to 0x1296, returns to 0x1221 label_1221: // Incoming return from call to 0x1296 at 0x1220 // Inputs[2] // { // @122A stack[-1] // @122B tx.origin // } 1221 5B JUMPDEST 1222 60 PUSH1 0x01 1224 60 PUSH1 0x01 1226 60 PUSH1 0xa0 1228 1B SHL 1229 03 SUB 122A 16 AND 122B 32 ORIGIN 122C 60 PUSH1 0x01 122E 60 PUSH1 0x01 1230 60 PUSH1 0xa0 1232 1B SHL 1233 03 SUB 1234 16 AND 1235 14 EQ 1236 61 PUSH2 0x1274 1239 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1274, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] label_123A: // Incoming jump from 0x1239, if not (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[5] // { // @123D memory[0x40:0x60] // @1258 memory[0x00:0x20] // @1261 memory[0x00:0x20] // @126A memory[0x40:0x60] // @1273 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 123A 60 PUSH1 0x40 123C 80 DUP1 123D 51 MLOAD 123E 62 PUSH3 0x461bcd 1242 60 PUSH1 0xe5 1244 1B SHL 1245 81 DUP2 1246 52 MSTORE 1247 60 PUSH1 0x20 1249 60 PUSH1 0x04 124B 82 DUP3 124C 01 ADD 124D 52 MSTORE 124E 60 PUSH1 0x1f 1250 60 PUSH1 0x24 1252 82 DUP3 1253 01 ADD 1254 52 MSTORE 1255 60 PUSH1 0x00 1257 80 DUP1 1258 51 MLOAD 1259 60 PUSH1 0x20 125B 61 PUSH2 0x1bb7 125E 83 DUP4 125F 39 CODECOPY 1260 81 DUP2 1261 51 MLOAD 1262 91 SWAP2 1263 52 MSTORE 1264 60 PUSH1 0x44 1266 82 DUP3 1267 01 ADD 1268 52 MSTORE 1269 90 SWAP1 126A 51 MLOAD 126B 90 SWAP1 126C 81 DUP2 126D 90 SWAP1 126E 03 SUB 126F 60 PUSH1 0x64 1271 01 ADD 1272 90 SWAP1 1273 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @1246 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @124D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1254 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @125F memory[0x00:0x20] = code[0x1bb7:0x1bd7] // @1263 memory[0x00:0x20] = memory[0x00:0x20] // @1268 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @1273 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1274: // Incoming jump from 0x1239, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @1278 storage[0x0b] // @128B stack[-1] // @1295 stack[-2] // } 1274 5B JUMPDEST 1275 60 PUSH1 0x0b 1277 80 DUP1 1278 54 SLOAD 1279 60 PUSH1 0x01 127B 60 PUSH1 0x01 127D 60 PUSH1 0xa0 127F 1B SHL 1280 03 SUB 1281 19 NOT 1282 16 AND 1283 60 PUSH1 0x01 1285 60 PUSH1 0x01 1287 60 PUSH1 0xa0 1289 1B SHL 128A 03 SUB 128B 92 SWAP3 128C 90 SWAP1 128D 92 SWAP3 128E 16 AND 128F 91 SWAP2 1290 90 SWAP1 1291 91 SWAP2 1292 17 OR 1293 90 SWAP1 1294 55 SSTORE 1295 56 *JUMP // Stack delta = -2 // Outputs[1] { @1294 storage[0x0b] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x0b]) } // Block ends with unconditional jump to stack[-2] label_1296: // Incoming call from 0x07F1, returns to 0x07F2 // Incoming call from 0x0D9E, returns to 0x0D9F // Incoming call from 0x05E7, returns to 0x049D // Incoming call from 0x11A3, returns to 0x11A4 // Incoming call from 0x1398, returns to 0x1399 // Incoming call from 0x0F21, returns to 0x0F22 // Incoming call from 0x0F45, returns to 0x0F46 // Incoming call from 0x1220, returns to 0x1221 // Incoming call from 0x0CB3, returns to 0x0CB4 // Incoming call from 0x1134, returns to 0x1135 // Incoming call from 0x1311, returns to 0x1312 // Incoming call from 0x0F67, returns to 0x0F68 // Incoming call from 0x0C3E, returns to 0x0C3F // Inputs[2] // { // @1299 storage[0x00] // @12A3 stack[-1] // } 1296 5B JUMPDEST 1297 60 PUSH1 0x00 1299 54 SLOAD 129A 60 PUSH1 0x01 129C 60 PUSH1 0x01 129E 60 PUSH1 0xa0 12A0 1B SHL 12A1 03 SUB 12A2 16 AND 12A3 90 SWAP1 12A4 56 *JUMP // Stack delta = +0 // Outputs[1] { @12A3 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to stack[-1] label_12A5: // Incoming call from 0x05FC, returns to 0x01B6 // Inputs[2] // { // @12A9 storage[0x02] // @12AD memory[0x40:0x60] // } 12A5 5B JUMPDEST 12A6 60 PUSH1 0x02 12A8 80 DUP1 12A9 54 SLOAD 12AA 60 PUSH1 0x40 12AC 80 DUP1 12AD 51 MLOAD 12AE 60 PUSH1 0x20 12B0 60 PUSH1 0x01 12B2 84 DUP5 12B3 16 AND 12B4 15 ISZERO 12B5 61 PUSH2 0x0100 12B8 02 MUL 12B9 60 PUSH1 0x00 12BB 19 NOT 12BC 01 ADD 12BD 90 SWAP1 12BE 93 SWAP4 12BF 16 AND 12C0 84 DUP5 12C1 90 SWAP1 12C2 04 DIV 12C3 60 PUSH1 0x1f 12C5 81 DUP2 12C6 01 ADD 12C7 84 DUP5 12C8 90 SWAP1 12C9 04 DIV 12CA 84 DUP5 12CB 02 MUL 12CC 82 DUP3 12CD 01 ADD 12CE 84 DUP5 12CF 01 ADD 12D0 90 SWAP1 12D1 92 SWAP3 12D2 52 MSTORE 12D3 81 DUP2 12D4 81 DUP2 12D5 52 MSTORE 12D6 92 SWAP3 12D7 91 SWAP2 12D8 83 DUP4 12D9 01 ADD 12DA 82 DUP3 12DB 82 DUP3 12DC 80 DUP1 12DD 15 ISZERO 12DE 61 PUSH2 0x07cb 12E1 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @12D1 stack[2] = (storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 // @12D2 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 + 0x1f) / 0x20) // @12D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 // @12D6 stack[0] = memory[0x40:0x60] // @12D7 stack[1] = 0x02 // @12D9 stack[3] = memory[0x40:0x60] + 0x20 // @12DA stack[4] = 0x02 // @12DB stack[5] = (storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x07cb, if !((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02) label_12E2: // Incoming jump from 0x12E1, if not !((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02) // Inputs[1] { @12E2 stack[-1] } 12E2 80 DUP1 12E3 60 PUSH1 0x1f 12E5 10 LT 12E6 61 PUSH2 0x07a0 12E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a0, if 0x1f < stack[-1] label_12EA: // Incoming jump from 0x12E9, if not 0x1f < stack[-1] // Inputs[4] // { // @12EE stack[-2] // @12EF storage[stack[-2]] // @12F2 stack[-3] // @12F4 stack[-1] // } 12EA 61 PUSH2 0x0100 12ED 80 DUP1 12EE 83 DUP4 12EF 54 SLOAD 12F0 04 DIV 12F1 02 MUL 12F2 83 DUP4 12F3 52 MSTORE 12F4 91 SWAP2 12F5 60 PUSH1 0x20 12F7 01 ADD 12F8 91 SWAP2 12F9 61 PUSH2 0x07cb 12FC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @12F3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @12F8 stack[-1] = stack[-1] // @12F8 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07cb label_12FD: // Incoming jump from 0x0635 // Inputs[3] // { // @1303 msg.sender // @1304 stack[-2] // @1305 stack[-1] // } 12FD 5B JUMPDEST 12FE 60 PUSH1 0x00 1300 61 PUSH2 0x07e0 1303 33 CALLER 1304 84 DUP5 1305 84 DUP5 1306 61 PUSH2 0x1503 1309 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @12FE stack[0] = 0x00 // @1300 stack[1] = 0x07e0 // @1303 stack[2] = msg.sender // @1304 stack[3] = stack[-2] // @1305 stack[4] = stack[-1] // } // Block ends with call to 0x1503, returns to 0x07E0 label_130A: // Incoming jump from 0x066E 130A 5B JUMPDEST 130B 61 PUSH2 0x1312 130E 61 PUSH2 0x1296 1311 56 *JUMP // Stack delta = +1 // Outputs[1] { @130B stack[0] = 0x1312 } // Block ends with call to 0x1296, returns to 0x1312 label_1312: // Incoming return from call to 0x1296 at 0x1311 // Inputs[2] // { // @131B stack[-1] // @131C tx.origin // } 1312 5B JUMPDEST 1313 60 PUSH1 0x01 1315 60 PUSH1 0x01 1317 60 PUSH1 0xa0 1319 1B SHL 131A 03 SUB 131B 16 AND 131C 32 ORIGIN 131D 60 PUSH1 0x01 131F 60 PUSH1 0x01 1321 60 PUSH1 0xa0 1323 1B SHL 1324 03 SUB 1325 16 AND 1326 14 EQ 1327 61 PUSH2 0x132f 132A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x132f, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] label_132B: // Incoming jump from 0x132A, if not (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @132E memory[0x00:0x00] } 132B 60 PUSH1 0x00 132D 80 DUP1 132E FD *REVERT // Stack delta = +0 // Outputs[1] { @132E revert(memory[0x00:0x00]); } // Block terminates label_132F: // Incoming jump from 0x132A, if (0x01 << 0xa0) - 0x01 & tx.origin == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[4] // { // @1338 stack[-1] // @1339 stack[-2] // @1348 memory[0x00:0x40] // @134A stack[-3] // } 132F 5B JUMPDEST 1330 60 PUSH1 0x01 1332 60 PUSH1 0x01 1334 60 PUSH1 0xa0 1336 1B SHL 1337 03 SUB 1338 90 SWAP1 1339 91 SWAP2 133A 16 AND 133B 60 PUSH1 0x00 133D 90 SWAP1 133E 81 DUP2 133F 52 MSTORE 1340 60 PUSH1 0x05 1342 60 PUSH1 0x20 1344 52 MSTORE 1345 60 PUSH1 0x40 1347 90 SWAP1 1348 20 SHA3 1349 55 SSTORE 134A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @133F memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1344 memory[0x20:0x40] = 0x05 // @1349 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_134B: // Incoming jump from 0x06A9 // Inputs[6] // { // @1355 stack[-2] // @135C memory[0x00:0x40] // @1360 stack[-1] // @1364 memory[0x00:0x40] // @1365 storage[keccak256(memory[0x00:0x40])] // @1366 stack[-3] // } 134B 5B JUMPDEST 134C 60 PUSH1 0x06 134E 60 PUSH1 0x20 1350 90 SWAP1 1351 81 DUP2 1352 52 MSTORE 1353 60 PUSH1 0x00 1355 92 SWAP3 1356 83 DUP4 1357 52 MSTORE 1358 60 PUSH1 0x40 135A 80 DUP1 135B 84 DUP5 135C 20 SHA3 135D 90 SWAP1 135E 91 SWAP2 135F 52 MSTORE 1360 90 SWAP1 1361 82 DUP3 1362 52 MSTORE 1363 90 SWAP1 1364 20 SHA3 1365 54 SLOAD 1366 81 DUP2 1367 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1352 memory[0x20:0x40] = 0x06 // @1357 memory[0x00:0x20] = stack[-2] // @135F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1362 memory[0x00:0x20] = stack[-1] // @1365 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1368: // Incoming jump from 0x06D3 // Inputs[2] // { // @136E stack[-1] // @136F msg.sender // } 1368 5B JUMPDEST 1369 60 PUSH1 0x00 136B 61 PUSH2 0x07e4 136E 82 DUP3 136F 33 CALLER 1370 61 PUSH2 0x1062 1373 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1369 stack[0] = 0x00 // @136B stack[1] = 0x07e4 // @136E stack[2] = stack[-1] // @136F stack[3] = msg.sender // } // Block ends with call to 0x1062, returns to 0x07E4 label_1374: // Incoming jump from 0x06FD // Inputs[2] // { // @137A stack[-1] // @137B msg.sender // } 1374 5B JUMPDEST 1375 60 PUSH1 0x00 1377 61 PUSH2 0x07e4 137A 82 DUP3 137B 33 CALLER 137C 61 PUSH2 0x098f 137F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1375 stack[0] = 0x00 // @1377 stack[1] = 0x07e4 // @137A stack[2] = stack[-1] // @137B stack[3] = msg.sender // } // Block ends with call to 0x098f, returns to 0x07E4 label_1380: // Incoming jump from 0x0730 1380 5B JUMPDEST 1381 61 PUSH2 0x1388 1384 61 PUSH2 0x1b0b 1387 56 *JUMP // Stack delta = +1 // Outputs[1] { @1381 stack[0] = 0x1388 } // Block ends with call to 0x1b0b, returns to 0x1388 label_1388: // Incoming return from call to 0x1B0B at 0x1387 // Inputs[1] { @1391 stack[-1] } 1388 5B JUMPDEST 1389 60 PUSH1 0x01 138B 60 PUSH1 0x01 138D 60 PUSH1 0xa0 138F 1B SHL 1390 03 SUB 1391 16 AND 1392 61 PUSH2 0x1399 1395 61 PUSH2 0x1296 1398 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1391 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1392 stack[0] = 0x1399 // } // Block ends with call to 0x1296, returns to 0x1399 label_1399: // Incoming return from call to 0x1296 at 0x1398 // Inputs[2] // { // @13A2 stack[-1] // @13A3 stack[-2] // } 1399 5B JUMPDEST 139A 60 PUSH1 0x01 139C 60 PUSH1 0x01 139E 60 PUSH1 0xa0 13A0 1B SHL 13A1 03 SUB 13A2 16 AND 13A3 14 EQ 13A4 61 PUSH2 0x13f4 13A7 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x13f4, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_13A8: // Incoming jump from 0x13A7, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @13AB memory[0x40:0x60] // @13EA memory[0x40:0x60] // @13F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 13A8 60 PUSH1 0x40 13AA 80 DUP1 13AB 51 MLOAD 13AC 62 PUSH3 0x461bcd 13B0 60 PUSH1 0xe5 13B2 1B SHL 13B3 81 DUP2 13B4 52 MSTORE 13B5 60 PUSH1 0x20 13B7 60 PUSH1 0x04 13B9 82 DUP3 13BA 01 ADD 13BB 81 DUP2 13BC 90 SWAP1 13BD 52 MSTORE 13BE 60 PUSH1 0x24 13C0 82 DUP3 13C1 01 ADD 13C2 52 MSTORE 13C3 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 13E4 60 PUSH1 0x44 13E6 82 DUP3 13E7 01 ADD 13E8 52 MSTORE 13E9 90 SWAP1 13EA 51 MLOAD 13EB 90 SWAP1 13EC 81 DUP2 13ED 90 SWAP1 13EE 03 SUB 13EF 60 PUSH1 0x64 13F1 01 ADD 13F2 90 SWAP1 13F3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13BD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13C2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @13E8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @13F3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_13F4: // Incoming jump from 0x13A7, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @13FD stack[-1] } 13F4 5B JUMPDEST 13F5 60 PUSH1 0x01 13F7 60 PUSH1 0x01 13F9 60 PUSH1 0xa0 13FB 1B SHL 13FC 03 SUB 13FD 81 DUP2 13FE 16 AND 13FF 61 PUSH2 0x1439 1402 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1439, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1403: // Incoming jump from 0x1402, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1405 memory[0x40:0x60] // @1433 memory[0x40:0x60] // @1438 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1403 60 PUSH1 0x40 1405 51 MLOAD 1406 62 PUSH3 0x461bcd 140A 60 PUSH1 0xe5 140C 1B SHL 140D 81 DUP2 140E 52 MSTORE 140F 60 PUSH1 0x04 1411 01 ADD 1412 80 DUP1 1413 80 DUP1 1414 60 PUSH1 0x20 1416 01 ADD 1417 82 DUP3 1418 81 DUP2 1419 03 SUB 141A 82 DUP3 141B 52 MSTORE 141C 60 PUSH1 0x26 141E 81 DUP2 141F 52 MSTORE 1420 60 PUSH1 0x20 1422 01 ADD 1423 80 DUP1 1424 61 PUSH2 0x1b60 1427 60 PUSH1 0x26 1429 91 SWAP2 142A 39 CODECOPY 142B 60 PUSH1 0x40 142D 01 ADD 142E 91 SWAP2 142F 50 POP 1430 50 POP 1431 60 PUSH1 0x40 1433 51 MLOAD 1434 80 DUP1 1435 91 SWAP2 1436 03 SUB 1437 90 SWAP1 1438 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @140E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @141B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @141F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @142A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x1b60:0x1b86] // @1438 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1439: // Incoming jump from 0x1402, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @143D stack[-1] } 1439 5B JUMPDEST 143A 61 PUSH2 0x0ca9 143D 81 DUP2 143E 61 PUSH2 0x1b0f 1441 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @143A stack[0] = 0x0ca9 // @143D stack[1] = stack[-1] // } // Block ends with call to 0x1b0f, returns to 0x0CA9 label_1442: // Incoming call from 0x0745, returns to 0x049D // Inputs[2] // { // @1445 storage[0x07] // @144F stack[-1] // } 1442 5B JUMPDEST 1443 60 PUSH1 0x07 1445 54 SLOAD 1446 60 PUSH1 0x01 1448 60 PUSH1 0x01 144A 60 PUSH1 0xa0 144C 1B SHL 144D 03 SUB 144E 16 AND 144F 81 DUP2 1450 56 *JUMP // Stack delta = +1 // Outputs[1] { @144E stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with unconditional jump to stack[-1] label_1451: // Incoming call from 0x07DF, returns to 0x07E0 // Inputs[9] // { // @145B stack[-3] // @146D memory[0x00:0x40] // @146F stack[-2] // @147A memory[0x00:0x40] // @147B stack[-1] // @147F memory[0x40:0x60] // @1484 memory[0x40:0x60] // @14AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @14B2 stack[-4] // } 1451 5B JUMPDEST 1452 60 PUSH1 0x01 1454 60 PUSH1 0x01 1456 60 PUSH1 0xa0 1458 1B SHL 1459 03 SUB 145A 80 DUP1 145B 84 DUP5 145C 16 AND 145D 60 PUSH1 0x00 145F 81 DUP2 1460 81 DUP2 1461 52 MSTORE 1462 60 PUSH1 0x06 1464 60 PUSH1 0x20 1466 90 SWAP1 1467 81 DUP2 1468 52 MSTORE 1469 60 PUSH1 0x40 146B 80 DUP1 146C 83 DUP4 146D 20 SHA3 146E 94 SWAP5 146F 87 DUP8 1470 16 AND 1471 80 DUP1 1472 84 DUP5 1473 52 MSTORE 1474 94 SWAP5 1475 82 DUP3 1476 52 MSTORE 1477 91 SWAP2 1478 82 DUP3 1479 90 SWAP1 147A 20 SHA3 147B 85 DUP6 147C 90 SWAP1 147D 55 SSTORE 147E 81 DUP2 147F 51 MLOAD 1480 85 DUP6 1481 81 DUP2 1482 52 MSTORE 1483 91 SWAP2 1484 51 MLOAD 1485 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 14A6 92 SWAP3 14A7 81 DUP2 14A8 90 SWAP1 14A9 03 SUB 14AA 90 SWAP1 14AB 91 SWAP2 14AC 01 ADD 14AD 90 SWAP1 14AE A3 LOG3 14AF 50 POP 14B0 50 POP 14B1 50 POP 14B2 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @1461 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1468 memory[0x20:0x40] = 0x06 // @1473 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1476 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @147D storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1482 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @14AE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] label_14B3: // Incoming call from 0x0954, returns to 0x0955 // Incoming call from 0x0D6F, returns to 0x0D70 // Incoming call from 0x1AB3, returns to 0x1AB4 // Incoming call from 0x152B, returns to 0x152C // Inputs[2] // { // @14B4 stack[-1] // @14B5 stack[-2] // } 14B3 5B JUMPDEST 14B4 80 DUP1 14B5 82 DUP3 14B6 03 SUB 14B7 82 DUP3 14B8 81 DUP2 14B9 11 GT 14BA 15 ISZERO 14BB 61 PUSH2 0x07e4 14BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14B6 stack[0] = stack[-2] - stack[-1] } // Block ends with conditional jump to 0x07e4, if !(stack[-2] - stack[-1] > stack[-2]) label_14BF: // Incoming jump from 0x14BE, if not !(stack[-2] - stack[-1] > stack[-2]) // Inputs[3] // { // @14C2 memory[0x40:0x60] // @14F9 memory[0x40:0x60] // @1502 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 14BF 60 PUSH1 0x40 14C1 80 DUP1 14C2 51 MLOAD 14C3 62 PUSH3 0x461bcd 14C7 60 PUSH1 0xe5 14C9 1B SHL 14CA 81 DUP2 14CB 52 MSTORE 14CC 60 PUSH1 0x20 14CE 60 PUSH1 0x04 14D0 82 DUP3 14D1 01 ADD 14D2 52 MSTORE 14D3 60 PUSH1 0x15 14D5 60 PUSH1 0x24 14D7 82 DUP3 14D8 01 ADD 14D9 52 MSTORE 14DA 74 PUSH21 0x64732d6d6174682d7375622d756e646572666c6f77 14F0 60 PUSH1 0x58 14F2 1B SHL 14F3 60 PUSH1 0x44 14F5 82 DUP3 14F6 01 ADD 14F7 52 MSTORE 14F8 90 SWAP1 14F9 51 MLOAD 14FA 90 SWAP1 14FB 81 DUP2 14FC 90 SWAP1 14FD 03 SUB 14FE 60 PUSH1 0x64 1500 01 ADD 1501 90 SWAP1 1502 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @14CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14D2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14D9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @14F7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d7375622d756e646572666c6f77 << 0x58 // @1502 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1503: // Incoming call from 0x1309, returns to 0x07E0 // Incoming call from 0x0984, returns to 0x0985 // Inputs[4] // { // @150C stack[-3] // @151B memory[0x00:0x40] // @151C storage[keccak256(memory[0x00:0x40])] // @1521 stack[-1] // } 1503 5B JUMPDEST 1504 60 PUSH1 0x01 1506 60 PUSH1 0x01 1508 60 PUSH1 0xa0 150A 1B SHL 150B 03 SUB 150C 83 DUP4 150D 16 AND 150E 60 PUSH1 0x00 1510 90 SWAP1 1511 81 DUP2 1512 52 MSTORE 1513 60 PUSH1 0x05 1515 60 PUSH1 0x20 1517 52 MSTORE 1518 60 PUSH1 0x40 151A 90 SWAP1 151B 20 SHA3 151C 54 SLOAD 151D 61 PUSH2 0x152c 1520 90 SWAP1 1521 82 DUP3 1522 63 PUSH4 0xffffffff 1527 61 PUSH2 0x14b3 152A 16 AND 152B 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1512 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1517 memory[0x20:0x40] = 0x05 // @1520 stack[0] = 0x152c // @1520 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1521 stack[2] = stack[-1] // } // Block ends with call to 0x14b3 & 0xffffffff, returns to 0x152C label_152C: // Incoming return from call to 0x14B3 at 0x152B // Inputs[7] // { // @1536 stack[-4] // @1546 memory[0x00:0x40] // @1547 stack[-1] // @154C stack[-3] // @1550 memory[0x00:0x40] // @1551 storage[keccak256(memory[0x00:0x40])] // @1556 stack[-2] // } 152C 5B JUMPDEST 152D 60 PUSH1 0x01 152F 60 PUSH1 0x01 1531 60 PUSH1 0xa0 1533 1B SHL 1534 03 SUB 1535 80 DUP1 1536 85 DUP6 1537 16 AND 1538 60 PUSH1 0x00 153A 90 SWAP1 153B 81 DUP2 153C 52 MSTORE 153D 60 PUSH1 0x05 153F 60 PUSH1 0x20 1541 52 MSTORE 1542 60 PUSH1 0x40 1544 80 DUP1 1545 82 DUP3 1546 20 SHA3 1547 93 SWAP4 1548 90 SWAP1 1549 93 SWAP4 154A 55 SSTORE 154B 90 SWAP1 154C 84 DUP5 154D 16 AND 154E 81 DUP2 154F 52 MSTORE 1550 20 SHA3 1551 54 SLOAD 1552 61 PUSH2 0x1561 1555 90 SWAP1 1556 82 DUP3 1557 63 PUSH4 0xffffffff 155C 61 PUSH2 0x18ef 155F 16 AND 1560 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @153C memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1541 memory[0x20:0x40] = 0x05 // @154A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @154F memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1555 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1555 stack[-1] = 0x1561 // @1556 stack[1] = stack[-2] // } // Block ends with call to 0x18ef & 0xffffffff, returns to 0x1561 label_1561: // Incoming return from call to 0x18EF at 0x1560 // Inputs[9] // { // @156B stack[-3] // @157E memory[0x00:0x40] // @157F stack[-1] // @1584 memory[0x40:0x60] // @1585 stack[-2] // @1589 memory[0x40:0x60] // @158D stack[-4] // @15B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20] // @15BC stack[-5] // } 1561 5B JUMPDEST 1562 60 PUSH1 0x01 1564 60 PUSH1 0x01 1566 60 PUSH1 0xa0 1568 1B SHL 1569 03 SUB 156A 80 DUP1 156B 84 DUP5 156C 16 AND 156D 60 PUSH1 0x00 156F 81 DUP2 1570 81 DUP2 1571 52 MSTORE 1572 60 PUSH1 0x05 1574 60 PUSH1 0x20 1576 90 SWAP1 1577 81 DUP2 1578 52 MSTORE 1579 60 PUSH1 0x40 157B 91 SWAP2 157C 82 DUP3 157D 90 SWAP1 157E 20 SHA3 157F 94 SWAP5 1580 90 SWAP1 1581 94 SWAP5 1582 55 SSTORE 1583 80 DUP1 1584 51 MLOAD 1585 85 DUP6 1586 81 DUP2 1587 52 MSTORE 1588 90 SWAP1 1589 51 MLOAD 158A 91 SWAP2 158B 93 SWAP4 158C 92 SWAP3 158D 87 DUP8 158E 16 AND 158F 92 SWAP3 1590 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 15B1 92 SWAP3 15B2 91 SWAP2 15B3 82 DUP3 15B4 90 SWAP1 15B5 03 SUB 15B6 01 ADD 15B7 90 SWAP1 15B8 A3 LOG3 15B9 50 POP 15BA 50 POP 15BB 50 POP 15BC 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1571 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1578 memory[0x20:0x40] = 0x05 // @1582 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1587 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @15B8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-5] label_15BD: // Incoming call from 0x0BBF, returns to 0x0BC0 // Incoming call from 0x0BDC, returns to 0x0BDD // Incoming jump from 0x0F27 // Incoming jump from 0x0F4B // Inputs[9] // { // @15C1 memory[0x40:0x60] // @15CA stack[-3] // @15D2 stack[-2] // @15DF stack[-1] // @15E3 memory[0x40:0x60] // @15F8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @160E memory[0x40:0x60] // @1610 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1618 stack[-4] // } 15BD 5B JUMPDEST 15BE 60 PUSH1 0x40 15C0 80 DUP1 15C1 51 MLOAD 15C2 60 PUSH1 0x01 15C4 60 PUSH1 0x01 15C6 60 PUSH1 0xa0 15C8 1B SHL 15C9 03 SUB 15CA 85 DUP6 15CB 81 DUP2 15CC 16 AND 15CD 60 PUSH1 0x24 15CF 83 DUP4 15D0 01 ADD 15D1 52 MSTORE 15D2 84 DUP5 15D3 81 DUP2 15D4 16 AND 15D5 60 PUSH1 0x44 15D7 83 DUP4 15D8 01 ADD 15D9 52 MSTORE 15DA 60 PUSH1 0x64 15DC 80 DUP1 15DD 83 DUP4 15DE 01 ADD 15DF 85 DUP6 15E0 90 SWAP1 15E1 52 MSTORE 15E2 83 DUP4 15E3 51 MLOAD 15E4 80 DUP1 15E5 84 DUP5 15E6 03 SUB 15E7 90 SWAP1 15E8 91 SWAP2 15E9 01 ADD 15EA 81 DUP2 15EB 52 MSTORE 15EC 60 PUSH1 0x84 15EE 90 SWAP1 15EF 92 SWAP3 15F0 01 ADD 15F1 83 DUP4 15F2 52 MSTORE 15F3 60 PUSH1 0x20 15F5 82 DUP3 15F6 01 ADD 15F7 80 DUP1 15F8 51 MLOAD 15F9 60 PUSH1 0x01 15FB 60 PUSH1 0x01 15FD 60 PUSH1 0xe0 15FF 1B SHL 1600 03 SUB 1601 16 AND 1602 63 PUSH4 0x23b872dd 1607 60 PUSH1 0xe0 1609 1B SHL 160A 17 OR 160B 81 DUP2 160C 52 MSTORE 160D 92 SWAP3 160E 51 MLOAD 160F 82 DUP3 1610 51 MLOAD 1611 60 PUSH1 0x00 1613 94 SWAP5 1614 60 PUSH1 0x60 1616 94 SWAP5 1617 93 SWAP4 1618 8A DUP11 1619 16 AND 161A 93 SWAP4 161B 92 SWAP3 161C 91 SWAP2 161D 82 DUP3 161E 91 SWAP2 161F 90 SWAP1 1620 80 DUP1 1621 83 DUP4 1622 83 DUP4 1623 5B JUMPDEST 1624 60 PUSH1 0x20 1626 83 DUP4 1627 10 LT 1628 61 PUSH2 0x1642 162B 57 *JUMPI // Stack delta = +11 // Outputs[17] // { // @15D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @15D9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @15E1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-1] // @15EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x64 + (memory[0x40:0x60] - memory[0x40:0x60]) // @15F2 memory[0x40:0x60] = memory[0x40:0x60] + 0x84 // @160C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x23b872dd << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @1613 stack[0] = 0x00 // @1616 stack[1] = 0x60 // @161A stack[2] = stack[-4] & (0x01 << 0xa0) - 0x01 // @161B stack[3] = memory[0x40:0x60] // @161C stack[4] = memory[0x40:0x60] // @161E stack[5] = memory[0x40:0x60] // @161F stack[6] = memory[0x40:0x60] + 0x20 // @161F stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1620 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1621 stack[9] = memory[0x40:0x60] // @1622 stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x1642, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_162C: // Incoming jump from 0x162B, if not stack[-3] < 0x20 // Incoming jump from 0x162B, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @162C stack[-1] // @162D memory[stack[-1]:stack[-1] + 0x20] // @162E stack[-2] // @1634 stack[-3] // } 162C 80 DUP1 162D 51 MLOAD 162E 82 DUP3 162F 52 MSTORE 1630 60 PUSH1 0x1f 1632 19 NOT 1633 90 SWAP1 1634 92 SWAP3 1635 01 ADD 1636 91 SWAP2 1637 60 PUSH1 0x20 1639 91 SWAP2 163A 82 DUP3 163B 01 ADD 163C 91 SWAP2 163D 01 ADD 163E 61 PUSH2 0x1623 1641 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @162F memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1636 stack[-3] = stack[-3] + ~0x1f // @163C stack[-2] = 0x20 + stack[-2] // @163D stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1623 label_1642: // Incoming jump from 0x162B, if stack[-3] < 0x20 // Incoming jump from 0x162B, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[15] // { // @1645 stack[-3] // @1650 stack[-1] // @1651 memory[stack[-1]:stack[-1] + 0x20] // @1654 stack[-2] // @1655 memory[stack[-2]:stack[-2] + 0x20] // @1662 stack[-5] // @1662 stack[-4] // @1664 stack[-6] // @1665 stack[-8] // @166C memory[0x40:0x60] // @1673 stack[-9] // @1674 msg.gas // @1675 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @1675 address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1679 returndata.length // } 1642 5B JUMPDEST 1643 60 PUSH1 0x01 1645 83 DUP4 1646 60 PUSH1 0x20 1648 03 SUB 1649 61 PUSH2 0x0100 164C 0A EXP 164D 03 SUB 164E 80 DUP1 164F 19 NOT 1650 82 DUP3 1651 51 MLOAD 1652 16 AND 1653 81 DUP2 1654 84 DUP5 1655 51 MLOAD 1656 16 AND 1657 80 DUP1 1658 82 DUP3 1659 17 OR 165A 85 DUP6 165B 52 MSTORE 165C 50 POP 165D 50 POP 165E 50 POP 165F 50 POP 1660 50 POP 1661 50 POP 1662 90 SWAP1 1663 50 POP 1664 01 ADD 1665 91 SWAP2 1666 50 POP 1667 50 POP 1668 60 PUSH1 0x00 166A 60 PUSH1 0x40 166C 51 MLOAD 166D 80 DUP1 166E 83 DUP4 166F 03 SUB 1670 81 DUP2 1671 60 PUSH1 0x00 1673 86 DUP7 1674 5A GAS 1675 F1 CALL 1676 91 SWAP2 1677 50 POP 1678 50 POP 1679 3D RETURNDATASIZE 167A 80 DUP1 167B 60 PUSH1 0x00 167D 81 DUP2 167E 14 EQ 167F 61 PUSH2 0x16a4 1682 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @165B memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1675 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1676 stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1679 stack[-8] = returndata.length // @167A stack[-7] = returndata.length // } // Block ends with conditional jump to 0x16a4, if returndata.length == 0x00 label_1683: // Incoming jump from 0x1682, if not returndata.length == 0x00 // Inputs[6] // { // @1685 memory[0x40:0x60] // @1686 stack[-2] // @168D returndata.length // @1695 returndata.length // @1698 returndata.length // @169F returndata[0x00:0x00 + returndata.length] // } 1683 60 PUSH1 0x40 1685 51 MLOAD 1686 91 SWAP2 1687 50 POP 1688 60 PUSH1 0x1f 168A 19 NOT 168B 60 PUSH1 0x3f 168D 3D RETURNDATASIZE 168E 01 ADD 168F 16 AND 1690 82 DUP3 1691 01 ADD 1692 60 PUSH1 0x40 1694 52 MSTORE 1695 3D RETURNDATASIZE 1696 82 DUP3 1697 52 MSTORE 1698 3D RETURNDATASIZE 1699 60 PUSH1 0x00 169B 60 PUSH1 0x20 169D 84 DUP5 169E 01 ADD 169F 3E RETURNDATACOPY 16A0 61 PUSH2 0x16a9 16A3 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1686 stack[-2] = memory[0x40:0x60] // @1694 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1697 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @169F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x16a9 label_16A4: // Incoming jump from 0x1682, if returndata.length == 0x00 // Inputs[4] // { // @16A7 stack[-2] // @16AB stack[-4] // @16AD stack[-3] // @16AD stack[-5] // } 16A4 5B JUMPDEST 16A5 60 PUSH1 0x60 16A7 91 SWAP2 16A8 50 POP 16A9 5B JUMPDEST 16AA 50 POP 16AB 91 SWAP2 16AC 50 POP 16AD 91 SWAP2 16AE 50 POP 16AF 81 DUP2 16B0 80 DUP1 16B1 15 ISZERO 16B2 61 PUSH2 0x16d7 16B5 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @16AB stack[-4] = 0x60 // @16AD stack[-5] = stack[-3] // @16AF stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x16d7, if !stack[-3] label_16B6: // Incoming jump from 0x16B5, if not !stack[-3] // Incoming jump from 0x16B5, if not !stack[-3] // Inputs[2] // { // @16B7 stack[-2] // @16B8 memory[stack[-2]:stack[-2] + 0x20] // } 16B6 50 POP 16B7 80 DUP1 16B8 51 MLOAD 16B9 15 ISZERO 16BA 80 DUP1 16BB 61 PUSH2 0x16d7 16BE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @16B9 stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x16d7, if !memory[stack[-2]:stack[-2] + 0x20] label_16BF: // Incoming jump from 0x16BE, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @16C0 stack[-2] // @16C6 memory[stack[-2]:stack[-2] + 0x20] // } 16BF 50 POP 16C0 80 DUP1 16C1 80 DUP1 16C2 60 PUSH1 0x20 16C4 01 ADD 16C5 90 SWAP1 16C6 51 MLOAD 16C7 60 PUSH1 0x20 16C9 81 DUP2 16CA 10 LT 16CB 15 ISZERO 16CC 61 PUSH2 0x16d4 16CF 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @16C5 stack[-1] = 0x20 + stack[-2] // @16C6 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x16d4, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_16D0: // Incoming jump from 0x16CF, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @16D3 memory[0x00:0x00] } 16D0 60 PUSH1 0x00 16D2 80 DUP1 16D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @16D3 revert(memory[0x00:0x00]); } // Block terminates label_16D4: // Incoming jump from 0x16CF, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @16D6 stack[-2] // @16D6 memory[stack[-2]:stack[-2] + 0x20] // } 16D4 5B JUMPDEST 16D5 50 POP 16D6 51 MLOAD // Stack delta = -1 // Outputs[1] { @16D6 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_16D7: // Incoming jump from 0x16B5, if !stack[-3] // Incoming jump from 0x16BE, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x16B5, if !stack[-3] // Incoming jump from 0x16D6 // Inputs[1] { @16DB stack[-1] } 16D7 5B JUMPDEST 16D8 61 PUSH2 0x1712 16DB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1712, if stack[-1] label_16DC: // Incoming jump from 0x16DB, if not stack[-1] // Inputs[3] // { // @16DE memory[0x40:0x60] // @170C memory[0x40:0x60] // @1711 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16DC 60 PUSH1 0x40 16DE 51 MLOAD 16DF 62 PUSH3 0x461bcd 16E3 60 PUSH1 0xe5 16E5 1B SHL 16E6 81 DUP2 16E7 52 MSTORE 16E8 60 PUSH1 0x04 16EA 01 ADD 16EB 80 DUP1 16EC 80 DUP1 16ED 60 PUSH1 0x20 16EF 01 ADD 16F0 82 DUP3 16F1 81 DUP2 16F2 03 SUB 16F3 82 DUP3 16F4 52 MSTORE 16F5 60 PUSH1 0x31 16F7 81 DUP2 16F8 52 MSTORE 16F9 60 PUSH1 0x20 16FB 01 ADD 16FC 80 DUP1 16FD 61 PUSH2 0x1b86 1700 60 PUSH1 0x31 1702 91 SWAP2 1703 39 CODECOPY 1704 60 PUSH1 0x40 1706 01 ADD 1707 91 SWAP2 1708 50 POP 1709 50 POP 170A 60 PUSH1 0x40 170C 51 MLOAD 170D 80 DUP1 170E 91 SWAP2 170F 03 SUB 1710 90 SWAP1 1711 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @16E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16F4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @16F8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @1703 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x1b86:0x1bb7] // @1711 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1712: // Incoming jump from 0x16DB, if stack[-1] // Inputs[1] { @1719 stack[-7] } 1712 5B JUMPDEST 1713 50 POP 1714 50 POP 1715 50 POP 1716 50 POP 1717 50 POP 1718 50 POP 1719 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_171A: // Incoming call from 0x0BE6, returns to 0x0BE7 // Inputs[4] // { // @1723 stack[-2] // @1732 memory[0x00:0x40] // @1733 storage[keccak256(memory[0x00:0x40])] // @1738 stack[-1] // } 171A 5B JUMPDEST 171B 60 PUSH1 0x01 171D 60 PUSH1 0x01 171F 60 PUSH1 0xa0 1721 1B SHL 1722 03 SUB 1723 82 DUP3 1724 16 AND 1725 60 PUSH1 0x00 1727 90 SWAP1 1728 81 DUP2 1729 52 MSTORE 172A 60 PUSH1 0x05 172C 60 PUSH1 0x20 172E 52 MSTORE 172F 60 PUSH1 0x40 1731 90 SWAP1 1732 20 SHA3 1733 54 SLOAD 1734 61 PUSH2 0x1743 1737 90 SWAP1 1738 82 DUP3 1739 63 PUSH4 0xffffffff 173E 61 PUSH2 0x18ef 1741 16 AND 1742 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1729 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @172E memory[0x20:0x40] = 0x05 // @1737 stack[0] = 0x1743 // @1737 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1738 stack[2] = stack[-1] // } // Block ends with call to 0x18ef & 0xffffffff, returns to 0x1743 label_1743: // Incoming return from call to 0x18EF at 0x1742 // Inputs[8] // { // @174C stack[-3] // @175E memory[0x00:0x40] // @175F stack[-1] // @1764 memory[0x40:0x60] // @1765 stack[-2] // @1769 memory[0x40:0x60] // @1797 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @179A stack[-4] // } 1743 5B JUMPDEST 1744 60 PUSH1 0x01 1746 60 PUSH1 0x01 1748 60 PUSH1 0xa0 174A 1B SHL 174B 03 SUB 174C 83 DUP4 174D 16 AND 174E 60 PUSH1 0x00 1750 81 DUP2 1751 81 DUP2 1752 52 MSTORE 1753 60 PUSH1 0x05 1755 60 PUSH1 0x20 1757 90 SWAP1 1758 81 DUP2 1759 52 MSTORE 175A 60 PUSH1 0x40 175C 80 DUP1 175D 83 DUP4 175E 20 SHA3 175F 94 SWAP5 1760 90 SWAP1 1761 94 SWAP5 1762 55 SSTORE 1763 83 DUP4 1764 51 MLOAD 1765 85 DUP6 1766 81 DUP2 1767 52 MSTORE 1768 93 SWAP4 1769 51 MLOAD 176A 92 SWAP3 176B 93 SWAP4 176C 91 SWAP2 176D 92 SWAP3 176E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 178F 92 SWAP3 1790 81 DUP2 1791 90 SWAP1 1792 03 SUB 1793 90 SWAP1 1794 91 SWAP2 1795 01 ADD 1796 90 SWAP1 1797 A3 LOG3 1798 50 POP 1799 50 POP 179A 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @1752 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1759 memory[0x20:0x40] = 0x05 // @1762 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1767 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1797 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] label_179B: // Incoming call from 0x0CA8, returns to 0x0CA9 // Incoming call from 0x10C2, returns to 0x10C3 // Inputs[8] // { // @179F memory[0x40:0x60] // @17A8 stack[-2] // @17B5 stack[-1] // @17B9 memory[0x40:0x60] // @17CE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @17E4 memory[0x40:0x60] // @17E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @17EE stack[-3] // } 179B 5B JUMPDEST 179C 60 PUSH1 0x40 179E 80 DUP1 179F 51 MLOAD 17A0 60 PUSH1 0x01 17A2 60 PUSH1 0x01 17A4 60 PUSH1 0xa0 17A6 1B SHL 17A7 03 SUB 17A8 84 DUP5 17A9 81 DUP2 17AA 16 AND 17AB 60 PUSH1 0x24 17AD 83 DUP4 17AE 01 ADD 17AF 52 MSTORE 17B0 60 PUSH1 0x44 17B2 80 DUP1 17B3 83 DUP4 17B4 01 ADD 17B5 85 DUP6 17B6 90 SWAP1 17B7 52 MSTORE 17B8 83 DUP4 17B9 51 MLOAD 17BA 80 DUP1 17BB 84 DUP5 17BC 03 SUB 17BD 90 SWAP1 17BE 91 SWAP2 17BF 01 ADD 17C0 81 DUP2 17C1 52 MSTORE 17C2 60 PUSH1 0x64 17C4 90 SWAP1 17C5 92 SWAP3 17C6 01 ADD 17C7 83 DUP4 17C8 52 MSTORE 17C9 60 PUSH1 0x20 17CB 82 DUP3 17CC 01 ADD 17CD 80 DUP1 17CE 51 MLOAD 17CF 60 PUSH1 0x01 17D1 60 PUSH1 0x01 17D3 60 PUSH1 0xe0 17D5 1B SHL 17D6 03 SUB 17D7 16 AND 17D8 63 PUSH4 0xa9059cbb 17DD 60 PUSH1 0xe0 17DF 1B SHL 17E0 17 OR 17E1 81 DUP2 17E2 52 MSTORE 17E3 92 SWAP3 17E4 51 MLOAD 17E5 82 DUP3 17E6 51 MLOAD 17E7 60 PUSH1 0x00 17E9 94 SWAP5 17EA 60 PUSH1 0x60 17EC 94 SWAP5 17ED 93 SWAP4 17EE 89 DUP10 17EF 16 AND 17F0 93 SWAP4 17F1 92 SWAP3 17F2 91 SWAP2 17F3 82 DUP3 17F4 91 SWAP2 17F5 90 SWAP1 17F6 80 DUP1 17F7 83 DUP4 17F8 83 DUP4 17F9 5B JUMPDEST 17FA 60 PUSH1 0x20 17FC 83 DUP4 17FD 10 LT 17FE 61 PUSH2 0x1818 1801 57 *JUMPI // Stack delta = +11 // Outputs[16] // { // @17AF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @17B7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @17C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x44 + (memory[0x40:0x60] - memory[0x40:0x60]) // @17C8 memory[0x40:0x60] = memory[0x40:0x60] + 0x64 // @17E2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0xa9059cbb << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @17E9 stack[0] = 0x00 // @17EC stack[1] = 0x60 // @17F0 stack[2] = stack[-3] & (0x01 << 0xa0) - 0x01 // @17F1 stack[3] = memory[0x40:0x60] // @17F2 stack[4] = memory[0x40:0x60] // @17F4 stack[5] = memory[0x40:0x60] // @17F5 stack[6] = memory[0x40:0x60] + 0x20 // @17F5 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @17F6 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @17F7 stack[9] = memory[0x40:0x60] // @17F8 stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x1818, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1802: // Incoming jump from 0x1801, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Incoming jump from 0x1801, if not stack[-3] < 0x20 // Inputs[4] // { // @1802 stack[-1] // @1803 memory[stack[-1]:stack[-1] + 0x20] // @1804 stack[-2] // @180A stack[-3] // } 1802 80 DUP1 1803 51 MLOAD 1804 82 DUP3 1805 52 MSTORE 1806 60 PUSH1 0x1f 1808 19 NOT 1809 90 SWAP1 180A 92 SWAP3 180B 01 ADD 180C 91 SWAP2 180D 60 PUSH1 0x20 180F 91 SWAP2 1810 82 DUP3 1811 01 ADD 1812 91 SWAP2 1813 01 ADD 1814 61 PUSH2 0x17f9 1817 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1805 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @180C stack[-3] = stack[-3] + ~0x1f // @1812 stack[-2] = 0x20 + stack[-2] // @1813 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x17f9 label_1818: // Incoming jump from 0x1801, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Incoming jump from 0x1801, if stack[-3] < 0x20 // Inputs[15] // { // @181B stack[-3] // @1826 stack[-1] // @1827 memory[stack[-1]:stack[-1] + 0x20] // @182A stack[-2] // @182B memory[stack[-2]:stack[-2] + 0x20] // @1838 stack[-4] // @1838 stack[-5] // @183A stack[-6] // @183B stack[-8] // @1842 memory[0x40:0x60] // @1849 stack[-9] // @184A msg.gas // @184B address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @184B memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @184F returndata.length // } 1818 5B JUMPDEST 1819 60 PUSH1 0x01 181B 83 DUP4 181C 60 PUSH1 0x20 181E 03 SUB 181F 61 PUSH2 0x0100 1822 0A EXP 1823 03 SUB 1824 80 DUP1 1825 19 NOT 1826 82 DUP3 1827 51 MLOAD 1828 16 AND 1829 81 DUP2 182A 84 DUP5 182B 51 MLOAD 182C 16 AND 182D 80 DUP1 182E 82 DUP3 182F 17 OR 1830 85 DUP6 1831 52 MSTORE 1832 50 POP 1833 50 POP 1834 50 POP 1835 50 POP 1836 50 POP 1837 50 POP 1838 90 SWAP1 1839 50 POP 183A 01 ADD 183B 91 SWAP2 183C 50 POP 183D 50 POP 183E 60 PUSH1 0x00 1840 60 PUSH1 0x40 1842 51 MLOAD 1843 80 DUP1 1844 83 DUP4 1845 03 SUB 1846 81 DUP2 1847 60 PUSH1 0x00 1849 86 DUP7 184A 5A GAS 184B F1 CALL 184C 91 SWAP2 184D 50 POP 184E 50 POP 184F 3D RETURNDATASIZE 1850 80 DUP1 1851 60 PUSH1 0x00 1853 81 DUP2 1854 14 EQ 1855 61 PUSH2 0x187a 1858 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @1831 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @184B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @184C stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @184F stack[-8] = returndata.length // @1850 stack[-7] = returndata.length // } // Block ends with conditional jump to 0x187a, if returndata.length == 0x00 label_1859: // Incoming jump from 0x1858, if not returndata.length == 0x00 // Inputs[6] // { // @185B memory[0x40:0x60] // @185C stack[-2] // @1863 returndata.length // @186B returndata.length // @186E returndata.length // @1875 returndata[0x00:0x00 + returndata.length] // } 1859 60 PUSH1 0x40 185B 51 MLOAD 185C 91 SWAP2 185D 50 POP 185E 60 PUSH1 0x1f 1860 19 NOT 1861 60 PUSH1 0x3f 1863 3D RETURNDATASIZE 1864 01 ADD 1865 16 AND 1866 82 DUP3 1867 01 ADD 1868 60 PUSH1 0x40 186A 52 MSTORE 186B 3D RETURNDATASIZE 186C 82 DUP3 186D 52 MSTORE 186E 3D RETURNDATASIZE 186F 60 PUSH1 0x00 1871 60 PUSH1 0x20 1873 84 DUP5 1874 01 ADD 1875 3E RETURNDATACOPY 1876 61 PUSH2 0x187f 1879 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @185C stack[-2] = memory[0x40:0x60] // @186A memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @186D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1875 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x187f label_187A: // Incoming jump from 0x1858, if returndata.length == 0x00 // Inputs[4] // { // @187D stack[-2] // @1881 stack[-4] // @1883 stack[-5] // @1883 stack[-3] // } 187A 5B JUMPDEST 187B 60 PUSH1 0x60 187D 91 SWAP2 187E 50 POP 187F 5B JUMPDEST 1880 50 POP 1881 91 SWAP2 1882 50 POP 1883 91 SWAP2 1884 50 POP 1885 81 DUP2 1886 80 DUP1 1887 15 ISZERO 1888 61 PUSH2 0x18ad 188B 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @1881 stack[-4] = 0x60 // @1883 stack[-5] = stack[-3] // @1885 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x18ad, if !stack[-3] label_188C: // Incoming jump from 0x188B, if not !stack[-3] // Incoming jump from 0x188B, if not !stack[-3] // Inputs[2] // { // @188D stack[-2] // @188E memory[stack[-2]:stack[-2] + 0x20] // } 188C 50 POP 188D 80 DUP1 188E 51 MLOAD 188F 15 ISZERO 1890 80 DUP1 1891 61 PUSH2 0x18ad 1894 57 *JUMPI // Stack delta = +0 // Outputs[1] { @188F stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x18ad, if !memory[stack[-2]:stack[-2] + 0x20] label_1895: // Incoming jump from 0x1894, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @1896 stack[-2] // @189C memory[stack[-2]:stack[-2] + 0x20] // } 1895 50 POP 1896 80 DUP1 1897 80 DUP1 1898 60 PUSH1 0x20 189A 01 ADD 189B 90 SWAP1 189C 51 MLOAD 189D 60 PUSH1 0x20 189F 81 DUP2 18A0 10 LT 18A1 15 ISZERO 18A2 61 PUSH2 0x18aa 18A5 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @189B stack[-1] = 0x20 + stack[-2] // @189C stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x18aa, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_18A6: // Incoming jump from 0x18A5, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @18A9 memory[0x00:0x00] } 18A6 60 PUSH1 0x00 18A8 80 DUP1 18A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @18A9 revert(memory[0x00:0x00]); } // Block terminates label_18AA: // Incoming jump from 0x18A5, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @18AC stack[-2] // @18AC memory[stack[-2]:stack[-2] + 0x20] // } 18AA 5B JUMPDEST 18AB 50 POP 18AC 51 MLOAD // Stack delta = -1 // Outputs[1] { @18AC stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_18AD: // Incoming jump from 0x188B, if !stack[-3] // Incoming jump from 0x18AC // Incoming jump from 0x1894, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x188B, if !stack[-3] // Inputs[1] { @18B1 stack[-1] } 18AD 5B JUMPDEST 18AE 61 PUSH2 0x18e8 18B1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18e8, if stack[-1] label_18B2: // Incoming jump from 0x18B1, if not stack[-1] // Inputs[3] // { // @18B4 memory[0x40:0x60] // @18E2 memory[0x40:0x60] // @18E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 18B2 60 PUSH1 0x40 18B4 51 MLOAD 18B5 62 PUSH3 0x461bcd 18B9 60 PUSH1 0xe5 18BB 1B SHL 18BC 81 DUP2 18BD 52 MSTORE 18BE 60 PUSH1 0x04 18C0 01 ADD 18C1 80 DUP1 18C2 80 DUP1 18C3 60 PUSH1 0x20 18C5 01 ADD 18C6 82 DUP3 18C7 81 DUP2 18C8 03 SUB 18C9 82 DUP3 18CA 52 MSTORE 18CB 60 PUSH1 0x2d 18CD 81 DUP2 18CE 52 MSTORE 18CF 60 PUSH1 0x20 18D1 01 ADD 18D2 80 DUP1 18D3 61 PUSH2 0x1c25 18D6 60 PUSH1 0x2d 18D8 91 SWAP2 18D9 39 CODECOPY 18DA 60 PUSH1 0x40 18DC 01 ADD 18DD 91 SWAP2 18DE 50 POP 18DF 50 POP 18E0 60 PUSH1 0x40 18E2 51 MLOAD 18E3 80 DUP1 18E4 91 SWAP2 18E5 03 SUB 18E6 90 SWAP1 18E7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @18BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18CA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @18CE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2d // @18D9 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2d] = code[0x1c25:0x1c52] // @18E7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_18E8: // Incoming jump from 0x18B1, if stack[-1] // Incoming jump from 0x1A54, if stack[-1] // Inputs[1] { @18EE stack[-6] } 18E8 5B JUMPDEST 18E9 50 POP 18EA 50 POP 18EB 50 POP 18EC 50 POP 18ED 50 POP 18EE 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_18EF: // Incoming call from 0x1560, returns to 0x1561 // Incoming call from 0x1742, returns to 0x1743 // Incoming call from 0x0D2F, returns to 0x0D30 // Inputs[2] // { // @18F0 stack[-1] // @18F1 stack[-2] // } 18EF 5B JUMPDEST 18F0 80 DUP1 18F1 82 DUP3 18F2 01 ADD 18F3 82 DUP3 18F4 81 DUP2 18F5 10 LT 18F6 15 ISZERO 18F7 61 PUSH2 0x07e4 18FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18F2 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x07e4, if !(stack[-2] + stack[-1] < stack[-2]) label_18FB: // Incoming jump from 0x18FA, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @18FE memory[0x40:0x60] // @1934 memory[0x40:0x60] // @193D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 18FB 60 PUSH1 0x40 18FD 80 DUP1 18FE 51 MLOAD 18FF 62 PUSH3 0x461bcd 1903 60 PUSH1 0xe5 1905 1B SHL 1906 81 DUP2 1907 52 MSTORE 1908 60 PUSH1 0x20 190A 60 PUSH1 0x04 190C 82 DUP3 190D 01 ADD 190E 52 MSTORE 190F 60 PUSH1 0x14 1911 60 PUSH1 0x24 1913 82 DUP3 1914 01 ADD 1915 52 MSTORE 1916 73 PUSH20 0x64732d6d6174682d6164642d6f766572666c6f77 192B 60 PUSH1 0x60 192D 1B SHL 192E 60 PUSH1 0x44 1930 82 DUP3 1931 01 ADD 1932 52 MSTORE 1933 90 SWAP1 1934 51 MLOAD 1935 90 SWAP1 1936 81 DUP2 1937 90 SWAP1 1938 03 SUB 1939 60 PUSH1 0x64 193B 01 ADD 193C 90 SWAP1 193D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1907 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @190E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1915 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1932 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d6164642d6f766572666c6f77 << 0x60 // @193D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_193E: // Incoming call from 0x105D, returns to 0x105E // Inputs[8] // { // @1942 memory[0x40:0x60] // @194B stack[-2] // @1958 stack[-1] // @195C memory[0x40:0x60] // @1971 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @1987 memory[0x40:0x60] // @1989 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1991 stack[-3] // } 193E 5B JUMPDEST 193F 60 PUSH1 0x40 1941 80 DUP1 1942 51 MLOAD 1943 60 PUSH1 0x01 1945 60 PUSH1 0x01 1947 60 PUSH1 0xa0 1949 1B SHL 194A 03 SUB 194B 84 DUP5 194C 81 DUP2 194D 16 AND 194E 60 PUSH1 0x24 1950 83 DUP4 1951 01 ADD 1952 52 MSTORE 1953 60 PUSH1 0x44 1955 80 DUP1 1956 83 DUP4 1957 01 ADD 1958 85 DUP6 1959 90 SWAP1 195A 52 MSTORE 195B 83 DUP4 195C 51 MLOAD 195D 80 DUP1 195E 84 DUP5 195F 03 SUB 1960 90 SWAP1 1961 91 SWAP2 1962 01 ADD 1963 81 DUP2 1964 52 MSTORE 1965 60 PUSH1 0x64 1967 90 SWAP1 1968 92 SWAP3 1969 01 ADD 196A 83 DUP4 196B 52 MSTORE 196C 60 PUSH1 0x20 196E 82 DUP3 196F 01 ADD 1970 80 DUP1 1971 51 MLOAD 1972 60 PUSH1 0x01 1974 60 PUSH1 0x01 1976 60 PUSH1 0xe0 1978 1B SHL 1979 03 SUB 197A 16 AND 197B 63 PUSH4 0x095ea7b3 1980 60 PUSH1 0xe0 1982 1B SHL 1983 17 OR 1984 81 DUP2 1985 52 MSTORE 1986 92 SWAP3 1987 51 MLOAD 1988 82 DUP3 1989 51 MLOAD 198A 60 PUSH1 0x00 198C 94 SWAP5 198D 60 PUSH1 0x60 198F 94 SWAP5 1990 93 SWAP4 1991 89 DUP10 1992 16 AND 1993 93 SWAP4 1994 92 SWAP3 1995 91 SWAP2 1996 82 DUP3 1997 91 SWAP2 1998 90 SWAP1 1999 80 DUP1 199A 83 DUP4 199B 83 DUP4 199C 5B JUMPDEST 199D 60 PUSH1 0x20 199F 83 DUP4 19A0 10 LT 19A1 61 PUSH2 0x19bb 19A4 57 *JUMPI // Stack delta = +11 // Outputs[16] // { // @1952 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @195A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @1964 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x44 + (memory[0x40:0x60] - memory[0x40:0x60]) // @196B memory[0x40:0x60] = memory[0x40:0x60] + 0x64 // @1985 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x095ea7b3 << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @198C stack[0] = 0x00 // @198F stack[1] = 0x60 // @1993 stack[2] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1994 stack[3] = memory[0x40:0x60] // @1995 stack[4] = memory[0x40:0x60] // @1997 stack[5] = memory[0x40:0x60] // @1998 stack[6] = memory[0x40:0x60] + 0x20 // @1998 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1999 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @199A stack[9] = memory[0x40:0x60] // @199B stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x19bb, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_19A5: // Incoming jump from 0x19A4, if not stack[-3] < 0x20 // Incoming jump from 0x19A4, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @19A5 stack[-1] // @19A6 memory[stack[-1]:stack[-1] + 0x20] // @19A7 stack[-2] // @19AD stack[-3] // } 19A5 80 DUP1 19A6 51 MLOAD 19A7 82 DUP3 19A8 52 MSTORE 19A9 60 PUSH1 0x1f 19AB 19 NOT 19AC 90 SWAP1 19AD 92 SWAP3 19AE 01 ADD 19AF 91 SWAP2 19B0 60 PUSH1 0x20 19B2 91 SWAP2 19B3 82 DUP3 19B4 01 ADD 19B5 91 SWAP2 19B6 01 ADD 19B7 61 PUSH2 0x199c 19BA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @19A8 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @19AF stack[-3] = stack[-3] + ~0x1f // @19B5 stack[-2] = 0x20 + stack[-2] // @19B6 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x199c label_19BB: // Incoming jump from 0x19A4, if stack[-3] < 0x20 // Incoming jump from 0x19A4, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[15] // { // @19BE stack[-3] // @19C9 stack[-1] // @19CA memory[stack[-1]:stack[-1] + 0x20] // @19CD stack[-2] // @19CE memory[stack[-2]:stack[-2] + 0x20] // @19DB stack[-4] // @19DB stack[-5] // @19DD stack[-6] // @19DE stack[-8] // @19E5 memory[0x40:0x60] // @19EC stack[-9] // @19ED msg.gas // @19EE memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @19EE address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @19F2 returndata.length // } 19BB 5B JUMPDEST 19BC 60 PUSH1 0x01 19BE 83 DUP4 19BF 60 PUSH1 0x20 19C1 03 SUB 19C2 61 PUSH2 0x0100 19C5 0A EXP 19C6 03 SUB 19C7 80 DUP1 19C8 19 NOT 19C9 82 DUP3 19CA 51 MLOAD 19CB 16 AND 19CC 81 DUP2 19CD 84 DUP5 19CE 51 MLOAD 19CF 16 AND 19D0 80 DUP1 19D1 82 DUP3 19D2 17 OR 19D3 85 DUP6 19D4 52 MSTORE 19D5 50 POP 19D6 50 POP 19D7 50 POP 19D8 50 POP 19D9 50 POP 19DA 50 POP 19DB 90 SWAP1 19DC 50 POP 19DD 01 ADD 19DE 91 SWAP2 19DF 50 POP 19E0 50 POP 19E1 60 PUSH1 0x00 19E3 60 PUSH1 0x40 19E5 51 MLOAD 19E6 80 DUP1 19E7 83 DUP4 19E8 03 SUB 19E9 81 DUP2 19EA 60 PUSH1 0x00 19EC 86 DUP7 19ED 5A GAS 19EE F1 CALL 19EF 91 SWAP2 19F0 50 POP 19F1 50 POP 19F2 3D RETURNDATASIZE 19F3 80 DUP1 19F4 60 PUSH1 0x00 19F6 81 DUP2 19F7 14 EQ 19F8 61 PUSH2 0x1a1d 19FB 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @19D4 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @19EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @19EF stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @19F2 stack[-8] = returndata.length // @19F3 stack[-7] = returndata.length // } // Block ends with conditional jump to 0x1a1d, if returndata.length == 0x00 label_19FC: // Incoming jump from 0x19FB, if not returndata.length == 0x00 // Inputs[6] // { // @19FE memory[0x40:0x60] // @19FF stack[-2] // @1A06 returndata.length // @1A0E returndata.length // @1A11 returndata.length // @1A18 returndata[0x00:0x00 + returndata.length] // } 19FC 60 PUSH1 0x40 19FE 51 MLOAD 19FF 91 SWAP2 1A00 50 POP 1A01 60 PUSH1 0x1f 1A03 19 NOT 1A04 60 PUSH1 0x3f 1A06 3D RETURNDATASIZE 1A07 01 ADD 1A08 16 AND 1A09 82 DUP3 1A0A 01 ADD 1A0B 60 PUSH1 0x40 1A0D 52 MSTORE 1A0E 3D RETURNDATASIZE 1A0F 82 DUP3 1A10 52 MSTORE 1A11 3D RETURNDATASIZE 1A12 60 PUSH1 0x00 1A14 60 PUSH1 0x20 1A16 84 DUP5 1A17 01 ADD 1A18 3E RETURNDATACOPY 1A19 61 PUSH2 0x1a22 1A1C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @19FF stack[-2] = memory[0x40:0x60] // @1A0D memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1A10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1A18 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1a22 label_1A1D: // Incoming jump from 0x19FB, if returndata.length == 0x00 // Inputs[4] // { // @1A20 stack[-2] // @1A24 stack[-4] // @1A26 stack[-5] // @1A26 stack[-3] // } 1A1D 5B JUMPDEST 1A1E 60 PUSH1 0x60 1A20 91 SWAP2 1A21 50 POP 1A22 5B JUMPDEST 1A23 50 POP 1A24 91 SWAP2 1A25 50 POP 1A26 91 SWAP2 1A27 50 POP 1A28 81 DUP2 1A29 80 DUP1 1A2A 15 ISZERO 1A2B 61 PUSH2 0x1a50 1A2E 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @1A24 stack[-4] = 0x60 // @1A26 stack[-5] = stack[-3] // @1A28 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x1a50, if !stack[-3] label_1A2F: // Incoming jump from 0x1A2E, if not !stack[-3] // Incoming jump from 0x1A2E, if not !stack[-3] // Inputs[2] // { // @1A30 stack[-2] // @1A31 memory[stack[-2]:stack[-2] + 0x20] // } 1A2F 50 POP 1A30 80 DUP1 1A31 51 MLOAD 1A32 15 ISZERO 1A33 80 DUP1 1A34 61 PUSH2 0x1a50 1A37 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A32 stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1a50, if !memory[stack[-2]:stack[-2] + 0x20] label_1A38: // Incoming jump from 0x1A37, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @1A39 stack[-2] // @1A3F memory[stack[-2]:stack[-2] + 0x20] // } 1A38 50 POP 1A39 80 DUP1 1A3A 80 DUP1 1A3B 60 PUSH1 0x20 1A3D 01 ADD 1A3E 90 SWAP1 1A3F 51 MLOAD 1A40 60 PUSH1 0x20 1A42 81 DUP2 1A43 10 LT 1A44 15 ISZERO 1A45 61 PUSH2 0x1a4d 1A48 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1A3E stack[-1] = 0x20 + stack[-2] // @1A3F stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1a4d, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_1A49: // Incoming jump from 0x1A48, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @1A4C memory[0x00:0x00] } 1A49 60 PUSH1 0x00 1A4B 80 DUP1 1A4C FD *REVERT // Stack delta = +0 // Outputs[1] { @1A4C revert(memory[0x00:0x00]); } // Block terminates label_1A4D: // Incoming jump from 0x1A48, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @1A4F memory[stack[-2]:stack[-2] + 0x20] // @1A4F stack[-2] // } 1A4D 5B JUMPDEST 1A4E 50 POP 1A4F 51 MLOAD // Stack delta = -1 // Outputs[1] { @1A4F stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_1A50: // Incoming jump from 0x1A2E, if !stack[-3] // Incoming jump from 0x1A37, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1A2E, if !stack[-3] // Incoming jump from 0x1A4F // Inputs[1] { @1A54 stack[-1] } 1A50 5B JUMPDEST 1A51 61 PUSH2 0x18e8 1A54 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18e8, if stack[-1] label_1A55: // Incoming jump from 0x1A54, if not stack[-1] // Inputs[3] // { // @1A57 memory[0x40:0x60] // @1A85 memory[0x40:0x60] // @1A8A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A55 60 PUSH1 0x40 1A57 51 MLOAD 1A58 62 PUSH3 0x461bcd 1A5C 60 PUSH1 0xe5 1A5E 1B SHL 1A5F 81 DUP2 1A60 52 MSTORE 1A61 60 PUSH1 0x04 1A63 01 ADD 1A64 80 DUP1 1A65 80 DUP1 1A66 60 PUSH1 0x20 1A68 01 ADD 1A69 82 DUP3 1A6A 81 DUP2 1A6B 03 SUB 1A6C 82 DUP3 1A6D 52 MSTORE 1A6E 60 PUSH1 0x2b 1A70 81 DUP2 1A71 52 MSTORE 1A72 60 PUSH1 0x20 1A74 01 ADD 1A75 80 DUP1 1A76 61 PUSH2 0x1bd7 1A79 60 PUSH1 0x2b 1A7B 91 SWAP2 1A7C 39 CODECOPY 1A7D 60 PUSH1 0x40 1A7F 01 ADD 1A80 91 SWAP2 1A81 50 POP 1A82 50 POP 1A83 60 PUSH1 0x40 1A85 51 MLOAD 1A86 80 DUP1 1A87 91 SWAP2 1A88 03 SUB 1A89 90 SWAP1 1A8A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1A60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A6D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1A71 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2b // @1A7C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2b] = code[0x1bd7:0x1c02] // @1A8A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A8B: // Incoming call from 0x10AB, returns to 0x10AC // Inputs[4] // { // @1A94 stack[-2] // @1AA3 memory[0x00:0x40] // @1AA4 storage[keccak256(memory[0x00:0x40])] // @1AA9 stack[-1] // } 1A8B 5B JUMPDEST 1A8C 60 PUSH1 0x01 1A8E 60 PUSH1 0x01 1A90 60 PUSH1 0xa0 1A92 1B SHL 1A93 03 SUB 1A94 82 DUP3 1A95 16 AND 1A96 60 PUSH1 0x00 1A98 90 SWAP1 1A99 81 DUP2 1A9A 52 MSTORE 1A9B 60 PUSH1 0x05 1A9D 60 PUSH1 0x20 1A9F 52 MSTORE 1AA0 60 PUSH1 0x40 1AA2 90 SWAP1 1AA3 20 SHA3 1AA4 54 SLOAD 1AA5 61 PUSH2 0x1ab4 1AA8 90 SWAP1 1AA9 82 DUP3 1AAA 63 PUSH4 0xffffffff 1AAF 61 PUSH2 0x14b3 1AB2 16 AND 1AB3 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1A9A memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1A9F memory[0x20:0x40] = 0x05 // @1AA8 stack[0] = 0x1ab4 // @1AA8 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1AA9 stack[2] = stack[-1] // } // Block ends with call to 0x14b3 & 0xffffffff, returns to 0x1AB4 label_1AB4: // Incoming return from call to 0x14B3 at 0x1AB3 // Inputs[8] // { // @1ABD stack[-3] // @1ACF memory[0x00:0x40] // @1AD0 stack[-1] // @1AD5 memory[0x40:0x60] // @1AD6 stack[-2] // @1ADA memory[0x40:0x60] // @1B07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1B0A stack[-4] // } 1AB4 5B JUMPDEST 1AB5 60 PUSH1 0x01 1AB7 60 PUSH1 0x01 1AB9 60 PUSH1 0xa0 1ABB 1B SHL 1ABC 03 SUB 1ABD 83 DUP4 1ABE 16 AND 1ABF 60 PUSH1 0x00 1AC1 81 DUP2 1AC2 81 DUP2 1AC3 52 MSTORE 1AC4 60 PUSH1 0x05 1AC6 60 PUSH1 0x20 1AC8 90 SWAP1 1AC9 81 DUP2 1ACA 52 MSTORE 1ACB 60 PUSH1 0x40 1ACD 80 DUP1 1ACE 83 DUP4 1ACF 20 SHA3 1AD0 94 SWAP5 1AD1 90 SWAP1 1AD2 94 SWAP5 1AD3 55 SSTORE 1AD4 83 DUP4 1AD5 51 MLOAD 1AD6 85 DUP6 1AD7 81 DUP2 1AD8 52 MSTORE 1AD9 93 SWAP4 1ADA 51 MLOAD 1ADB 91 SWAP2 1ADC 93 SWAP4 1ADD 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1AFE 92 SWAP3 1AFF 90 SWAP1 1B00 81 DUP2 1B01 90 SWAP1 1B02 03 SUB 1B03 90 SWAP1 1B04 91 SWAP2 1B05 01 ADD 1B06 90 SWAP1 1B07 A3 LOG3 1B08 50 POP 1B09 50 POP 1B0A 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @1AC3 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1ACA memory[0x20:0x40] = 0x05 // @1AD3 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1AD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1B07 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & (0x01 << 0xa0) - 0x01, 0x00]); // } // Block ends with unconditional jump to stack[-4] label_1B0B: // Incoming call from 0x1387, returns to 0x1388 // Incoming call from 0x1123, returns to 0x1124 // Inputs[2] // { // @1B0C msg.sender // @1B0D stack[-1] // } 1B0B 5B JUMPDEST 1B0C 33 CALLER 1B0D 90 SWAP1 1B0E 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B0D stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_1B0F: // Incoming call from 0x1199, returns to 0x119A // Incoming call from 0x1441, returns to 0x0CA9 // Inputs[5] // { // @1B13 storage[0x00] // @1B1C stack[-1] // @1B30 memory[0x40:0x60] // @1B5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1B5E stack[-2] // } 1B0F 5B JUMPDEST 1B10 60 PUSH1 0x00 1B12 80 DUP1 1B13 54 SLOAD 1B14 60 PUSH1 0x01 1B16 60 PUSH1 0x01 1B18 60 PUSH1 0xa0 1B1A 1B SHL 1B1B 03 SUB 1B1C 83 DUP4 1B1D 81 DUP2 1B1E 16 AND 1B1F 60 PUSH1 0x01 1B21 60 PUSH1 0x01 1B23 60 PUSH1 0xa0 1B25 1B SHL 1B26 03 SUB 1B27 19 NOT 1B28 83 DUP4 1B29 16 AND 1B2A 81 DUP2 1B2B 17 OR 1B2C 84 DUP5 1B2D 55 SSTORE 1B2E 60 PUSH1 0x40 1B30 51 MLOAD 1B31 91 SWAP2 1B32 90 SWAP1 1B33 92 SWAP3 1B34 16 AND 1B35 92 SWAP3 1B36 83 DUP4 1B37 91 SWAP2 1B38 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1B59 91 SWAP2 1B5A 90 SWAP1 1B5B A3 LOG3 1B5C 50 POP 1B5D 50 POP 1B5E 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1B2D storage[0x00] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~((0x01 << 0xa0) - 0x01)) // @1B5B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 1B5F FE *ASSERT 1B60 4F 4F 1B61 77 PUSH24 0x6e61626c653a206e6577206f776e65722069732074686520 1B7A 7A PUSH27 0x65726f20616464726573735472616e7366657248656c7065723a3a 1B96 74 PUSH21 0x72616e7366657246726f6d3a207472616e73666572 1BAC 46 CHAINID 1BAD 72 PUSH19 0x6f6d206661696c6564436f72655265663a2043 1BC1 61 PUSH2 0x6c6c 1BC4 65 PUSH6 0x72206973206e 1BCB 6F PUSH16 0x742061206d696e746572005472616e73 1BDC 66 PUSH7 0x657248656c7065 1BE4 72 PUSH19 0x3a3a73616665417070726f76653a2061707072 1BF8 6F PUSH16 0x7665206661696c65644665773a207a65 1C09 72 PUSH19 0x6f20616d6f756e7420756e77726170206e6f74 1C1D 20 SHA3 1C1E 61 PUSH2 0x6c6c 1C21 6F PUSH16 0x7765645472616e7366657248656c7065 1C32 72 PUSH19 0x3a3a736166655472616e736665723a20747261 1C46 6E PUSH15 0x73666572206661696c6564a2646970 1C56 66 PUSH7 0x7358221220f27d 1C5E 52 MSTORE 1C5F 10 LT 1C60 F1 CALL 1C61 0F 0F 1C62 83 DUP4 1C63 60 PUSH1 0x98 1C65 86 DUP7 1C66 21 21 1C67 A5 A5 1C68 5F PUSH0 1C69 79 PUSH26 0xf7530c22c6feea8407c8c133add6e45f1a1564736f6c63430006 1C84 06 MOD 1C85 00 *STOP 1C86 33 CALLER