Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x00da 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00da, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 62 PUSH3 0xfdd58e 0025 14 EQ 0026 61 PUSH2 0x00df 0029 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00df, if 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 label_002A: // Incoming jump from 0x0029, if not 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002A stack[-1] } 002A 80 DUP1 002B 63 PUSH4 0x01ffc9a7 0030 14 EQ 0031 61 PUSH2 0x0105 0034 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0105, if 0x01ffc9a7 == stack[-1] label_0035: // Incoming jump from 0x0034, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0035 stack[-1] } 0035 80 DUP1 0036 63 PUSH4 0x06fdde03 003B 14 EQ 003C 61 PUSH2 0x0128 003F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0128, if 0x06fdde03 == stack[-1] label_0040: // Incoming jump from 0x003F, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0040 stack[-1] } 0040 80 DUP1 0041 63 PUSH4 0x0e89341c 0046 14 EQ 0047 61 PUSH2 0x013d 004A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013d, if 0x0e89341c == stack[-1] label_004B: // Incoming jump from 0x004A, if not 0x0e89341c == stack[-1] // Inputs[1] { @004B stack[-1] } 004B 80 DUP1 004C 63 PUSH4 0x29dcb0cf 0051 14 EQ 0052 61 PUSH2 0x0150 0055 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0150, if 0x29dcb0cf == stack[-1] label_0056: // Incoming jump from 0x0055, if not 0x29dcb0cf == stack[-1] // Inputs[1] { @0056 stack[-1] } 0056 80 DUP1 0057 63 PUSH4 0x2eb2c2d6 005C 14 EQ 005D 61 PUSH2 0x0177 0060 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0177, if 0x2eb2c2d6 == stack[-1] label_0061: // Incoming jump from 0x0060, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0061 stack[-1] } 0061 80 DUP1 0062 63 PUSH4 0x4e1273f4 0067 14 EQ 0068 61 PUSH2 0x018c 006B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018c, if 0x4e1273f4 == stack[-1] label_006C: // Incoming jump from 0x006B, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @006C stack[-1] } 006C 80 DUP1 006D 63 PUSH4 0x4e71d92d 0072 14 EQ 0073 61 PUSH2 0x01ac 0076 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ac, if 0x4e71d92d == stack[-1] label_0077: // Incoming jump from 0x0076, if not 0x4e71d92d == stack[-1] // Inputs[1] { @0077 stack[-1] } 0077 80 DUP1 0078 63 PUSH4 0x4f558e79 007D 14 EQ 007E 61 PUSH2 0x01b4 0081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b4, if 0x4f558e79 == stack[-1] label_0082: // Incoming jump from 0x0081, if not 0x4f558e79 == stack[-1] // Inputs[1] { @0082 stack[-1] } 0082 80 DUP1 0083 63 PUSH4 0x8b58c569 0088 14 EQ 0089 61 PUSH2 0x01c7 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c7, if 0x8b58c569 == stack[-1] label_008D: // Incoming jump from 0x008C, if not 0x8b58c569 == stack[-1] // Inputs[1] { @008D stack[-1] } 008D 80 DUP1 008E 63 PUSH4 0x95d89b41 0093 14 EQ 0094 61 PUSH2 0x01da 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01da, if 0x95d89b41 == stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0xa22cb465 009E 14 EQ 009F 61 PUSH2 0x01e2 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e2, if 0xa22cb465 == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0xbd85b039 00A9 14 EQ 00AA 61 PUSH2 0x01f5 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f5, if 0xbd85b039 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0xbd85b039 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0xc884ef83 00B4 14 EQ 00B5 61 PUSH2 0x0208 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0208, if 0xc884ef83 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0xc884ef83 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xe8a3d485 00BF 14 EQ 00C0 61 PUSH2 0x022b 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022b, if 0xe8a3d485 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xe985e9c5 00CA 14 EQ 00CB 61 PUSH2 0x0233 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0233, if 0xe985e9c5 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xf242432a 00D5 14 EQ 00D6 61 PUSH2 0x026f 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026f, if 0xf242432a == stack[-1] label_00DA: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00D9, if not 0xf242432a == stack[-1] // Inputs[1] { @00DE memory[0x00:0x00] } 00DA 5B JUMPDEST 00DB 60 PUSH1 0x00 00DD 80 DUP1 00DE FD *REVERT // Stack delta = +0 // Outputs[1] { @00DE revert(memory[0x00:0x00]); } // Block terminates label_00DF: // Incoming jump from 0x0029, if 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00E6 msg.data.length } 00DF 5B JUMPDEST 00E0 61 PUSH2 0x00f2 00E3 61 PUSH2 0x00ed 00E6 36 CALLDATASIZE 00E7 60 PUSH1 0x04 00E9 61 PUSH2 0x14cd 00EC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00E0 stack[0] = 0x00f2 // @00E3 stack[1] = 0x00ed // @00E6 stack[2] = msg.data.length // @00E7 stack[3] = 0x04 // } // Block ends with call to 0x14cd, returns to 0x00ED label_00ED: // Incoming return from call to 0x14CD at 0x00EC 00ED 5B JUMPDEST 00EE 61 PUSH2 0x0282 00F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0282 label_00F2: // Incoming jump from 0x0176 // Incoming return from call to 0x01D5 at 0x01D4 // Incoming return from call to 0x0203 at 0x0202 // Incoming return from call to 0x00ED at 0x00EC // Inputs[4] // { // @00F5 memory[0x40:0x60] // @00F6 stack[-1] // @00FF memory[0x40:0x60] // @0104 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00F2 5B JUMPDEST 00F3 60 PUSH1 0x40 00F5 51 MLOAD 00F6 90 SWAP1 00F7 81 DUP2 00F8 52 MSTORE 00F9 60 PUSH1 0x20 00FB 01 ADD 00FC 5B JUMPDEST 00FD 60 PUSH1 0x40 00FF 51 MLOAD 0100 80 DUP1 0101 91 SWAP2 0102 03 SUB 0103 90 SWAP1 0104 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0104 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0105: // Incoming jump from 0x0034, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @010C msg.data.length } 0105 5B JUMPDEST 0106 61 PUSH2 0x0118 0109 61 PUSH2 0x0113 010C 36 CALLDATASIZE 010D 60 PUSH1 0x04 010F 61 PUSH2 0x15c7 0112 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0106 stack[0] = 0x0118 // @0109 stack[1] = 0x0113 // @010C stack[2] = msg.data.length // @010D stack[3] = 0x04 // } // Block ends with call to 0x15c7, returns to 0x0113 label_0113: // Incoming return from call to 0x15C7 at 0x0112 0113 5B JUMPDEST 0114 61 PUSH2 0x0319 0117 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0319 label_0118: // Incoming return from call to 0x01C2 at 0x01C1 // Incoming return from call to 0x0241 at 0x0240 // Incoming return from call to 0x0113 at 0x0112 // Incoming return from call to 0x0216 at 0x0215 // Inputs[2] // { // @011B memory[0x40:0x60] // @011C stack[-1] // } 0118 5B JUMPDEST 0119 60 PUSH1 0x40 011B 51 MLOAD 011C 90 SWAP1 011D 15 ISZERO 011E 15 ISZERO 011F 81 DUP2 0120 52 MSTORE 0121 60 PUSH1 0x20 0123 01 ADD 0124 61 PUSH2 0x00fc 0127 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0120 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0123 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00fc label_0128: // Incoming jump from 0x003F, if 0x06fdde03 == stack[-1] 0128 5B JUMPDEST 0129 61 PUSH2 0x0130 012C 61 PUSH2 0x0344 012F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0129 stack[0] = 0x0130 } // Block ends with call to 0x0344, returns to 0x0130 label_0130: // Incoming return from call to 0x0344 at 0x012F // Incoming return from call to 0x0851 at 0x0232 // Incoming return from call to 0x075B at 0x01E1 // Incoming return from call to 0x014B at 0x014A // Inputs[2] // { // @0133 memory[0x40:0x60] // @0137 stack[-1] // } 0130 5B JUMPDEST 0131 60 PUSH1 0x40 0133 51 MLOAD 0134 61 PUSH2 0x00fc 0137 91 SWAP2 0138 90 SWAP1 0139 61 PUSH2 0x178b 013C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0137 stack[-1] = 0x00fc // @0138 stack[1] = memory[0x40:0x60] // @0138 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x178b label_013D: // Incoming jump from 0x004A, if 0x0e89341c == stack[-1] // Inputs[1] { @0144 msg.data.length } 013D 5B JUMPDEST 013E 61 PUSH2 0x0130 0141 61 PUSH2 0x014b 0144 36 CALLDATASIZE 0145 60 PUSH1 0x04 0147 61 PUSH2 0x1601 014A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @013E stack[0] = 0x0130 // @0141 stack[1] = 0x014b // @0144 stack[2] = msg.data.length // @0145 stack[3] = 0x04 // } // Block ends with call to 0x1601, returns to 0x014B label_014B: // Incoming return from call to 0x1601 at 0x014A 014B 5B JUMPDEST 014C 61 PUSH2 0x03d2 014F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03d2 label_0150: // Incoming jump from 0x0055, if 0x29dcb0cf == stack[-1] 0150 5B JUMPDEST 0151 61 PUSH2 0x00f2 0154 7F PUSH32 0x000000000000000000000000000000000000000000000000000000006105e400 0175 81 DUP2 0176 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0151 stack[0] = 0x00f2 // @0154 stack[1] = 0x000000000000000000000000000000000000000000000000000000006105e400 // } // Block ends with unconditional jump to 0x00f2 label_0177: // Incoming jump from 0x0060, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @017E msg.data.length } 0177 5B JUMPDEST 0178 61 PUSH2 0x018a 017B 61 PUSH2 0x0185 017E 36 CALLDATASIZE 017F 60 PUSH1 0x04 0181 61 PUSH2 0x1384 0184 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0178 stack[0] = 0x018a // @017B stack[1] = 0x0185 // @017E stack[2] = msg.data.length // @017F stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1384 0185 5B JUMPDEST 0186 61 PUSH2 0x049b 0189 56 *JUMP label_018A: // Incoming return from call to 0x01F0 at 0x01EF 018A 5B JUMPDEST 018B 00 *STOP // Stack delta = +0 // Outputs[1] { @018B stop(); } // Block terminates label_018C: // Incoming jump from 0x006B, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0193 msg.data.length } 018C 5B JUMPDEST 018D 61 PUSH2 0x019f 0190 61 PUSH2 0x019a 0193 36 CALLDATASIZE 0194 60 PUSH1 0x04 0196 61 PUSH2 0x14f7 0199 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @018D stack[0] = 0x019f // @0190 stack[1] = 0x019a // @0193 stack[2] = msg.data.length // @0194 stack[3] = 0x04 // } // Block ends with call to 0x14f7, returns to 0x019A label_019A: // Incoming return from call to 0x14F7 at 0x0199 019A 5B JUMPDEST 019B 61 PUSH2 0x0532 019E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0532 label_019F: // Incoming return from call to 0x019A at 0x0199 // Inputs[2] // { // @01A2 memory[0x40:0x60] // @01A6 stack[-1] // } 019F 5B JUMPDEST 01A0 60 PUSH1 0x40 01A2 51 MLOAD 01A3 61 PUSH2 0x00fc 01A6 91 SWAP2 01A7 90 SWAP1 01A8 61 PUSH2 0x1753 01AB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01A6 stack[-1] = 0x00fc // @01A7 stack[1] = memory[0x40:0x60] // @01A7 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1753 label_01AC: // Incoming jump from 0x0076, if 0x4e71d92d == stack[-1] 01AC 5B JUMPDEST 01AD 61 PUSH2 0x018a 01B0 61 PUSH2 0x065b 01B3 56 *JUMP // Stack delta = +1 // Outputs[1] { @01AD stack[0] = 0x018a } // Block ends with unconditional jump to 0x065b label_01B4: // Incoming jump from 0x0081, if 0x4f558e79 == stack[-1] // Inputs[1] { @01BB msg.data.length } 01B4 5B JUMPDEST 01B5 61 PUSH2 0x0118 01B8 61 PUSH2 0x01c2 01BB 36 CALLDATASIZE 01BC 60 PUSH1 0x04 01BE 61 PUSH2 0x1601 01C1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01B5 stack[0] = 0x0118 // @01B8 stack[1] = 0x01c2 // @01BB stack[2] = msg.data.length // @01BC stack[3] = 0x04 // } // Block ends with call to 0x1601, returns to 0x01C2 label_01C2: // Incoming return from call to 0x1601 at 0x01C1 01C2 5B JUMPDEST 01C3 61 PUSH2 0x06b7 01C6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06b7 label_01C7: // Incoming jump from 0x008C, if 0x8b58c569 == stack[-1] // Inputs[1] { @01CE msg.data.length } 01C7 5B JUMPDEST 01C8 61 PUSH2 0x00f2 01CB 61 PUSH2 0x01d5 01CE 36 CALLDATASIZE 01CF 60 PUSH1 0x04 01D1 61 PUSH2 0x1601 01D4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01C8 stack[0] = 0x00f2 // @01CB stack[1] = 0x01d5 // @01CE stack[2] = msg.data.length // @01CF stack[3] = 0x04 // } // Block ends with call to 0x1601, returns to 0x01D5 label_01D5: // Incoming return from call to 0x1601 at 0x01D4 01D5 5B JUMPDEST 01D6 61 PUSH2 0x06ca 01D9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ca label_01DA: // Incoming jump from 0x0097, if 0x95d89b41 == stack[-1] 01DA 5B JUMPDEST 01DB 61 PUSH2 0x0130 01DE 61 PUSH2 0x075b 01E1 56 *JUMP // Stack delta = +1 // Outputs[1] { @01DB stack[0] = 0x0130 } // Block ends with call to 0x075b, returns to 0x0130 label_01E2: // Incoming jump from 0x00A2, if 0xa22cb465 == stack[-1] // Inputs[1] { @01E9 msg.data.length } 01E2 5B JUMPDEST 01E3 61 PUSH2 0x018a 01E6 61 PUSH2 0x01f0 01E9 36 CALLDATASIZE 01EA 60 PUSH1 0x04 01EC 61 PUSH2 0x1491 01EF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E3 stack[0] = 0x018a // @01E6 stack[1] = 0x01f0 // @01E9 stack[2] = msg.data.length // @01EA stack[3] = 0x04 // } // Block ends with call to 0x1491, returns to 0x01F0 label_01F0: // Incoming return from call to 0x1491 at 0x01EF 01F0 5B JUMPDEST 01F1 61 PUSH2 0x0768 01F4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0768 label_01F5: // Incoming jump from 0x00AD, if 0xbd85b039 == stack[-1] // Inputs[1] { @01FC msg.data.length } 01F5 5B JUMPDEST 01F6 61 PUSH2 0x00f2 01F9 61 PUSH2 0x0203 01FC 36 CALLDATASIZE 01FD 60 PUSH1 0x04 01FF 61 PUSH2 0x1601 0202 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01F6 stack[0] = 0x00f2 // @01F9 stack[1] = 0x0203 // @01FC stack[2] = msg.data.length // @01FD stack[3] = 0x04 // } // Block ends with call to 0x1601, returns to 0x0203 label_0203: // Incoming return from call to 0x1601 at 0x0202 0203 5B JUMPDEST 0204 61 PUSH2 0x083f 0207 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x083f label_0208: // Incoming jump from 0x00B8, if 0xc884ef83 == stack[-1] // Inputs[1] { @020F msg.data.length } 0208 5B JUMPDEST 0209 61 PUSH2 0x0118 020C 61 PUSH2 0x0216 020F 36 CALLDATASIZE 0210 60 PUSH1 0x04 0212 61 PUSH2 0x132f 0215 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0209 stack[0] = 0x0118 // @020C stack[1] = 0x0216 // @020F stack[2] = msg.data.length // @0210 stack[3] = 0x04 // } // Block ends with call to 0x132f, returns to 0x0216 label_0216: // Incoming return from call to 0x132F at 0x0215 // Inputs[4] // { // @021E stack[-1] // @0224 memory[0x00:0x40] // @0225 storage[keccak256(memory[0x00:0x40])] // @0229 stack[-2] // } 0216 5B JUMPDEST 0217 60 PUSH1 0x04 0219 60 PUSH1 0x20 021B 52 MSTORE 021C 60 PUSH1 0x00 021E 90 SWAP1 021F 81 DUP2 0220 52 MSTORE 0221 60 PUSH1 0x40 0223 90 SWAP1 0224 20 SHA3 0225 54 SLOAD 0226 60 PUSH1 0xff 0228 16 AND 0229 81 DUP2 022A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @021B memory[0x20:0x40] = 0x04 // @0220 memory[0x00:0x20] = stack[-1] // @0228 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_022B: // Incoming jump from 0x00C3, if 0xe8a3d485 == stack[-1] 022B 5B JUMPDEST 022C 61 PUSH2 0x0130 022F 61 PUSH2 0x0851 0232 56 *JUMP // Stack delta = +1 // Outputs[1] { @022C stack[0] = 0x0130 } // Block ends with call to 0x0851, returns to 0x0130 label_0233: // Incoming jump from 0x00CE, if 0xe985e9c5 == stack[-1] // Inputs[1] { @023A msg.data.length } 0233 5B JUMPDEST 0234 61 PUSH2 0x0118 0237 61 PUSH2 0x0241 023A 36 CALLDATASIZE 023B 60 PUSH1 0x04 023D 61 PUSH2 0x1351 0240 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0234 stack[0] = 0x0118 // @0237 stack[1] = 0x0241 // @023A stack[2] = msg.data.length // @023B stack[3] = 0x04 // } // Block ends with call to 0x1351, returns to 0x0241 label_0241: // Incoming return from call to 0x1351 at 0x0240 // Incoming call from 0x0879, returns to 0x087A // Inputs[6] // { // @024A stack[-2] // @025D memory[0x00:0x40] // @025E stack[-1] // @0268 memory[0x00:0x40] // @0269 storage[keccak256(memory[0x00:0x40])] // @026D stack[-3] // } 0241 5B JUMPDEST 0242 60 PUSH1 0x01 0244 60 PUSH1 0x01 0246 60 PUSH1 0xa0 0248 1B SHL 0249 03 SUB 024A 91 SWAP2 024B 82 DUP3 024C 16 AND 024D 60 PUSH1 0x00 024F 90 SWAP1 0250 81 DUP2 0251 52 MSTORE 0252 60 PUSH1 0x01 0254 60 PUSH1 0x20 0256 90 SWAP1 0257 81 DUP2 0258 52 MSTORE 0259 60 PUSH1 0x40 025B 80 DUP1 025C 83 DUP4 025D 20 SHA3 025E 93 SWAP4 025F 90 SWAP1 0260 94 SWAP5 0261 16 AND 0262 82 DUP3 0263 52 MSTORE 0264 91 SWAP2 0265 90 SWAP1 0266 91 SWAP2 0267 52 MSTORE 0268 20 SHA3 0269 54 SLOAD 026A 60 PUSH1 0xff 026C 16 AND 026D 90 SWAP1 026E 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0251 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0258 memory[0x20:0x40] = 0x01 // @0263 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0267 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @026D stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_026F: // Incoming jump from 0x00D9, if 0xf242432a == stack[-1] // Inputs[1] { @0276 msg.data.length } 026F 5B JUMPDEST 0270 61 PUSH2 0x018a 0273 61 PUSH2 0x027d 0276 36 CALLDATASIZE 0277 60 PUSH1 0x04 0279 61 PUSH2 0x142d 027C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0270 stack[0] = 0x018a // @0273 stack[1] = 0x027d // @0276 stack[2] = msg.data.length // @0277 stack[3] = 0x04 // } // Block ends with call to 0x142d, returns to 0x027D label_027D: // Incoming return from call to 0x142D at 0x027C 027D 5B JUMPDEST 027E 61 PUSH2 0x085e 0281 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x085e label_0282: // Incoming jump from 0x0625 // Incoming jump from 0x00F1 // Inputs[1] { @028D stack[-2] } 0282 5B JUMPDEST 0283 60 PUSH1 0x00 0285 60 PUSH1 0x01 0287 60 PUSH1 0x01 0289 60 PUSH1 0xa0 028B 1B SHL 028C 03 SUB 028D 83 DUP4 028E 16 AND 028F 61 PUSH2 0x02f3 0292 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0283 stack[0] = 0x00 } // Block ends with conditional jump to 0x02f3, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0293: // Incoming jump from 0x0292, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0295 memory[0x40:0x60] } 0293 60 PUSH1 0x40 0295 51 MLOAD 0296 62 PUSH3 0x461bcd 029A 60 PUSH1 0xe5 029C 1B SHL 029D 81 DUP2 029E 52 MSTORE 029F 60 PUSH1 0x20 02A1 60 PUSH1 0x04 02A3 82 DUP3 02A4 01 ADD 02A5 52 MSTORE 02A6 60 PUSH1 0x2b 02A8 60 PUSH1 0x24 02AA 82 DUP3 02AB 01 ADD 02AC 52 MSTORE 02AD 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 02CE 60 PUSH1 0x44 02D0 82 DUP3 02D1 01 ADD 02D2 52 MSTORE 02D3 6A PUSH11 0x65726f2061646472657373 02DF 60 PUSH1 0xa8 02E1 1B SHL 02E2 60 PUSH1 0x64 02E4 82 DUP3 02E5 01 ADD 02E6 52 MSTORE 02E7 60 PUSH1 0x84 02E9 01 ADD // Stack delta = +1 // Outputs[6] // { // @029E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02A5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @02AC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @02D2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @02E6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373 << 0xa8 // @02E9 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_02EA: // Incoming jump from 0x0FF4 // Incoming return from call to 0x17E6 at 0x0DCB // Incoming jump from 0x0BC9 // Incoming return from call to 0x182B at 0x0E25 // Incoming jump from 0x07D2 // Incoming jump from 0x0FF4 // Incoming jump from 0x02E9 // Incoming jump from 0x08D7 // Incoming jump from 0x0596 // Incoming jump from 0x0C32 // Incoming jump from 0x1084 // Incoming return from call to 0x179E at 0x1228 // Inputs[3] // { // @02ED memory[0x40:0x60] // @02EF stack[-1] // @02F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02EA 5B JUMPDEST 02EB 60 PUSH1 0x40 02ED 51 MLOAD 02EE 80 DUP1 02EF 91 SWAP2 02F0 03 SUB 02F1 90 SWAP1 02F2 FD *REVERT // Stack delta = -1 // Outputs[1] { @02F2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_02F3: // Incoming jump from 0x0292, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @02F7 stack[-2] // @0303 memory[0x00:0x40] // @030C stack[-3] // @0315 memory[0x00:0x40] // @0316 storage[keccak256(memory[0x00:0x40])] // @0317 stack[-4] // } 02F3 5B JUMPDEST 02F4 50 POP 02F5 60 PUSH1 0x00 02F7 90 SWAP1 02F8 81 DUP2 02F9 52 MSTORE 02FA 60 PUSH1 0x20 02FC 81 DUP2 02FD 81 DUP2 02FE 52 MSTORE 02FF 60 PUSH1 0x40 0301 80 DUP1 0302 83 DUP4 0303 20 SHA3 0304 60 PUSH1 0x01 0306 60 PUSH1 0x01 0308 60 PUSH1 0xa0 030A 1B SHL 030B 03 SUB 030C 94 SWAP5 030D 90 SWAP1 030E 94 SWAP5 030F 16 AND 0310 83 DUP4 0311 52 MSTORE 0312 92 SWAP3 0313 90 SWAP1 0314 52 MSTORE 0315 20 SHA3 0316 54 SLOAD 0317 90 SWAP1 0318 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @02F9 memory[0x00:0x20] = stack[-2] // @02FE memory[0x20:0x40] = 0x00 // @0311 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0314 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0317 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0319: // Incoming jump from 0x0117 // Inputs[1] { @0325 stack[-1] } 0319 5B JUMPDEST 031A 60 PUSH1 0x00 031C 60 PUSH1 0x01 031E 60 PUSH1 0x01 0320 60 PUSH1 0xe0 0322 1B SHL 0323 03 SUB 0324 19 NOT 0325 82 DUP3 0326 16 AND 0327 63 PUSH4 0xe8a3d485 032C 60 PUSH1 0xe0 032E 1B SHL 032F 14 EQ 0330 80 DUP1 0331 61 PUSH2 0x033e 0334 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @031A stack[0] = 0x00 // @032F stack[1] = 0xe8a3d485 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x033e, if 0xe8a3d485 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0335: // Incoming jump from 0x0334, if not 0xe8a3d485 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0339 stack[-3] } 0335 50 POP 0336 61 PUSH2 0x033e 0339 82 DUP3 033A 61 PUSH2 0x08e5 033D 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0336 stack[-1] = 0x033e // @0339 stack[0] = stack[-3] // } // Block ends with call to 0x08e5, returns to 0x033E label_033E: // Incoming return from call to 0x18B0 at 0x075A // Incoming return from call to 0x0418 at 0x0417 // Incoming jump from 0x091B, if stack[-1] // Incoming jump from 0x0334, if 0xe8a3d485 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x091B, if 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x08E5 at 0x033D // Incoming jump from 0x0934 // Inputs[3] // { // @033F stack[-1] // @033F stack[-4] // @0340 stack[-3] // } 033E 5B JUMPDEST 033F 92 SWAP3 0340 91 SWAP2 0341 50 POP 0342 50 POP 0343 56 *JUMP // Stack delta = -3 // Outputs[1] { @033F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0344: // Incoming call from 0x012F, returns to 0x0130 // Inputs[1] { @0348 storage[0x05] } 0344 5B JUMPDEST 0345 60 PUSH1 0x05 0347 80 DUP1 0348 54 SLOAD 0349 61 PUSH2 0x0351 034C 90 SWAP1 034D 61 PUSH2 0x1941 0350 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0345 stack[0] = 0x05 // @034C stack[1] = 0x0351 // @034C stack[2] = storage[0x05] // } // Block ends with call to 0x1941, returns to 0x0351 label_0351: // Incoming return from call to 0x1941 at 0x085D // Incoming return from call to 0x1941 at 0x0767 // Incoming return from call to 0x1941 at 0x0350 // Inputs[4] // { // @0352 stack[-1] // @0361 memory[0x40:0x60] // @0369 stack[-2] // @0374 storage[stack[-2]] // } 0351 5B JUMPDEST 0352 80 DUP1 0353 60 PUSH1 0x1f 0355 01 ADD 0356 60 PUSH1 0x20 0358 80 DUP1 0359 91 SWAP2 035A 04 DIV 035B 02 MUL 035C 60 PUSH1 0x20 035E 01 ADD 035F 60 PUSH1 0x40 0361 51 MLOAD 0362 90 SWAP1 0363 81 DUP2 0364 01 ADD 0365 60 PUSH1 0x40 0367 52 MSTORE 0368 80 DUP1 0369 92 SWAP3 036A 91 SWAP2 036B 90 SWAP1 036C 81 DUP2 036D 81 DUP2 036E 52 MSTORE 036F 60 PUSH1 0x20 0371 01 ADD 0372 82 DUP3 0373 80 DUP1 0374 54 SLOAD 0375 61 PUSH2 0x037d 0378 90 SWAP1 0379 61 PUSH2 0x1941 037C 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0367 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0369 stack[-2] = memory[0x40:0x60] // @036A stack[-1] = stack[-2] // @036B stack[0] = stack[-1] // @036E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0371 stack[1] = 0x20 + memory[0x40:0x60] // @0372 stack[2] = stack[-2] // @0378 stack[4] = storage[stack[-2]] // @0378 stack[3] = 0x037d // } // Block ends with call to 0x1941, returns to 0x037D label_037D: // Incoming return from call to 0x1941 at 0x037C // Inputs[1] { @037E stack[-1] } 037D 5B JUMPDEST 037E 80 DUP1 037F 15 ISZERO 0380 61 PUSH2 0x03ca 0383 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if !stack[-1] label_0384: // Incoming jump from 0x0383, if not !stack[-1] // Inputs[1] { @0384 stack[-1] } 0384 80 DUP1 0385 60 PUSH1 0x1f 0387 10 LT 0388 61 PUSH2 0x039f 038B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039f, if 0x1f < stack[-1] label_038C: // Incoming jump from 0x038B, if not 0x1f < stack[-1] // Inputs[4] // { // @0390 stack[-2] // @0391 storage[stack[-2]] // @0394 stack[-3] // @0396 stack[-1] // } 038C 61 PUSH2 0x0100 038F 80 DUP1 0390 83 DUP4 0391 54 SLOAD 0392 04 DIV 0393 02 MUL 0394 83 DUP4 0395 52 MSTORE 0396 91 SWAP2 0397 60 PUSH1 0x20 0399 01 ADD 039A 91 SWAP2 039B 61 PUSH2 0x03ca 039E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0395 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @039A stack[-1] = stack[-1] // @039A stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x03ca label_039F: // Incoming jump from 0x038B, if 0x1f < stack[-1] // Inputs[5] // { // @03A0 stack[-3] // @03A1 stack[-1] // @03A3 stack[-2] // @03AB memory[0x00:0x20] // @03AF storage[keccak256(memory[0x00:0x20])] // } 039F 5B JUMPDEST 03A0 82 DUP3 03A1 01 ADD 03A2 91 SWAP2 03A3 90 SWAP1 03A4 60 PUSH1 0x00 03A6 52 MSTORE 03A7 60 PUSH1 0x20 03A9 60 PUSH1 0x00 03AB 20 SHA3 03AC 90 SWAP1 03AD 5B JUMPDEST 03AE 81 DUP2 03AF 54 SLOAD 03B0 81 DUP2 03B1 52 MSTORE 03B2 90 SWAP1 03B3 60 PUSH1 0x01 03B5 01 ADD 03B6 90 SWAP1 03B7 60 PUSH1 0x20 03B9 01 ADD 03BA 80 DUP1 03BB 83 DUP4 03BC 11 GT 03BD 61 PUSH2 0x03ad 03C0 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @03A2 stack[-3] = stack[-3] + stack[-1] // @03A6 memory[0x00:0x20] = stack[-2] // @03B1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @03B6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @03B9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x03ad, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_03C1: // Incoming jump from 0x03C0, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x03C0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @03C1 stack[-3] // @03C2 stack[-1] // } 03C1 82 DUP3 03C2 90 SWAP1 03C3 03 SUB 03C4 60 PUSH1 0x1f 03C6 16 AND 03C7 82 DUP3 03C8 01 ADD 03C9 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @03C9 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @03C9 stack[-1] = stack[-3] // } // Block continues label_03CA: // Incoming jump from 0x03C9 // Incoming jump from 0x039E // Incoming jump from 0x0383, if !stack[-1] // Inputs[1] { @03D0 stack[-7] } 03CA 5B JUMPDEST 03CB 50 POP 03CC 50 POP 03CD 50 POP 03CE 50 POP 03CF 50 POP 03D0 81 DUP2 03D1 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_03D2: // Incoming jump from 0x014F // Inputs[1] { @03D5 stack[-1] } 03D2 5B JUMPDEST 03D3 60 PUSH1 0x60 03D5 81 DUP2 03D6 15 ISZERO 03D7 80 DUP1 03D8 61 PUSH2 0x03e1 03DB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @03D3 stack[0] = 0x60 // @03D6 stack[1] = !stack[-1] // } // Block ends with conditional jump to 0x03e1, if !stack[-1] label_03DC: // Incoming jump from 0x03DB, if not !stack[-1] // Inputs[1] { @03DF stack[-3] } 03DC 50 POP 03DD 60 PUSH1 0x0a 03DF 82 DUP3 03E0 11 GT 03E1 5B JUMPDEST 03E2 15 ISZERO 03E3 61 PUSH2 0x03fa 03E6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x03fa, if !(stack[-3] > 0x0a) label_03E7: // Incoming jump from 0x03E6, if not !(stack[-3] > 0x0a) // Incoming jump from 0x03E6, if not !stack[-1] // Inputs[2] // { // @03EC memory[0x40:0x60] // @03F8 stack[-3] // } 03E7 50 POP 03E8 50 POP 03E9 60 PUSH1 0x40 03EB 80 DUP1 03EC 51 MLOAD 03ED 60 PUSH1 0x20 03EF 81 DUP2 03F0 01 ADD 03F1 90 SWAP1 03F2 91 SWAP2 03F3 52 MSTORE 03F4 60 PUSH1 0x00 03F6 81 DUP2 03F7 52 MSTORE 03F8 90 SWAP1 03F9 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @03F3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @03F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @03F8 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_03FA: // Incoming jump from 0x03E6, if !(stack[-3] > 0x0a) // Incoming jump from 0x03E6, if !stack[-1] // Inputs[3] // { // @03FD stack[-2] // @0408 memory[0x00:0x40] // @040A storage[keccak256(memory[0x00:0x40])] // } 03FA 5B JUMPDEST 03FB 60 PUSH1 0x00 03FD 82 DUP3 03FE 81 DUP2 03FF 52 MSTORE 0400 60 PUSH1 0x08 0402 60 PUSH1 0x20 0404 52 MSTORE 0405 60 PUSH1 0x40 0407 90 SWAP1 0408 20 SHA3 0409 80 DUP1 040A 54 SLOAD 040B 61 PUSH2 0x033e 040E 91 SWAP2 040F 90 SWAP1 0410 61 PUSH2 0x0418 0413 90 SWAP1 0414 61 PUSH2 0x1941 0417 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @03FF memory[0x00:0x20] = stack[-2] // @0404 memory[0x20:0x40] = 0x08 // @040E stack[0] = 0x033e // @040F stack[1] = keccak256(memory[0x00:0x40]) // @0413 stack[2] = 0x0418 // @0413 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1941, returns to 0x0418 label_0418: // Incoming return from call to 0x1941 at 0x0417 // Inputs[4] // { // @0419 stack[-1] // @0428 memory[0x40:0x60] // @0430 stack[-2] // @043B storage[stack[-2]] // } 0418 5B JUMPDEST 0419 80 DUP1 041A 60 PUSH1 0x1f 041C 01 ADD 041D 60 PUSH1 0x20 041F 80 DUP1 0420 91 SWAP2 0421 04 DIV 0422 02 MUL 0423 60 PUSH1 0x20 0425 01 ADD 0426 60 PUSH1 0x40 0428 51 MLOAD 0429 90 SWAP1 042A 81 DUP2 042B 01 ADD 042C 60 PUSH1 0x40 042E 52 MSTORE 042F 80 DUP1 0430 92 SWAP3 0431 91 SWAP2 0432 90 SWAP1 0433 81 DUP2 0434 81 DUP2 0435 52 MSTORE 0436 60 PUSH1 0x20 0438 01 ADD 0439 82 DUP3 043A 80 DUP1 043B 54 SLOAD 043C 61 PUSH2 0x0444 043F 90 SWAP1 0440 61 PUSH2 0x1941 0443 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @042E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0430 stack[-2] = memory[0x40:0x60] // @0431 stack[-1] = stack[-2] // @0432 stack[0] = stack[-1] // @0435 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0438 stack[1] = 0x20 + memory[0x40:0x60] // @0439 stack[2] = stack[-2] // @043F stack[4] = storage[stack[-2]] // @043F stack[3] = 0x0444 // } // Block ends with call to 0x1941, returns to 0x0444 label_0444: // Incoming return from call to 0x1941 at 0x0443 // Inputs[1] { @0445 stack[-1] } 0444 5B JUMPDEST 0445 80 DUP1 0446 15 ISZERO 0447 61 PUSH2 0x0491 044A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0491, if !stack[-1] label_044B: // Incoming jump from 0x044A, if not !stack[-1] // Inputs[1] { @044B stack[-1] } 044B 80 DUP1 044C 60 PUSH1 0x1f 044E 10 LT 044F 61 PUSH2 0x0466 0452 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0466, if 0x1f < stack[-1] label_0453: // Incoming jump from 0x0452, if not 0x1f < stack[-1] // Inputs[4] // { // @0457 stack[-2] // @0458 storage[stack[-2]] // @045B stack[-3] // @045D stack[-1] // } 0453 61 PUSH2 0x0100 0456 80 DUP1 0457 83 DUP4 0458 54 SLOAD 0459 04 DIV 045A 02 MUL 045B 83 DUP4 045C 52 MSTORE 045D 91 SWAP2 045E 60 PUSH1 0x20 0460 01 ADD 0461 91 SWAP2 0462 61 PUSH2 0x0491 0465 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @045C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0461 stack[-1] = stack[-1] // @0461 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0491 label_0466: // Incoming jump from 0x0452, if 0x1f < stack[-1] // Inputs[5] // { // @0467 stack[-3] // @0468 stack[-1] // @046A stack[-2] // @0472 memory[0x00:0x20] // @0476 storage[keccak256(memory[0x00:0x20])] // } 0466 5B JUMPDEST 0467 82 DUP3 0468 01 ADD 0469 91 SWAP2 046A 90 SWAP1 046B 60 PUSH1 0x00 046D 52 MSTORE 046E 60 PUSH1 0x20 0470 60 PUSH1 0x00 0472 20 SHA3 0473 90 SWAP1 0474 5B JUMPDEST 0475 81 DUP2 0476 54 SLOAD 0477 81 DUP2 0478 52 MSTORE 0479 90 SWAP1 047A 60 PUSH1 0x01 047C 01 ADD 047D 90 SWAP1 047E 60 PUSH1 0x20 0480 01 ADD 0481 80 DUP1 0482 83 DUP4 0483 11 GT 0484 61 PUSH2 0x0474 0487 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0469 stack[-3] = stack[-3] + stack[-1] // @046D memory[0x00:0x20] = stack[-2] // @0478 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @047D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0480 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0474, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0488: // Incoming jump from 0x0487, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0487, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0488 stack[-3] // @0489 stack[-1] // } 0488 82 DUP3 0489 90 SWAP1 048A 03 SUB 048B 60 PUSH1 0x1f 048D 16 AND 048E 82 DUP3 048F 01 ADD 0490 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0490 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0490 stack[-1] = stack[-3] // } // Block continues label_0491: // Incoming jump from 0x044A, if !stack[-1] // Incoming jump from 0x0490 // Incoming jump from 0x0465 0491 5B JUMPDEST 0492 50 POP 0493 50 POP 0494 50 POP 0495 50 POP 0496 50 POP 0497 61 PUSH2 0x0935 049A 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x0935 049B 5B JUMPDEST 049C 60 PUSH1 0x01 049E 60 PUSH1 0x01 04A0 60 PUSH1 0xa0 04A2 1B SHL 04A3 03 SUB 04A4 85 DUP6 04A5 16 AND 04A6 33 CALLER 04A7 14 EQ 04A8 80 DUP1 04A9 61 PUSH2 0x04b7 04AC 57 *JUMPI 04AD 50 POP 04AE 61 PUSH2 0x04b7 04B1 85 DUP6 04B2 33 CALLER 04B3 61 PUSH2 0x0241 04B6 56 *JUMP 04B7 5B JUMPDEST 04B8 61 PUSH2 0x051e 04BB 57 *JUMPI 04BC 60 PUSH1 0x40 04BE 51 MLOAD 04BF 62 PUSH3 0x461bcd 04C3 60 PUSH1 0xe5 04C5 1B SHL 04C6 81 DUP2 04C7 52 MSTORE 04C8 60 PUSH1 0x20 04CA 60 PUSH1 0x04 04CC 82 DUP3 04CD 01 ADD 04CE 52 MSTORE 04CF 60 PUSH1 0x32 04D1 60 PUSH1 0x24 04D3 82 DUP3 04D4 01 ADD 04D5 52 MSTORE 04D6 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 04F7 60 PUSH1 0x44 04F9 82 DUP3 04FA 01 ADD 04FB 52 MSTORE 04FC 71 PUSH18 0x1bdddb995c881b9bdc88185c1c1c9bdd9959 050F 60 PUSH1 0x72 0511 1B SHL 0512 60 PUSH1 0x64 0514 82 DUP3 0515 01 ADD 0516 52 MSTORE 0517 60 PUSH1 0x84 0519 01 ADD 051A 61 PUSH2 0x02ea 051D 56 *JUMP 051E 5B JUMPDEST 051F 61 PUSH2 0x052b 0522 85 DUP6 0523 85 DUP6 0524 85 DUP6 0525 85 DUP6 0526 85 DUP6 0527 61 PUSH2 0x097f 052A 56 *JUMP label_052B: // Incoming return from call to 0x1114 at 0x0DE4 // Incoming return from call to 0x0DA6 at 0x08E4 // Incoming return from call to 0x115F at 0x1113 // Inputs[1] { @0531 stack[-6] } 052B 5B JUMPDEST 052C 50 POP 052D 50 POP 052E 50 POP 052F 50 POP 0530 50 POP 0531 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0532: // Incoming jump from 0x019E // Inputs[4] // { // @0535 stack[-1] // @0536 memory[stack[-1]:stack[-1] + 0x20] // @0537 stack[-2] // @0538 memory[stack[-2]:stack[-2] + 0x20] // } 0532 5B JUMPDEST 0533 60 PUSH1 0x60 0535 81 DUP2 0536 51 MLOAD 0537 83 DUP4 0538 51 MLOAD 0539 14 EQ 053A 61 PUSH2 0x0597 053D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0533 stack[0] = 0x60 } // Block ends with conditional jump to 0x0597, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_053E: // Incoming jump from 0x053D, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0540 memory[0x40:0x60] } 053E 60 PUSH1 0x40 0540 51 MLOAD 0541 62 PUSH3 0x461bcd 0545 60 PUSH1 0xe5 0547 1B SHL 0548 81 DUP2 0549 52 MSTORE 054A 60 PUSH1 0x20 054C 60 PUSH1 0x04 054E 82 DUP3 054F 01 ADD 0550 52 MSTORE 0551 60 PUSH1 0x29 0553 60 PUSH1 0x24 0555 82 DUP3 0556 01 ADD 0557 52 MSTORE 0558 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 0579 60 PUSH1 0x44 057B 82 DUP3 057C 01 ADD 057D 52 MSTORE 057E 68 PUSH9 0x040dad2e6dac2e8c6d 0588 60 PUSH1 0xbb 058A 1B SHL 058B 60 PUSH1 0x64 058D 82 DUP3 058E 01 ADD 058F 52 MSTORE 0590 60 PUSH1 0x84 0592 01 ADD 0593 61 PUSH2 0x02ea 0596 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0549 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0550 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0557 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @057D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @058F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x040dad2e6dac2e8c6d << 0xbb // @0592 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ea label_0597: // Incoming jump from 0x053D, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @059A stack[-3] // @059B memory[stack[-3]:stack[-3] + 0x20] // } 0597 5B JUMPDEST 0598 60 PUSH1 0x00 059A 83 DUP4 059B 51 MLOAD 059C 60 PUSH1 0x01 059E 60 PUSH1 0x01 05A0 60 PUSH1 0x40 05A2 1B SHL 05A3 03 SUB 05A4 81 DUP2 05A5 11 GT 05A6 15 ISZERO 05A7 61 PUSH2 0x05b2 05AA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0598 stack[0] = 0x00 // @059B stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x05b2, if !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_05AB: // Incoming jump from 0x05AA, if not !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) 05AB 61 PUSH2 0x05b2 05AE 61 PUSH2 0x1a19 05B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @05AB stack[0] = 0x05b2 } // Block ends with unconditional jump to 0x1a19 label_05B2: // Incoming jump from 0x05AA, if !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @05B5 memory[0x40:0x60] // @05B6 stack[-1] // } 05B2 5B JUMPDEST 05B3 60 PUSH1 0x40 05B5 51 MLOAD 05B6 90 SWAP1 05B7 80 DUP1 05B8 82 DUP3 05B9 52 MSTORE 05BA 80 DUP1 05BB 60 PUSH1 0x20 05BD 02 MUL 05BE 60 PUSH1 0x20 05C0 01 ADD 05C1 82 DUP3 05C2 01 ADD 05C3 60 PUSH1 0x40 05C5 52 MSTORE 05C6 80 DUP1 05C7 15 ISZERO 05C8 61 PUSH2 0x05db 05CB 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @05B6 stack[-1] = memory[0x40:0x60] // @05B6 stack[0] = stack[-1] // @05B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05C5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x05db, if !stack[-1] label_05CC: // Incoming jump from 0x05CB, if not !stack[-1] // Inputs[7] // { // @05CC stack[-2] // @05D2 stack[-1] // @05D5 msg.data.length // @05D7 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @05DD stack[-3] // @05E2 stack[-6] // @05E3 memory[stack[-6]:stack[-6] + 0x20] // } 05CC 81 DUP2 05CD 60 PUSH1 0x20 05CF 01 ADD 05D0 60 PUSH1 0x20 05D2 82 DUP3 05D3 02 MUL 05D4 80 DUP1 05D5 36 CALLDATASIZE 05D6 83 DUP4 05D7 37 CALLDATACOPY 05D8 01 ADD 05D9 90 SWAP1 05DA 50 POP 05DB 5B JUMPDEST 05DC 50 POP 05DD 90 SWAP1 05DE 50 POP 05DF 60 PUSH1 0x00 05E1 5B JUMPDEST 05E2 84 DUP5 05E3 51 MLOAD 05E4 81 DUP2 05E5 10 LT 05E6 15 ISZERO 05E7 61 PUSH2 0x0653 05EA 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @05D7 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @05DD stack[-3] = stack[-2] // @05DF stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0653, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_05EB: // Incoming jump from 0x05EA, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x05EA, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x05EA, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @05EE stack[-5] // @05EF stack[-1] // @05F1 memory[stack[-5]:stack[-5] + 0x20] // } 05EB 61 PUSH2 0x0626 05EE 85 DUP6 05EF 82 DUP3 05F0 81 DUP2 05F1 51 MLOAD 05F2 81 DUP2 05F3 10 LT 05F4 61 PUSH2 0x05ff 05F7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05EB stack[0] = 0x0626 // @05EE stack[1] = stack[-5] // @05EF stack[2] = stack[-1] // } // Block ends with conditional call to 0x05ff, returns to 0x0626, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_05F8: // Incoming jump from 0x05F7, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 05F8 61 PUSH2 0x05ff 05FB 61 PUSH2 0x1a03 05FE 56 *JUMP // Stack delta = +1 // Outputs[1] { @05F8 stack[0] = 0x05ff } // Block ends with unconditional jump to 0x1a03 label_05FF: // Incoming call from 0x05F7, returns to 0x0626, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @0602 stack[-1] // @0606 stack[-2] // @0607 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0608 stack[-7] // @0609 stack[-4] // @060B memory[stack[-7]:stack[-7] + 0x20] // } 05FF 5B JUMPDEST 0600 60 PUSH1 0x20 0602 02 MUL 0603 60 PUSH1 0x20 0605 01 ADD 0606 01 ADD 0607 51 MLOAD 0608 85 DUP6 0609 83 DUP4 060A 81 DUP2 060B 51 MLOAD 060C 81 DUP2 060D 10 LT 060E 61 PUSH2 0x0619 0611 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0607 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0608 stack[-1] = stack[-7] // @0609 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0619, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_0612: // Incoming jump from 0x0611, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 0612 61 PUSH2 0x0619 0615 61 PUSH2 0x1a03 0618 56 *JUMP // Stack delta = +1 // Outputs[1] { @0612 stack[0] = 0x0619 } // Block ends with unconditional jump to 0x1a03 label_0619: // Incoming jump from 0x0611, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @061C stack[-1] // @0620 stack[-2] // @0621 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0619 5B JUMPDEST 061A 60 PUSH1 0x20 061C 02 MUL 061D 60 PUSH1 0x20 061F 01 ADD 0620 01 ADD 0621 51 MLOAD 0622 61 PUSH2 0x0282 0625 56 *JUMP // Stack delta = -1 // Outputs[1] { @0621 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0282 label_0626: // Incoming return from call to 0x05FF at 0x05F7 // Inputs[3] // { // @0627 stack[-3] // @0628 stack[-2] // @062A memory[stack[-3]:stack[-3] + 0x20] // } 0626 5B JUMPDEST 0627 82 DUP3 0628 82 DUP3 0629 81 DUP2 062A 51 MLOAD 062B 81 DUP2 062C 10 LT 062D 61 PUSH2 0x0638 0630 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0627 stack[0] = stack[-3] // @0628 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0638, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0631: // Incoming jump from 0x0630, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 0631 61 PUSH2 0x0638 0634 61 PUSH2 0x1a03 0637 56 *JUMP // Stack delta = +1 // Outputs[1] { @0631 stack[0] = 0x0638 } // Block ends with unconditional jump to 0x1a03 label_0638: // Incoming jump from 0x0630, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @063B stack[-1] // @063E stack[-2] // @0643 stack[-3] // @0647 stack[-4] // } 0638 5B JUMPDEST 0639 60 PUSH1 0x20 063B 90 SWAP1 063C 81 DUP2 063D 02 MUL 063E 91 SWAP2 063F 90 SWAP1 0640 91 SWAP2 0641 01 ADD 0642 01 ADD 0643 52 MSTORE 0644 61 PUSH2 0x064c 0647 81 DUP2 0648 61 PUSH2 0x19a8 064B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0643 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0644 stack[-3] = 0x064c // @0647 stack[-2] = stack[-4] // } // Block ends with call to 0x19a8, returns to 0x064C label_064C: // Incoming return from call to 0x19A8 at 0x064B // Inputs[2] // { // @064D stack[-2] // @064D stack[-1] // } 064C 5B JUMPDEST 064D 90 SWAP1 064E 50 POP 064F 61 PUSH2 0x05e1 0652 56 *JUMP // Stack delta = -1 // Outputs[1] { @064D stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x05e1 label_0653: // Incoming jump from 0x05EA, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x05EA, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x05EA, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @0655 stack[-2] // @0655 stack[-6] // @0656 stack[-5] // } 0653 5B JUMPDEST 0654 50 POP 0655 93 SWAP4 0656 92 SWAP3 0657 50 POP 0658 50 POP 0659 50 POP 065A 56 *JUMP // Stack delta = -5 // Outputs[1] { @0655 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_065B: // Incoming jump from 0x01B3 // Inputs[1] { @065C msg.sender } 065B 5B JUMPDEST 065C 33 CALLER 065D 61 PUSH2 0x0665 0660 81 DUP2 0661 61 PUSH2 0x0b5c 0664 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @065C stack[0] = msg.sender // @065D stack[1] = 0x0665 // @0660 stack[2] = msg.sender // } // Block ends with call to 0x0b5c, returns to 0x0665 label_0665: // Incoming return from call to 0x0B5C at 0x0664 // Inputs[1] { @066B block.timestamp } 0665 5B JUMPDEST 0666 60 PUSH1 0x00 0668 61 PUSH2 0x0670 066B 42 TIMESTAMP 066C 61 PUSH2 0x0c36 066F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0666 stack[0] = 0x00 // @0668 stack[1] = 0x0670 // @066B stack[2] = block.timestamp // } // Block ends with call to 0x0c36, returns to 0x0670 label_0670: // Incoming return from call to 0x0C36 at 0x066F // Incoming return from call to 0x0C36 at 0x066F // Incoming return from call to 0x0C36 at 0x066F // Inputs[4] // { // @0674 memory[0x40:0x60] // @0680 stack[-1] // @0681 stack[-2] // @0687 stack[-3] // } 0670 5B JUMPDEST 0671 60 PUSH1 0x40 0673 80 DUP1 0674 51 MLOAD 0675 60 PUSH1 0x00 0677 81 DUP2 0678 52 MSTORE 0679 60 PUSH1 0x20 067B 81 DUP2 067C 01 ADD 067D 90 SWAP1 067E 91 SWAP2 067F 52 MSTORE 0680 90 SWAP1 0681 91 SWAP2 0682 50 POP 0683 61 PUSH2 0x0692 0686 90 SWAP1 0687 83 DUP4 0688 90 SWAP1 0689 83 DUP4 068A 90 SWAP1 068B 60 PUSH1 0x01 068D 90 SWAP1 068E 61 PUSH2 0x0d71 0691 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @0678 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @067F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0681 stack[-2] = stack[-1] // @0686 stack[-1] = 0x0692 // @0688 stack[0] = stack[-3] // @068A stack[1] = stack[-1] // @068D stack[2] = 0x01 // @068D stack[3] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0d71 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 16 AND 069D 60 PUSH1 0x00 069F 90 SWAP1 06A0 81 DUP2 06A1 52 MSTORE 06A2 60 PUSH1 0x04 06A4 60 PUSH1 0x20 06A6 52 MSTORE 06A7 60 PUSH1 0x40 06A9 90 SWAP1 06AA 20 SHA3 06AB 80 DUP1 06AC 54 SLOAD 06AD 60 PUSH1 0xff 06AF 19 NOT 06B0 16 AND 06B1 60 PUSH1 0x01 06B3 17 OR 06B4 90 SWAP1 06B5 55 SSTORE 06B6 56 *JUMP label_06B7: // Incoming jump from 0x01C6 // Inputs[1] { @06BE stack[-1] } 06B7 5B JUMPDEST 06B8 60 PUSH1 0x00 06BA 80 DUP1 06BB 61 PUSH2 0x06c3 06BE 83 DUP4 06BF 61 PUSH2 0x083f 06C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06B8 stack[0] = 0x00 // @06BA stack[1] = 0x00 // @06BB stack[2] = 0x06c3 // @06BE stack[3] = stack[-1] // } // Block ends with call to 0x083f, returns to 0x06C3 label_06C3: // Incoming return from call to 0x083F at 0x06C2 // Inputs[4] // { // @06C4 stack[-1] // @06C4 stack[-2] // @06C5 stack[-5] // @06C6 stack[-4] // } 06C3 5B JUMPDEST 06C4 11 GT 06C5 92 SWAP3 06C6 91 SWAP2 06C7 50 POP 06C8 50 POP 06C9 56 *JUMP // Stack delta = -4 // Outputs[1] { @06C5 stack[-5] = stack[-1] > stack[-2] } // Block ends with unconditional jump to stack[-5] label_06CA: // Incoming jump from 0x01D9 // Inputs[1] { @06CD stack[-1] } 06CA 5B JUMPDEST 06CB 60 PUSH1 0x00 06CD 81 DUP2 06CE 15 ISZERO 06CF 80 DUP1 06D0 61 PUSH2 0x06d9 06D3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @06CB stack[0] = 0x00 // @06CE stack[1] = !stack[-1] // } // Block ends with conditional jump to 0x06d9, if !stack[-1] label_06D4: // Incoming jump from 0x06D3, if not !stack[-1] // Inputs[1] { @06D7 stack[-3] } 06D4 50 POP 06D5 60 PUSH1 0x0a 06D7 82 DUP3 06D8 11 GT 06D9 5B JUMPDEST 06DA 15 ISZERO 06DB 61 PUSH2 0x06e6 06DE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06e6, if !(stack[-3] > 0x0a) label_06DF: // Incoming jump from 0x06DE, if not !(stack[-3] > 0x0a) // Incoming jump from 0x06DE, if not !stack[-1] // Inputs[2] // { // @06E2 stack[-3] // @06E3 stack[-2] // } 06DF 50 POP 06E0 60 PUSH1 0x00 06E2 91 SWAP2 06E3 90 SWAP1 06E4 50 POP 06E5 56 *JUMP // Stack delta = -2 // Outputs[1] { @06E2 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_06E6: // Incoming jump from 0x06DE, if !(stack[-3] > 0x0a) // Incoming jump from 0x06DE, if !stack[-1] // Inputs[1] { @072E stack[-2] } 06E6 5B JUMPDEST 06E7 7F PUSH32 0x00000000000000000000000000000000000000000000000000000000000003e8 0708 7F PUSH32 0x013333338d8d8d8d8d8d00000000000000000000000000000000000000000000 0729 61 PUSH2 0x0733 072C 60 PUSH1 0x01 072E 85 DUP6 072F 61 PUSH2 0x18e3 0732 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @06E7 stack[0] = 0x00000000000000000000000000000000000000000000000000000000000003e8 // @0708 stack[1] = 0x013333338d8d8d8d8d8d00000000000000000000000000000000000000000000 // @0729 stack[2] = 0x0733 // @072C stack[3] = 0x01 // @072E stack[4] = stack[-2] // } // Block ends with call to 0x18e3, returns to 0x0733 label_0733: // Incoming return from call to 0x18E3 at 0x0732 // Inputs[1] { @0736 stack[-1] } 0733 5B JUMPDEST 0734 60 PUSH1 0x0a 0736 81 DUP2 0737 10 LT 0738 61 PUSH2 0x0743 073B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0743, if stack[-1] < 0x0a label_073C: // Incoming jump from 0x073B, if not stack[-1] < 0x0a 073C 61 PUSH2 0x0743 073F 61 PUSH2 0x1a03 0742 56 *JUMP // Stack delta = +1 // Outputs[1] { @073C stack[0] = 0x0743 } // Block ends with unconditional jump to 0x1a03 label_0743: // Incoming jump from 0x073B, if stack[-1] < 0x0a // Inputs[2] // { // @0747 stack[-2] // @0748 stack[-1] // } 0743 5B JUMPDEST 0744 61 PUSH2 0x0751 0747 91 SWAP2 0748 90 SWAP1 0749 1A BYTE 074A 61 PUSH2 0x03e8 074D 61 PUSH2 0x18c4 0750 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0747 stack[-2] = 0x0751 // @0749 stack[-1] = byte(stack[-2], stack[-1]) // @074A stack[0] = 0x03e8 // } // Block ends with call to 0x18c4, returns to 0x0751 label_0751: // Incoming return from call to 0x18C4 at 0x0750 // Inputs[2] // { // @0755 stack[-2] // @0756 stack[-1] // } 0751 5B JUMPDEST 0752 61 PUSH2 0x033e 0755 91 SWAP2 0756 90 SWAP1 0757 61 PUSH2 0x18b0 075A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0755 stack[-2] = 0x033e // @0756 stack[-1] = stack[-2] // @0756 stack[0] = stack[-1] // } // Block ends with call to 0x18b0, returns to 0x033E label_075B: // Incoming call from 0x01E1, returns to 0x0130 // Inputs[1] { @075F storage[0x06] } 075B 5B JUMPDEST 075C 60 PUSH1 0x06 075E 80 DUP1 075F 54 SLOAD 0760 61 PUSH2 0x0351 0763 90 SWAP1 0764 61 PUSH2 0x1941 0767 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @075C stack[0] = 0x06 // @0763 stack[1] = 0x0351 // @0763 stack[2] = storage[0x06] // } // Block ends with call to 0x1941, returns to 0x0351 label_0768: // Incoming jump from 0x01F4 // Inputs[2] // { // @0769 msg.sender // @0772 stack[-2] // } 0768 5B JUMPDEST 0769 33 CALLER 076A 60 PUSH1 0x01 076C 60 PUSH1 0x01 076E 60 PUSH1 0xa0 0770 1B SHL 0771 03 SUB 0772 83 DUP4 0773 16 AND 0774 14 EQ 0775 15 ISZERO 0776 61 PUSH2 0x07d3 0779 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07d3, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) label_077A: // Incoming jump from 0x0779, if not !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[1] { @077C memory[0x40:0x60] } 077A 60 PUSH1 0x40 077C 51 MLOAD 077D 62 PUSH3 0x461bcd 0781 60 PUSH1 0xe5 0783 1B SHL 0784 81 DUP2 0785 52 MSTORE 0786 60 PUSH1 0x20 0788 60 PUSH1 0x04 078A 82 DUP3 078B 01 ADD 078C 52 MSTORE 078D 60 PUSH1 0x29 078F 60 PUSH1 0x24 0791 82 DUP3 0792 01 ADD 0793 52 MSTORE 0794 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 07B5 60 PUSH1 0x44 07B7 82 DUP3 07B8 01 ADD 07B9 52 MSTORE 07BA 68 PUSH9 0x103337b91039b2b633 07C4 60 PUSH1 0xb9 07C6 1B SHL 07C7 60 PUSH1 0x64 07C9 82 DUP3 07CA 01 ADD 07CB 52 MSTORE 07CC 60 PUSH1 0x84 07CE 01 ADD 07CF 61 PUSH2 0x02ea 07D2 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0785 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @078C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0793 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @07B9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @07CB memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103337b91039b2b633 << 0xb9 // @07CE stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ea label_07D3: // Incoming jump from 0x0779, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[10] // { // @07D4 msg.sender // @07E5 memory[0x00:0x40] // @07EE stack[-2] // @07F9 memory[0x00:0x40] // @07FB storage[keccak256(memory[0x00:0x40])] // @0800 stack[-1] // @080A memory[0x40:0x60] // @0836 memory[0x40:0x60] // @083B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @083E stack[-3] // } 07D3 5B JUMPDEST 07D4 33 CALLER 07D5 60 PUSH1 0x00 07D7 81 DUP2 07D8 81 DUP2 07D9 52 MSTORE 07DA 60 PUSH1 0x01 07DC 60 PUSH1 0x20 07DE 90 SWAP1 07DF 81 DUP2 07E0 52 MSTORE 07E1 60 PUSH1 0x40 07E3 80 DUP1 07E4 83 DUP4 07E5 20 SHA3 07E6 60 PUSH1 0x01 07E8 60 PUSH1 0x01 07EA 60 PUSH1 0xa0 07EC 1B SHL 07ED 03 SUB 07EE 87 DUP8 07EF 16 AND 07F0 80 DUP1 07F1 85 DUP6 07F2 52 MSTORE 07F3 90 SWAP1 07F4 83 DUP4 07F5 52 MSTORE 07F6 92 SWAP3 07F7 81 DUP2 07F8 90 SWAP1 07F9 20 SHA3 07FA 80 DUP1 07FB 54 SLOAD 07FC 60 PUSH1 0xff 07FE 19 NOT 07FF 16 AND 0800 86 DUP7 0801 15 ISZERO 0802 15 ISZERO 0803 90 SWAP1 0804 81 DUP2 0805 17 OR 0806 90 SWAP1 0807 91 SWAP2 0808 55 SSTORE 0809 90 SWAP1 080A 51 MLOAD 080B 90 SWAP1 080C 81 DUP2 080D 52 MSTORE 080E 91 SWAP2 080F 92 SWAP3 0810 91 SWAP2 0811 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0832 91 SWAP2 0833 01 ADD 0834 60 PUSH1 0x40 0836 51 MLOAD 0837 80 DUP1 0838 91 SWAP2 0839 03 SUB 083A 90 SWAP1 083B A3 LOG3 083C 50 POP 083D 50 POP 083E 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @07D9 memory[0x00:0x20] = msg.sender // @07E0 memory[0x20:0x40] = 0x01 // @07F2 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @07F5 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0808 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @080D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @083B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_083F: // Incoming call from 0x0D43, returns to 0x0D44 // Incoming call from 0x06C2, returns to 0x06C3 // Incoming jump from 0x0207 // Inputs[4] // { // @0842 stack[-1] // @084D memory[0x00:0x40] // @084E storage[keccak256(memory[0x00:0x40])] // @084F stack[-2] // } 083F 5B JUMPDEST 0840 60 PUSH1 0x00 0842 90 SWAP1 0843 81 DUP2 0844 52 MSTORE 0845 60 PUSH1 0x03 0847 60 PUSH1 0x20 0849 52 MSTORE 084A 60 PUSH1 0x40 084C 90 SWAP1 084D 20 SHA3 084E 54 SLOAD 084F 90 SWAP1 0850 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0844 memory[0x00:0x20] = stack[-1] // @0849 memory[0x20:0x40] = 0x03 // @084F stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0851: // Incoming call from 0x0232, returns to 0x0130 // Inputs[1] { @0855 storage[0x07] } 0851 5B JUMPDEST 0852 60 PUSH1 0x07 0854 80 DUP1 0855 54 SLOAD 0856 61 PUSH2 0x0351 0859 90 SWAP1 085A 61 PUSH2 0x1941 085D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0852 stack[0] = 0x07 // @0859 stack[1] = 0x0351 // @0859 stack[2] = storage[0x07] // } // Block ends with call to 0x1941, returns to 0x0351 label_085E: // Incoming jump from 0x0281 // Inputs[2] // { // @0867 stack[-5] // @0869 msg.sender // } 085E 5B JUMPDEST 085F 60 PUSH1 0x01 0861 60 PUSH1 0x01 0863 60 PUSH1 0xa0 0865 1B SHL 0866 03 SUB 0867 85 DUP6 0868 16 AND 0869 33 CALLER 086A 14 EQ 086B 80 DUP1 086C 61 PUSH2 0x087a 086F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @086A stack[0] = msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x087a, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 label_0870: // Incoming jump from 0x086F, if not msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0874 stack[-6] // @0875 msg.sender // } 0870 50 POP 0871 61 PUSH2 0x087a 0874 85 DUP6 0875 33 CALLER 0876 61 PUSH2 0x0241 0879 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0871 stack[-1] = 0x087a // @0874 stack[0] = stack[-6] // @0875 stack[1] = msg.sender // } // Block ends with call to 0x0241, returns to 0x087A label_087A: // Incoming jump from 0x086F, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0241 at 0x0879 // Inputs[1] { @087E stack[-1] } 087A 5B JUMPDEST 087B 61 PUSH2 0x08d8 087E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08d8, if stack[-1] label_087F: // Incoming jump from 0x087E, if not stack[-1] // Inputs[1] { @0881 memory[0x40:0x60] } 087F 60 PUSH1 0x40 0881 51 MLOAD 0882 62 PUSH3 0x461bcd 0886 60 PUSH1 0xe5 0888 1B SHL 0889 81 DUP2 088A 52 MSTORE 088B 60 PUSH1 0x20 088D 60 PUSH1 0x04 088F 82 DUP3 0890 01 ADD 0891 52 MSTORE 0892 60 PUSH1 0x29 0894 60 PUSH1 0x24 0896 82 DUP3 0897 01 ADD 0898 52 MSTORE 0899 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 08BA 60 PUSH1 0x44 08BC 82 DUP3 08BD 01 ADD 08BE 52 MSTORE 08BF 68 PUSH9 0x08185c1c1c9bdd9959 08C9 60 PUSH1 0xba 08CB 1B SHL 08CC 60 PUSH1 0x64 08CE 82 DUP3 08CF 01 ADD 08D0 52 MSTORE 08D1 60 PUSH1 0x84 08D3 01 ADD 08D4 61 PUSH2 0x02ea 08D7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @088A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0891 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0898 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @08BE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 // @08D0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x08185c1c1c9bdd9959 << 0xba // @08D3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ea label_08D8: // Incoming jump from 0x087E, if stack[-1] // Inputs[5] // { // @08DC stack[-5] // @08DD stack[-4] // @08DE stack[-3] // @08DF stack[-2] // @08E0 stack[-1] // } 08D8 5B JUMPDEST 08D9 61 PUSH2 0x052b 08DC 85 DUP6 08DD 85 DUP6 08DE 85 DUP6 08DF 85 DUP6 08E0 85 DUP6 08E1 61 PUSH2 0x0da6 08E4 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @08D9 stack[0] = 0x052b // @08DC stack[1] = stack[-5] // @08DD stack[2] = stack[-4] // @08DE stack[3] = stack[-3] // @08DF stack[4] = stack[-2] // @08E0 stack[5] = stack[-1] // } // Block ends with call to 0x0da6, returns to 0x052B label_08E5: // Incoming call from 0x033D, returns to 0x033E // Inputs[1] { @08F1 stack[-1] } 08E5 5B JUMPDEST 08E6 60 PUSH1 0x00 08E8 60 PUSH1 0x01 08EA 60 PUSH1 0x01 08EC 60 PUSH1 0xe0 08EE 1B SHL 08EF 03 SUB 08F0 19 NOT 08F1 82 DUP3 08F2 16 AND 08F3 63 PUSH4 0x6cdb3d13 08F8 60 PUSH1 0xe1 08FA 1B SHL 08FB 14 EQ 08FC 80 DUP1 08FD 61 PUSH2 0x0916 0900 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @08E6 stack[0] = 0x00 // @08FB stack[1] = 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0916, if 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0901: // Incoming jump from 0x0900, if not 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @090B stack[-3] } 0901 50 POP 0902 60 PUSH1 0x01 0904 60 PUSH1 0x01 0906 60 PUSH1 0xe0 0908 1B SHL 0909 03 SUB 090A 19 NOT 090B 82 DUP3 090C 16 AND 090D 63 PUSH4 0x03a24d07 0912 60 PUSH1 0xe2 0914 1B SHL 0915 14 EQ 0916 5B JUMPDEST 0917 80 DUP1 0918 61 PUSH2 0x033e 091B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0915 stack[-1] = 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x033e, if 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_091C: // Incoming jump from 0x091B, if not 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x091B, if not stack[-1] // Inputs[1] { @092E stack[-3] } 091C 50 POP 091D 63 PUSH4 0x01ffc9a7 0922 60 PUSH1 0xe0 0924 1B SHL 0925 60 PUSH1 0x01 0927 60 PUSH1 0x01 0929 60 PUSH1 0xe0 092B 1B SHL 092C 03 SUB 092D 19 NOT 092E 83 DUP4 092F 16 AND 0930 14 EQ 0931 61 PUSH2 0x033e 0934 56 *JUMP // Stack delta = +0 // Outputs[1] { @0930 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x033e label_0935: // Incoming jump from 0x049A // Inputs[3] // { // @093A memory[0x40:0x60] // @0958 stack[-1] // @095B memory[0x40:0x60] // } 0935 5B JUMPDEST 0936 60 PUSH1 0x60 0938 60 PUSH1 0x40 093A 51 MLOAD 093B 80 DUP1 093C 60 PUSH1 0x40 093E 01 ADD 093F 60 PUSH1 0x40 0941 52 MSTORE 0942 80 DUP1 0943 60 PUSH1 0x07 0945 81 DUP2 0946 52 MSTORE 0947 60 PUSH1 0x20 0949 01 ADD 094A 66 PUSH7 0x697066733a2f2f 0952 60 PUSH1 0xc8 0954 1B SHL 0955 81 DUP2 0956 52 MSTORE 0957 50 POP 0958 82 DUP3 0959 60 PUSH1 0x40 095B 51 MLOAD 095C 60 PUSH1 0x20 095E 01 ADD 095F 61 PUSH2 0x0969 0962 92 SWAP3 0963 91 SWAP2 0964 90 SWAP1 0965 61 PUSH2 0x1681 0968 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @0936 stack[0] = 0x60 // @0941 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0946 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x07 // @0956 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x697066733a2f2f << 0xc8 // @0962 stack[1] = 0x0969 // @0963 stack[2] = memory[0x40:0x60] // @0964 stack[3] = stack[-1] // @0964 stack[4] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x1681, returns to 0x0969 label_0969: // Incoming return from call to 0x1681 at 0x0968 // Inputs[5] // { // @096C memory[0x40:0x60] // @0970 stack[-1] // @0979 stack[-2] // @097B stack[-4] // @097C stack[-3] // } 0969 5B JUMPDEST 096A 60 PUSH1 0x40 096C 51 MLOAD 096D 60 PUSH1 0x20 096F 81 DUP2 0970 83 DUP4 0971 03 SUB 0972 03 SUB 0973 81 DUP2 0974 52 MSTORE 0975 90 SWAP1 0976 60 PUSH1 0x40 0978 52 MSTORE 0979 90 SWAP1 097A 50 POP 097B 91 SWAP2 097C 90 SWAP1 097D 50 POP 097E 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0974 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0978 memory[0x40:0x60] = stack[-1] // @097B stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] 097F 5B JUMPDEST 0980 81 DUP2 0981 51 MLOAD 0982 83 DUP4 0983 51 MLOAD 0984 14 EQ 0985 61 PUSH2 0x09e1 0988 57 *JUMPI 0989 60 PUSH1 0x40 098B 51 MLOAD 098C 62 PUSH3 0x461bcd 0990 60 PUSH1 0xe5 0992 1B SHL 0993 81 DUP2 0994 52 MSTORE 0995 60 PUSH1 0x20 0997 60 PUSH1 0x04 0999 82 DUP3 099A 01 ADD 099B 52 MSTORE 099C 60 PUSH1 0x28 099E 60 PUSH1 0x24 09A0 82 DUP3 09A1 01 ADD 09A2 52 MSTORE 09A3 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 09C4 60 PUSH1 0x44 09C6 82 DUP3 09C7 01 ADD 09C8 52 MSTORE 09C9 67 PUSH8 0x0dad2e6dac2e8c6d 09D2 60 PUSH1 0xc3 09D4 1B SHL 09D5 60 PUSH1 0x64 09D7 82 DUP3 09D8 01 ADD 09D9 52 MSTORE 09DA 60 PUSH1 0x84 09DC 01 ADD 09DD 61 PUSH2 0x02ea 09E0 56 *JUMP 09E1 5B JUMPDEST 09E2 60 PUSH1 0x01 09E4 60 PUSH1 0x01 09E6 60 PUSH1 0xa0 09E8 1B SHL 09E9 03 SUB 09EA 84 DUP5 09EB 16 AND 09EC 61 PUSH2 0x0a07 09EF 57 *JUMPI 09F0 60 PUSH1 0x40 09F2 51 MLOAD 09F3 62 PUSH3 0x461bcd 09F7 60 PUSH1 0xe5 09F9 1B SHL 09FA 81 DUP2 09FB 52 MSTORE 09FC 60 PUSH1 0x04 09FE 01 ADD 09FF 61 PUSH2 0x02ea 0A02 90 SWAP1 0A03 61 PUSH2 0x17e6 0A06 56 *JUMP 0A07 5B JUMPDEST 0A08 33 CALLER 0A09 60 PUSH1 0x00 0A0B 5B JUMPDEST 0A0C 84 DUP5 0A0D 51 MLOAD 0A0E 81 DUP2 0A0F 10 LT 0A10 15 ISZERO 0A11 61 PUSH2 0x0aee 0A14 57 *JUMPI 0A15 60 PUSH1 0x00 0A17 85 DUP6 0A18 82 DUP3 0A19 81 DUP2 0A1A 51 MLOAD 0A1B 81 DUP2 0A1C 10 LT 0A1D 61 PUSH2 0x0a28 0A20 57 *JUMPI 0A21 61 PUSH2 0x0a28 0A24 61 PUSH2 0x1a03 0A27 56 *JUMP 0A28 5B JUMPDEST 0A29 60 PUSH1 0x20 0A2B 02 MUL 0A2C 60 PUSH1 0x20 0A2E 01 ADD 0A2F 01 ADD 0A30 51 MLOAD 0A31 90 SWAP1 0A32 50 POP 0A33 60 PUSH1 0x00 0A35 85 DUP6 0A36 83 DUP4 0A37 81 DUP2 0A38 51 MLOAD 0A39 81 DUP2 0A3A 10 LT 0A3B 61 PUSH2 0x0a46 0A3E 57 *JUMPI 0A3F 61 PUSH2 0x0a46 0A42 61 PUSH2 0x1a03 0A45 56 *JUMP 0A46 5B JUMPDEST 0A47 60 PUSH1 0x20 0A49 90 SWAP1 0A4A 81 DUP2 0A4B 02 MUL 0A4C 91 SWAP2 0A4D 90 SWAP1 0A4E 91 SWAP2 0A4F 01 ADD 0A50 81 DUP2 0A51 01 ADD 0A52 51 MLOAD 0A53 60 PUSH1 0x00 0A55 84 DUP5 0A56 81 DUP2 0A57 52 MSTORE 0A58 80 DUP1 0A59 83 DUP4 0A5A 52 MSTORE 0A5B 60 PUSH1 0x40 0A5D 80 DUP1 0A5E 82 DUP3 0A5F 20 SHA3 0A60 60 PUSH1 0x01 0A62 60 PUSH1 0x01 0A64 60 PUSH1 0xa0 0A66 1B SHL 0A67 03 SUB 0A68 8E DUP15 0A69 16 AND 0A6A 83 DUP4 0A6B 52 MSTORE 0A6C 90 SWAP1 0A6D 93 SWAP4 0A6E 52 MSTORE 0A6F 91 SWAP2 0A70 90 SWAP1 0A71 91 SWAP2 0A72 20 SHA3 0A73 54 SLOAD 0A74 90 SWAP1 0A75 91 SWAP2 0A76 50 POP 0A77 81 DUP2 0A78 81 DUP2 0A79 10 LT 0A7A 15 ISZERO 0A7B 61 PUSH2 0x0a96 0A7E 57 *JUMPI 0A7F 60 PUSH1 0x40 0A81 51 MLOAD 0A82 62 PUSH3 0x461bcd 0A86 60 PUSH1 0xe5 0A88 1B SHL 0A89 81 DUP2 0A8A 52 MSTORE 0A8B 60 PUSH1 0x04 0A8D 01 ADD 0A8E 61 PUSH2 0x02ea 0A91 90 SWAP1 0A92 61 PUSH2 0x182b 0A95 56 *JUMP 0A96 5B JUMPDEST 0A97 60 PUSH1 0x00 0A99 83 DUP4 0A9A 81 DUP2 0A9B 52 MSTORE 0A9C 60 PUSH1 0x20 0A9E 81 DUP2 0A9F 81 DUP2 0AA0 52 MSTORE 0AA1 60 PUSH1 0x40 0AA3 80 DUP1 0AA4 83 DUP4 0AA5 20 SHA3 0AA6 60 PUSH1 0x01 0AA8 60 PUSH1 0x01 0AAA 60 PUSH1 0xa0 0AAC 1B SHL 0AAD 03 SUB 0AAE 8E DUP15 0AAF 81 DUP2 0AB0 16 AND 0AB1 85 DUP6 0AB2 52 MSTORE 0AB3 92 SWAP3 0AB4 52 MSTORE 0AB5 80 DUP1 0AB6 83 DUP4 0AB7 20 SHA3 0AB8 85 DUP6 0AB9 85 DUP6 0ABA 03 SUB 0ABB 90 SWAP1 0ABC 55 SSTORE 0ABD 90 SWAP1 0ABE 8B DUP12 0ABF 16 AND 0AC0 82 DUP3 0AC1 52 MSTORE 0AC2 81 DUP2 0AC3 20 SHA3 0AC4 80 DUP1 0AC5 54 SLOAD 0AC6 84 DUP5 0AC7 92 SWAP3 0AC8 90 SWAP1 0AC9 61 PUSH2 0x0ad3 0ACC 90 SWAP1 0ACD 84 DUP5 0ACE 90 SWAP1 0ACF 61 PUSH2 0x1898 0AD2 56 *JUMP 0AD3 5B JUMPDEST 0AD4 92 SWAP3 0AD5 50 POP 0AD6 50 POP 0AD7 81 DUP2 0AD8 90 SWAP1 0AD9 55 SSTORE 0ADA 50 POP 0ADB 50 POP 0ADC 50 POP 0ADD 50 POP 0ADE 80 DUP1 0ADF 61 PUSH2 0x0ae7 0AE2 90 SWAP1 0AE3 61 PUSH2 0x19a8 0AE6 56 *JUMP 0AE7 5B JUMPDEST 0AE8 90 SWAP1 0AE9 50 POP 0AEA 61 PUSH2 0x0a0b 0AED 56 *JUMP 0AEE 5B JUMPDEST 0AEF 50 POP 0AF0 84 DUP5 0AF1 60 PUSH1 0x01 0AF3 60 PUSH1 0x01 0AF5 60 PUSH1 0xa0 0AF7 1B SHL 0AF8 03 SUB 0AF9 16 AND 0AFA 86 DUP7 0AFB 60 PUSH1 0x01 0AFD 60 PUSH1 0x01 0AFF 60 PUSH1 0xa0 0B01 1B SHL 0B02 03 SUB 0B03 16 AND 0B04 82 DUP3 0B05 60 PUSH1 0x01 0B07 60 PUSH1 0x01 0B09 60 PUSH1 0xa0 0B0B 1B SHL 0B0C 03 SUB 0B0D 16 AND 0B0E 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 0B2F 87 DUP8 0B30 87 DUP8 0B31 60 PUSH1 0x40 0B33 51 MLOAD 0B34 61 PUSH2 0x0b3e 0B37 92 SWAP3 0B38 91 SWAP2 0B39 90 SWAP1 0B3A 61 PUSH2 0x1766 0B3D 56 *JUMP 0B3E 5B JUMPDEST 0B3F 60 PUSH1 0x40 0B41 51 MLOAD 0B42 80 DUP1 0B43 91 SWAP2 0B44 03 SUB 0B45 90 SWAP1 0B46 A4 LOG4 0B47 61 PUSH2 0x0b54 0B4A 81 DUP2 0B4B 87 DUP8 0B4C 87 DUP8 0B4D 87 DUP8 0B4E 87 DUP8 0B4F 87 DUP8 0B50 61 PUSH2 0x0eba 0B53 56 *JUMP label_0B54: // Incoming jump from 0x116F, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0B5B stack[-7] } 0B54 5B JUMPDEST 0B55 50 POP 0B56 50 POP 0B57 50 POP 0B58 50 POP 0B59 50 POP 0B5A 50 POP 0B5B 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0B5C: // Incoming call from 0x0664, returns to 0x0665 // Inputs[2] // { // @0B5D tx.origin // @0B66 stack[-1] // } 0B5C 5B JUMPDEST 0B5D 32 ORIGIN 0B5E 60 PUSH1 0x01 0B60 60 PUSH1 0x01 0B62 60 PUSH1 0xa0 0B64 1B SHL 0B65 03 SUB 0B66 82 DUP3 0B67 16 AND 0B68 14 EQ 0B69 61 PUSH2 0x0b85 0B6C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b85, if stack[-1] & (0x01 << 0xa0) - 0x01 == tx.origin label_0B6D: // Incoming jump from 0x0B6C, if not stack[-1] & (0x01 << 0xa0) - 0x01 == tx.origin // Inputs[3] // { // @0B6F memory[0x40:0x60] // @0B7F memory[0x40:0x60] // @0B84 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B6D 60 PUSH1 0x40 0B6F 51 MLOAD 0B70 63 PUSH4 0x58594bc3 0B75 60 PUSH1 0xe1 0B77 1B SHL 0B78 81 DUP2 0B79 52 MSTORE 0B7A 60 PUSH1 0x04 0B7C 01 ADD 0B7D 60 PUSH1 0x40 0B7F 51 MLOAD 0B80 80 DUP1 0B81 91 SWAP2 0B82 03 SUB 0B83 90 SWAP1 0B84 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x58594bc3 << 0xe1 // @0B84 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B85: // Incoming jump from 0x0B6C, if stack[-1] & (0x01 << 0xa0) - 0x01 == tx.origin // Inputs[3] // { // @0B8E stack[-1] // @0B9D memory[0x00:0x40] // @0B9E storage[keccak256(memory[0x00:0x40])] // } 0B85 5B JUMPDEST 0B86 60 PUSH1 0x01 0B88 60 PUSH1 0x01 0B8A 60 PUSH1 0xa0 0B8C 1B SHL 0B8D 03 SUB 0B8E 81 DUP2 0B8F 16 AND 0B90 60 PUSH1 0x00 0B92 90 SWAP1 0B93 81 DUP2 0B94 52 MSTORE 0B95 60 PUSH1 0x04 0B97 60 PUSH1 0x20 0B99 52 MSTORE 0B9A 60 PUSH1 0x40 0B9C 90 SWAP1 0B9D 20 SHA3 0B9E 54 SLOAD 0B9F 60 PUSH1 0xff 0BA1 16 AND 0BA2 15 ISZERO 0BA3 61 PUSH2 0x0bca 0BA6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0B94 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0B99 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0bca, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0BA7: // Incoming jump from 0x0BA6, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @0BA9 memory[0x40:0x60] // @0BBC stack[-1] // } 0BA7 60 PUSH1 0x40 0BA9 51 MLOAD 0BAA 63 PUSH4 0x2058b6db 0BAF 60 PUSH1 0xe0 0BB1 1B SHL 0BB2 81 DUP2 0BB3 52 MSTORE 0BB4 60 PUSH1 0x01 0BB6 60 PUSH1 0x01 0BB8 60 PUSH1 0xa0 0BBA 1B SHL 0BBB 03 SUB 0BBC 82 DUP3 0BBD 16 AND 0BBE 60 PUSH1 0x04 0BC0 82 DUP3 0BC1 01 ADD 0BC2 52 MSTORE 0BC3 60 PUSH1 0x24 0BC5 01 ADD 0BC6 61 PUSH2 0x02ea 0BC9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0BB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2058b6db << 0xe0 // @0BC2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0BC5 stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ea label_0BCA: // Incoming jump from 0x0BA6, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0BEC block.timestamp } 0BCA 5B JUMPDEST 0BCB 7F PUSH32 0x000000000000000000000000000000000000000000000000000000006105e400 0BEC 42 TIMESTAMP 0BED 11 GT 0BEE 15 ISZERO 0BEF 61 PUSH2 0x0c33 0BF2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c33, if !(block.timestamp > 0x000000000000000000000000000000000000000000000000000000006105e400) label_0BF3: // Incoming jump from 0x0BF2, if not !(block.timestamp > 0x000000000000000000000000000000000000000000000000000000006105e400) // Inputs[2] // { // @0BF5 memory[0x40:0x60] // @0C00 block.timestamp // } 0BF3 60 PUSH1 0x40 0BF5 51 MLOAD 0BF6 63 PUSH4 0x4796c9b7 0BFB 60 PUSH1 0xe1 0BFD 1B SHL 0BFE 81 DUP2 0BFF 52 MSTORE 0C00 42 TIMESTAMP 0C01 60 PUSH1 0x04 0C03 82 DUP3 0C04 01 ADD 0C05 52 MSTORE 0C06 7F PUSH32 0x000000000000000000000000000000000000000000000000000000006105e400 0C27 60 PUSH1 0x24 0C29 82 DUP3 0C2A 01 ADD 0C2B 52 MSTORE 0C2C 60 PUSH1 0x44 0C2E 01 ADD 0C2F 61 PUSH2 0x02ea 0C32 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0BFF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4796c9b7 << 0xe1 // @0C05 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = block.timestamp // @0C2B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x000000000000000000000000000000000000000000000000000000006105e400 // @0C2E stack[0] = 0x44 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ea label_0C33: // Incoming jump from 0x0BF2, if !(block.timestamp > 0x000000000000000000000000000000000000000000000000000000006105e400) // Incoming jump from 0x1AE5, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0C35 stack[-2] } 0C33 5B JUMPDEST 0C34 50 POP 0C35 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0C36: // Incoming jump from 0x0D5E // Incoming call from 0x066F, returns to 0x0670 // Inputs[6] // { // @0C39 memory[0x40:0x60] // @0C43 msg.sender // @0C51 stack[-1] // @0C80 memory[0x40:0x60] // @0C8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0C93 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 0C36 5B JUMPDEST 0C37 60 PUSH1 0x40 0C39 51 MLOAD 0C3A 60 PUSH1 0x01 0C3C 60 PUSH1 0x01 0C3E 60 PUSH1 0x60 0C40 1B SHL 0C41 03 SUB 0C42 19 NOT 0C43 33 CALLER 0C44 60 PUSH1 0x60 0C46 1B SHL 0C47 16 AND 0C48 60 PUSH1 0x20 0C4A 82 DUP3 0C4B 01 ADD 0C4C 52 MSTORE 0C4D 60 PUSH1 0x34 0C4F 81 DUP2 0C50 01 ADD 0C51 82 DUP3 0C52 90 SWAP1 0C53 52 MSTORE 0C54 60 PUSH1 0x00 0C56 90 SWAP1 0C57 81 DUP2 0C58 90 SWAP1 0C59 7F PUSH32 0x00000000000000000000000000000000000000000000000000000000000003e8 0C7A 90 SWAP1 0C7B 60 PUSH1 0x54 0C7D 01 ADD 0C7E 60 PUSH1 0x40 0C80 51 MLOAD 0C81 60 PUSH1 0x20 0C83 81 DUP2 0C84 83 DUP4 0C85 03 SUB 0C86 03 SUB 0C87 81 DUP2 0C88 52 MSTORE 0C89 90 SWAP1 0C8A 60 PUSH1 0x40 0C8C 52 MSTORE 0C8D 80 DUP1 0C8E 51 MLOAD 0C8F 90 SWAP1 0C90 60 PUSH1 0x20 0C92 01 ADD 0C93 20 SHA3 0C94 60 PUSH1 0x00 0C96 1C SHR 0C97 61 PUSH2 0x0ca0 0C9A 91 SWAP2 0C9B 90 SWAP1 0C9C 61 PUSH2 0x19c3 0C9F 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0C4C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~((0x01 << 0x60) - 0x01) // @0C53 memory[memory[0x40:0x60] + 0x34:memory[0x40:0x60] + 0x34 + 0x20] = stack[-1] // @0C56 stack[0] = 0x00 // @0C58 stack[1] = 0x00 // @0C88 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x54 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @0C8C memory[0x40:0x60] = 0x54 + memory[0x40:0x60] // @0C9A stack[2] = 0x0ca0 // @0C9B stack[3] = 0x00000000000000000000000000000000000000000000000000000000000003e8 // @0C9B stack[4] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) >> 0x00 // } // Block ends with call to 0x19c3, returns to 0x0CA0 label_0CA0: // Incoming return from call to 0x19C3 at 0x0C9F // Inputs[2] // { // @0CA1 stack[-2] // @0CA1 stack[-1] // } 0CA0 5B JUMPDEST 0CA1 90 SWAP1 0CA2 50 POP 0CA3 7F PUSH32 0x00000000000000000000000000000000000000000000000000000000000003e8 0CC4 60 PUSH1 0x09 0CC6 5B JUMPDEST 0CC7 80 DUP1 0CC8 15 ISZERO 0CC9 61 PUSH2 0x0d39 0CCC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0CA1 stack[-2] = stack[-1] // @0CA3 stack[-1] = 0x00000000000000000000000000000000000000000000000000000000000003e8 // @0CC4 stack[0] = 0x09 // } // Block ends with conditional jump to 0x0d39, if !0x09 label_0CCD: // Incoming jump from 0x0CCC, if not !0x09 // Incoming jump from 0x0CCC, if not !stack[-1] // Inputs[1] { @0CEE stack[-1] } 0CCD 7F PUSH32 0x013333338d8d8d8d8d8d00000000000000000000000000000000000000000000 0CEE 81 DUP2 0CEF 60 PUSH1 0x0a 0CF1 81 DUP2 0CF2 10 LT 0CF3 61 PUSH2 0x0cfe 0CF6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0CCD stack[0] = 0x013333338d8d8d8d8d8d00000000000000000000000000000000000000000000 // @0CEE stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0cfe, if stack[-1] < 0x0a label_0CF7: // Incoming jump from 0x0CF6, if not stack[-1] < 0x0a 0CF7 61 PUSH2 0x0cfe 0CFA 61 PUSH2 0x1a03 0CFD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CF7 stack[0] = 0x0cfe } // Block ends with unconditional jump to 0x1a03 label_0CFE: // Incoming jump from 0x0CF6, if stack[-1] < 0x0a // Inputs[3] // { // @0D02 stack[-2] // @0D03 stack[-1] // @0D05 stack[-4] // } 0CFE 5B JUMPDEST 0CFF 61 PUSH2 0x0d0a 0D02 91 SWAP2 0D03 90 SWAP1 0D04 1A BYTE 0D05 83 DUP4 0D06 61 PUSH2 0x18e3 0D09 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0D02 stack[-2] = 0x0d0a // @0D04 stack[-1] = byte(stack[-2], stack[-1]) // @0D05 stack[0] = stack[-4] // } // Block ends with call to 0x18e3, returns to 0x0D0A label_0D0A: // Incoming return from call to 0x18E3 at 0x0D09 // Inputs[3] // { // @0D0B stack[-3] // @0D0B stack[-1] // @0D0E stack[-4] // } 0D0A 5B JUMPDEST 0D0B 91 SWAP2 0D0C 50 POP 0D0D 81 DUP2 0D0E 83 DUP4 0D0F 10 LT 0D10 61 PUSH2 0x0d27 0D13 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0D0B stack[-3] = stack[-1] } // Block ends with conditional jump to 0x0d27, if stack[-4] < stack[-1] label_0D14: // Incoming jump from 0x0D13, if not stack[-4] < stack[-1] // Inputs[1] { @0D17 stack[-1] } 0D14 61 PUSH2 0x0d1e 0D17 81 DUP2 0D18 60 PUSH1 0x01 0D1A 61 PUSH2 0x1898 0D1D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D14 stack[0] = 0x0d1e // @0D17 stack[1] = stack[-1] // @0D18 stack[2] = 0x01 // } // Block ends with call to 0x1898, returns to 0x0D1E label_0D1E: // Incoming return from call to 0x1898 at 0x0D1D // Inputs[3] // { // @0D1F stack[-1] // @0D1F stack[-7] // @0D20 stack[-6] // } 0D1E 5B JUMPDEST 0D1F 95 SWAP6 0D20 94 SWAP5 0D21 50 POP 0D22 50 POP 0D23 50 POP 0D24 50 POP 0D25 50 POP 0D26 56 *JUMP // Stack delta = -6 // Outputs[1] { @0D1F stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_0D27: // Incoming jump from 0x0D13, if stack[-4] < stack[-1] // Inputs[1] { @0D28 stack[-1] } 0D27 5B JUMPDEST 0D28 80 DUP1 0D29 61 PUSH2 0x0d31 0D2C 81 DUP2 0D2D 61 PUSH2 0x192a 0D30 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D28 stack[0] = stack[-1] // @0D29 stack[1] = 0x0d31 // @0D2C stack[2] = stack[-1] // } // Block ends with call to 0x192a, returns to 0x0D31 label_0D31: // Incoming return from call to 0x192A at 0x0D30 // Inputs[2] // { // @0D32 stack[-1] // @0D32 stack[-3] // } 0D31 5B JUMPDEST 0D32 91 SWAP2 0D33 50 POP 0D34 50 POP 0D35 61 PUSH2 0x0cc6 0D38 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D32 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0cc6 label_0D39: // Incoming jump from 0x0CCC, if !0x09 // Incoming jump from 0x0CCC, if !stack[-1] 0D39 5B JUMPDEST 0D3A 50 POP 0D3B 61 PUSH2 0x0d44 0D3E 60 PUSH1 0x01 0D40 61 PUSH2 0x083f 0D43 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0D3B stack[-1] = 0x0d44 // @0D3E stack[0] = 0x01 // } // Block ends with call to 0x083f, returns to 0x0D44 label_0D44: // Incoming return from call to 0x083F at 0x0D43 // Inputs[1] { @0D47 stack[-1] } 0D44 5B JUMPDEST 0D45 60 PUSH1 0x0a 0D47 14 EQ 0D48 15 ISZERO 0D49 61 PUSH2 0x0d67 0D4C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d67, if !(0x0a == stack[-1]) label_0D4D: // Incoming jump from 0x0D4C, if not !(0x0a == stack[-1]) // Inputs[1] { @0D53 stack[-4] } 0D4D 61 PUSH2 0x0d5f 0D50 61 PUSH2 0x0d5a 0D53 85 DUP6 0D54 60 PUSH1 0x01 0D56 61 PUSH2 0x1898 0D59 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D4D stack[0] = 0x0d5f // @0D50 stack[1] = 0x0d5a // @0D53 stack[2] = stack[-4] // @0D54 stack[3] = 0x01 // } // Block ends with call to 0x1898, returns to 0x0D5A label_0D5A: // Incoming return from call to 0x1898 at 0x0D59 0D5A 5B JUMPDEST 0D5B 61 PUSH2 0x0c36 0D5E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c36 label_0D5F: // Incoming return from call to 0x0D5A at 0x0D59 // Incoming return from call to 0x0D5A at 0x0D59 // Inputs[3] // { // @0D60 stack[-1] // @0D60 stack[-6] // @0D61 stack[-5] // } 0D5F 5B JUMPDEST 0D60 94 SWAP5 0D61 93 SWAP4 0D62 50 POP 0D63 50 POP 0D64 50 POP 0D65 50 POP 0D66 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D60 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0D67: // Incoming jump from 0x0D4C, if !(0x0a == stack[-1]) // Inputs[2] // { // @0D6B stack[-5] // @0D6C stack[-4] // } 0D67 5B JUMPDEST 0D68 50 POP 0D69 60 PUSH1 0x01 0D6B 93 SWAP4 0D6C 92 SWAP3 0D6D 50 POP 0D6E 50 POP 0D6F 50 POP 0D70 56 *JUMP // Stack delta = -4 // Outputs[1] { @0D6B stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0D71: // Incoming jump from 0x0691 // Inputs[4] // { // @0D75 stack[-4] // @0D76 stack[-3] // @0D77 stack[-2] // @0D78 stack[-1] // } 0D71 5B JUMPDEST 0D72 61 PUSH2 0x0d7d 0D75 84 DUP5 0D76 84 DUP5 0D77 84 DUP5 0D78 84 DUP5 0D79 61 PUSH2 0x1025 0D7C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0D72 stack[0] = 0x0d7d // @0D75 stack[1] = stack[-4] // @0D76 stack[2] = stack[-3] // @0D77 stack[3] = stack[-2] // @0D78 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1025 0D7D 5B JUMPDEST 0D7E 60 PUSH1 0x00 0D80 83 DUP4 0D81 81 DUP2 0D82 52 MSTORE 0D83 60 PUSH1 0x03 0D85 60 PUSH1 0x20 0D87 52 MSTORE 0D88 60 PUSH1 0x40 0D8A 81 DUP2 0D8B 20 SHA3 0D8C 80 DUP1 0D8D 54 SLOAD 0D8E 84 DUP5 0D8F 92 SWAP3 0D90 90 SWAP1 0D91 61 PUSH2 0x0d9b 0D94 90 SWAP1 0D95 84 DUP5 0D96 90 SWAP1 0D97 61 PUSH2 0x1898 0D9A 56 *JUMP 0D9B 5B JUMPDEST 0D9C 90 SWAP1 0D9D 91 SWAP2 0D9E 55 SSTORE 0D9F 50 POP 0DA0 50 POP 0DA1 50 POP 0DA2 50 POP 0DA3 50 POP 0DA4 50 POP 0DA5 56 *JUMP label_0DA6: // Incoming call from 0x08E4, returns to 0x052B // Inputs[1] { @0DAF stack[-4] } 0DA6 5B JUMPDEST 0DA7 60 PUSH1 0x01 0DA9 60 PUSH1 0x01 0DAB 60 PUSH1 0xa0 0DAD 1B SHL 0DAE 03 SUB 0DAF 84 DUP5 0DB0 16 AND 0DB1 61 PUSH2 0x0dcc 0DB4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dcc, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0DB5: // Incoming jump from 0x0DB4, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0DB7 memory[0x40:0x60] } 0DB5 60 PUSH1 0x40 0DB7 51 MLOAD 0DB8 62 PUSH3 0x461bcd 0DBC 60 PUSH1 0xe5 0DBE 1B SHL 0DBF 81 DUP2 0DC0 52 MSTORE 0DC1 60 PUSH1 0x04 0DC3 01 ADD 0DC4 61 PUSH2 0x02ea 0DC7 90 SWAP1 0DC8 61 PUSH2 0x17e6 0DCB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DC7 stack[0] = 0x02ea // @0DC7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x17e6, returns to 0x02EA label_0DCC: // Incoming jump from 0x0DB4, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0DCD msg.sender // @0DD2 stack[-5] // @0DD3 stack[-4] // @0DD7 stack[-3] // } 0DCC 5B JUMPDEST 0DCD 33 CALLER 0DCE 61 PUSH2 0x0de5 0DD1 81 DUP2 0DD2 87 DUP8 0DD3 87 DUP8 0DD4 61 PUSH2 0x0ddc 0DD7 88 DUP9 0DD8 61 PUSH2 0x1114 0DDB 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0DCD stack[0] = msg.sender // @0DCE stack[1] = 0x0de5 // @0DD1 stack[2] = msg.sender // @0DD2 stack[3] = stack[-5] // @0DD3 stack[4] = stack[-4] // @0DD4 stack[5] = 0x0ddc // @0DD7 stack[6] = stack[-3] // } // Block ends with call to 0x1114, returns to 0x0DDC label_0DDC: // Incoming return from call to 0x1114 at 0x0DDB // Incoming return from call to 0x1114 at 0x1095 // Inputs[1] { @0DE0 stack[-8] } 0DDC 5B JUMPDEST 0DDD 61 PUSH2 0x052b 0DE0 88 DUP9 0DE1 61 PUSH2 0x1114 0DE4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DDD stack[0] = 0x052b // @0DE0 stack[1] = stack[-8] // } // Block ends with call to 0x1114, returns to 0x052B label_0DE5: // Incoming return from call to 0x0DDC at 0x0DDB // Inputs[6] // { // @0DE8 stack[-4] // @0DF4 memory[0x00:0x40] // @0DFD stack[-6] // @0E05 memory[0x00:0x40] // @0E06 storage[keccak256(memory[0x00:0x40])] // @0E07 stack[-3] // } 0DE5 5B JUMPDEST 0DE6 60 PUSH1 0x00 0DE8 84 DUP5 0DE9 81 DUP2 0DEA 52 MSTORE 0DEB 60 PUSH1 0x20 0DED 81 DUP2 0DEE 81 DUP2 0DEF 52 MSTORE 0DF0 60 PUSH1 0x40 0DF2 80 DUP1 0DF3 83 DUP4 0DF4 20 SHA3 0DF5 60 PUSH1 0x01 0DF7 60 PUSH1 0x01 0DF9 60 PUSH1 0xa0 0DFB 1B SHL 0DFC 03 SUB 0DFD 8A DUP11 0DFE 16 AND 0DFF 84 DUP5 0E00 52 MSTORE 0E01 90 SWAP1 0E02 91 SWAP2 0E03 52 MSTORE 0E04 90 SWAP1 0E05 20 SHA3 0E06 54 SLOAD 0E07 83 DUP4 0E08 81 DUP2 0E09 10 LT 0E0A 15 ISZERO 0E0B 61 PUSH2 0x0e26 0E0E 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0DEA memory[0x00:0x20] = stack[-4] // @0DEF memory[0x20:0x40] = 0x00 // @0E00 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0E03 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E06 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0e26, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) label_0E0F: // Incoming jump from 0x0E0E, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[1] { @0E11 memory[0x40:0x60] } 0E0F 60 PUSH1 0x40 0E11 51 MLOAD 0E12 62 PUSH3 0x461bcd 0E16 60 PUSH1 0xe5 0E18 1B SHL 0E19 81 DUP2 0E1A 52 MSTORE 0E1B 60 PUSH1 0x04 0E1D 01 ADD 0E1E 61 PUSH2 0x02ea 0E21 90 SWAP1 0E22 61 PUSH2 0x182b 0E25 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E21 stack[0] = 0x02ea // @0E21 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x182b, returns to 0x02EA label_0E26: // Incoming jump from 0x0E0E, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[9] // { // @0E29 stack[-5] // @0E35 memory[0x00:0x40] // @0E3E stack[-7] // @0E47 memory[0x00:0x40] // @0E48 stack[-4] // @0E49 stack[-1] // @0E4E stack[-6] // @0E53 memory[0x00:0x40] // @0E55 storage[keccak256(memory[0x00:0x40])] // } 0E26 5B JUMPDEST 0E27 60 PUSH1 0x00 0E29 85 DUP6 0E2A 81 DUP2 0E2B 52 MSTORE 0E2C 60 PUSH1 0x20 0E2E 81 DUP2 0E2F 81 DUP2 0E30 52 MSTORE 0E31 60 PUSH1 0x40 0E33 80 DUP1 0E34 83 DUP4 0E35 20 SHA3 0E36 60 PUSH1 0x01 0E38 60 PUSH1 0x01 0E3A 60 PUSH1 0xa0 0E3C 1B SHL 0E3D 03 SUB 0E3E 8B DUP12 0E3F 81 DUP2 0E40 16 AND 0E41 85 DUP6 0E42 52 MSTORE 0E43 92 SWAP3 0E44 52 MSTORE 0E45 80 DUP1 0E46 83 DUP4 0E47 20 SHA3 0E48 87 DUP8 0E49 85 DUP6 0E4A 03 SUB 0E4B 90 SWAP1 0E4C 55 SSTORE 0E4D 90 SWAP1 0E4E 88 DUP9 0E4F 16 AND 0E50 82 DUP3 0E51 52 MSTORE 0E52 81 DUP2 0E53 20 SHA3 0E54 80 DUP1 0E55 54 SLOAD 0E56 86 DUP7 0E57 92 SWAP3 0E58 90 SWAP1 0E59 61 PUSH2 0x0e63 0E5C 90 SWAP1 0E5D 84 DUP5 0E5E 90 SWAP1 0E5F 61 PUSH2 0x1898 0E62 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @0E2B memory[0x00:0x20] = stack[-5] // @0E30 memory[0x20:0x40] = 0x00 // @0E42 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @0E44 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E4C storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-4] // @0E51 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0E53 stack[1] = keccak256(memory[0x00:0x40]) // @0E57 stack[0] = stack[-4] // @0E58 stack[2] = 0x00 // @0E5C stack[3] = 0x0e63 // @0E5E stack[4] = stack[-4] // @0E5E stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1898, returns to 0x0E63 label_0E63: // Incoming return from call to 0x1898 at 0x0E62 // Inputs[14] // { // @0E64 stack[-2] // @0E64 stack[-1] // @0E65 stack[-3] // @0E6C memory[0x40:0x60] // @0E6D stack[-9] // @0E74 stack[-8] // @0E80 stack[-10] // @0E83 stack[-11] // @0E88 stack[-6] // @0E8E memory[0x00:0x20] // @0E97 memory[0x00:0x20] // @0E9E memory[0x40:0x60] // @0EA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0EAC stack[-7] // } 0E63 5B JUMPDEST 0E64 90 SWAP1 0E65 91 SWAP2 0E66 55 SSTORE 0E67 50 POP 0E68 50 POP 0E69 60 PUSH1 0x40 0E6B 80 DUP1 0E6C 51 MLOAD 0E6D 86 DUP7 0E6E 81 DUP2 0E6F 52 MSTORE 0E70 60 PUSH1 0x20 0E72 81 DUP2 0E73 01 ADD 0E74 86 DUP7 0E75 90 SWAP1 0E76 52 MSTORE 0E77 60 PUSH1 0x01 0E79 60 PUSH1 0x01 0E7B 60 PUSH1 0xa0 0E7D 1B SHL 0E7E 03 SUB 0E7F 80 DUP1 0E80 89 DUP10 0E81 16 AND 0E82 92 SWAP3 0E83 8A DUP11 0E84 82 DUP3 0E85 16 AND 0E86 92 SWAP3 0E87 91 SWAP2 0E88 86 DUP7 0E89 16 AND 0E8A 91 SWAP2 0E8B 60 PUSH1 0x00 0E8D 80 DUP1 0E8E 51 MLOAD 0E8F 60 PUSH1 0x20 0E91 61 PUSH2 0x1aeb 0E94 83 DUP4 0E95 39 CODECOPY 0E96 81 DUP2 0E97 51 MLOAD 0E98 91 SWAP2 0E99 52 MSTORE 0E9A 91 SWAP2 0E9B 01 ADD 0E9C 60 PUSH1 0x40 0E9E 51 MLOAD 0E9F 80 DUP1 0EA0 91 SWAP2 0EA1 03 SUB 0EA2 90 SWAP1 0EA3 A4 LOG4 0EA4 61 PUSH2 0x0eb1 0EA7 82 DUP3 0EA8 88 DUP9 0EA9 88 DUP9 0EAA 88 DUP9 0EAB 88 DUP9 0EAC 88 DUP9 0EAD 61 PUSH2 0x115f 0EB0 56 *JUMP // Stack delta = +3 // Outputs[13] // { // @0E66 storage[stack[-3]] = stack[-1] // @0E6F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-9] // @0E76 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-8] // @0E95 memory[0x00:0x20] = code[0x1aeb:0x1b0b] // @0E99 memory[0x00:0x20] = memory[0x00:0x20] // @0EA3 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [memory[0x00:0x20], stack[-6] & (0x01 << 0xa0) - 0x01, stack[-11] & (0x01 << 0xa0) - 0x01, stack[-10] & (0x01 << 0xa0) - 0x01]); // @0EA4 stack[-4] = 0x0eb1 // @0EA7 stack[-3] = stack[-6] // @0EA8 stack[-2] = stack[-11] // @0EA9 stack[-1] = stack[-10] // @0EAA stack[0] = stack[-9] // @0EAB stack[1] = stack[-8] // @0EAC stack[2] = stack[-7] // } // Block ends with call to 0x115f, returns to 0x0EB1 label_0EB1: // Incoming jump from 0x1211, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x115F at 0x0EB0 // Inputs[1] { @0EB9 stack[-8] } 0EB1 5B JUMPDEST 0EB2 50 POP 0EB3 50 POP 0EB4 50 POP 0EB5 50 POP 0EB6 50 POP 0EB7 50 POP 0EB8 50 POP 0EB9 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] 0EBA 5B JUMPDEST 0EBB 60 PUSH1 0x01 0EBD 60 PUSH1 0x01 0EBF 60 PUSH1 0xa0 0EC1 1B SHL 0EC2 03 SUB 0EC3 84 DUP5 0EC4 16 AND 0EC5 3B EXTCODESIZE 0EC6 15 ISZERO 0EC7 61 PUSH2 0x0b54 0ECA 57 *JUMPI 0ECB 60 PUSH1 0x40 0ECD 51 MLOAD 0ECE 63 PUSH4 0xbc197c81 0ED3 60 PUSH1 0xe0 0ED5 1B SHL 0ED6 81 DUP2 0ED7 52 MSTORE 0ED8 60 PUSH1 0x01 0EDA 60 PUSH1 0x01 0EDC 60 PUSH1 0xa0 0EDE 1B SHL 0EDF 03 SUB 0EE0 85 DUP6 0EE1 16 AND 0EE2 90 SWAP1 0EE3 63 PUSH4 0xbc197c81 0EE8 90 SWAP1 0EE9 61 PUSH2 0x0efe 0EEC 90 SWAP1 0EED 89 DUP10 0EEE 90 SWAP1 0EEF 89 DUP10 0EF0 90 SWAP1 0EF1 88 DUP9 0EF2 90 SWAP1 0EF3 88 DUP9 0EF4 90 SWAP1 0EF5 88 DUP9 0EF6 90 SWAP1 0EF7 60 PUSH1 0x04 0EF9 01 ADD 0EFA 61 PUSH2 0x16b0 0EFD 56 *JUMP 0EFE 5B JUMPDEST 0EFF 60 PUSH1 0x20 0F01 60 PUSH1 0x40 0F03 51 MLOAD 0F04 80 DUP1 0F05 83 DUP4 0F06 03 SUB 0F07 81 DUP2 0F08 60 PUSH1 0x00 0F0A 87 DUP8 0F0B 80 DUP1 0F0C 3B EXTCODESIZE 0F0D 15 ISZERO 0F0E 80 DUP1 0F0F 15 ISZERO 0F10 61 PUSH2 0x0f18 0F13 57 *JUMPI 0F14 60 PUSH1 0x00 0F16 80 DUP1 0F17 FD *REVERT 0F18 5B JUMPDEST 0F19 50 POP 0F1A 5A GAS 0F1B F1 CALL 0F1C 92 SWAP3 0F1D 50 POP 0F1E 50 POP 0F1F 50 POP 0F20 80 DUP1 0F21 15 ISZERO 0F22 61 PUSH2 0x0f48 0F25 57 *JUMPI 0F26 50 POP 0F27 60 PUSH1 0x40 0F29 80 DUP1 0F2A 51 MLOAD 0F2B 60 PUSH1 0x1f 0F2D 3D RETURNDATASIZE 0F2E 90 SWAP1 0F2F 81 DUP2 0F30 01 ADD 0F31 60 PUSH1 0x1f 0F33 19 NOT 0F34 16 AND 0F35 82 DUP3 0F36 01 ADD 0F37 90 SWAP1 0F38 92 SWAP3 0F39 52 MSTORE 0F3A 61 PUSH2 0x0f45 0F3D 91 SWAP2 0F3E 81 DUP2 0F3F 01 ADD 0F40 90 SWAP1 0F41 61 PUSH2 0x15e4 0F44 56 *JUMP 0F45 5B JUMPDEST 0F46 60 PUSH1 0x01 0F48 5B JUMPDEST 0F49 61 PUSH2 0x0ff5 0F4C 57 *JUMPI 0F4D 61 PUSH2 0x0f54 0F50 61 PUSH2 0x1a2f 0F53 56 *JUMP label_0F54: // Incoming return from call to 0x1A2F at 0x11F8 // Inputs[1] { @0F55 stack[-1] } 0F54 5B JUMPDEST 0F55 80 DUP1 0F56 63 PUSH4 0x08c379a0 0F5B 14 EQ 0F5C 15 ISZERO 0F5D 61 PUSH2 0x0f8e 0F60 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f8e, if !(0x08c379a0 == stack[-1]) label_0F61: // Incoming jump from 0x0F60, if not !(0x08c379a0 == stack[-1]) 0F61 50 POP 0F62 61 PUSH2 0x0f69 0F65 61 PUSH2 0x1a4b 0F68 56 *JUMP // Stack delta = +0 // Outputs[1] { @0F62 stack[-1] = 0x0f69 } // Block ends with call to 0x1a4b, returns to 0x0F69 label_0F69: // Incoming return from call to 0x1A4B at 0x0F68 // Incoming return from call to 0x1A4B at 0x0F68 // Inputs[1] { @0F6A stack[-1] } 0F69 5B JUMPDEST 0F6A 80 DUP1 0F6B 61 PUSH2 0x0f74 0F6E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f74, if stack[-1] label_0F6F: // Incoming jump from 0x0F6E, if not stack[-1] 0F6F 50 POP 0F70 61 PUSH2 0x0f90 0F73 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x0f90 label_0F74: // Incoming jump from 0x0F6E, if stack[-1] // Inputs[2] // { // @0F75 stack[-1] // @0F78 memory[0x40:0x60] // } 0F74 5B JUMPDEST 0F75 80 DUP1 0F76 60 PUSH1 0x40 0F78 51 MLOAD 0F79 62 PUSH3 0x461bcd 0F7D 60 PUSH1 0xe5 0F7F 1B SHL 0F80 81 DUP2 0F81 52 MSTORE 0F82 60 PUSH1 0x04 0F84 01 ADD 0F85 61 PUSH2 0x02ea 0F88 91 SWAP2 0F89 90 SWAP1 0F8A 61 PUSH2 0x178b 0F8D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0F81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F88 stack[0] = 0x02ea // @0F89 stack[1] = stack[-1] // @0F89 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x178b label_0F8E: // Incoming jump from 0x0F60, if !(0x08c379a0 == stack[-1]) // Inputs[1] { @0F93 memory[0x40:0x60] } 0F8E 5B JUMPDEST 0F8F 50 POP 0F90 5B JUMPDEST 0F91 60 PUSH1 0x40 0F93 51 MLOAD 0F94 62 PUSH3 0x461bcd 0F98 60 PUSH1 0xe5 0F9A 1B SHL 0F9B 81 DUP2 0F9C 52 MSTORE 0F9D 60 PUSH1 0x20 0F9F 60 PUSH1 0x04 0FA1 82 DUP3 0FA2 01 ADD 0FA3 52 MSTORE 0FA4 60 PUSH1 0x34 0FA6 60 PUSH1 0x24 0FA8 82 DUP3 0FA9 01 ADD 0FAA 52 MSTORE 0FAB 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 0FCC 60 PUSH1 0x44 0FCE 82 DUP3 0FCF 01 ADD 0FD0 52 MSTORE 0FD1 73 PUSH20 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 0FE6 60 PUSH1 0x61 0FE8 1B SHL 0FE9 60 PUSH1 0x64 0FEB 82 DUP3 0FEC 01 ADD 0FED 52 MSTORE 0FEE 60 PUSH1 0x84 0FF0 01 ADD 0FF1 61 PUSH2 0x02ea 0FF4 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @0F9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FA3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FAA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @0FD0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @0FED memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x61 // @0FF0 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ea 0FF5 5B JUMPDEST 0FF6 60 PUSH1 0x01 0FF8 60 PUSH1 0x01 0FFA 60 PUSH1 0xe0 0FFC 1B SHL 0FFD 03 SUB 0FFE 19 NOT 0FFF 81 DUP2 1000 16 AND 1001 63 PUSH4 0xbc197c81 1006 60 PUSH1 0xe0 1008 1B SHL 1009 14 EQ 100A 61 PUSH2 0x0eb1 100D 57 *JUMPI 100E 60 PUSH1 0x40 1010 51 MLOAD 1011 62 PUSH3 0x461bcd 1015 60 PUSH1 0xe5 1017 1B SHL 1018 81 DUP2 1019 52 MSTORE 101A 60 PUSH1 0x04 101C 01 ADD 101D 61 PUSH2 0x02ea 1020 90 SWAP1 1021 61 PUSH2 0x179e 1024 56 *JUMP label_1025: // Incoming jump from 0x0D7C // Inputs[1] { @102E stack[-4] } 1025 5B JUMPDEST 1026 60 PUSH1 0x01 1028 60 PUSH1 0x01 102A 60 PUSH1 0xa0 102C 1B SHL 102D 03 SUB 102E 84 DUP5 102F 16 AND 1030 61 PUSH2 0x1085 1033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1085, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1034: // Incoming jump from 0x1033, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1036 memory[0x40:0x60] } 1034 60 PUSH1 0x40 1036 51 MLOAD 1037 62 PUSH3 0x461bcd 103B 60 PUSH1 0xe5 103D 1B SHL 103E 81 DUP2 103F 52 MSTORE 1040 60 PUSH1 0x20 1042 60 PUSH1 0x04 1044 82 DUP3 1045 01 ADD 1046 52 MSTORE 1047 60 PUSH1 0x21 1049 60 PUSH1 0x24 104B 82 DUP3 104C 01 ADD 104D 52 MSTORE 104E 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 106F 60 PUSH1 0x44 1071 82 DUP3 1072 01 ADD 1073 52 MSTORE 1074 60 PUSH1 0x73 1076 60 PUSH1 0xf8 1078 1B SHL 1079 60 PUSH1 0x64 107B 82 DUP3 107C 01 ADD 107D 52 MSTORE 107E 60 PUSH1 0x84 1080 01 ADD 1081 61 PUSH2 0x02ea 1084 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @103F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1046 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @104D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @1073 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @107D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73 << 0xf8 // @1080 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ea label_1085: // Incoming jump from 0x1033, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1086 msg.sender // @108D stack[-4] // @1091 stack[-3] // } 1085 5B JUMPDEST 1086 33 CALLER 1087 61 PUSH2 0x1096 108A 81 DUP2 108B 60 PUSH1 0x00 108D 87 DUP8 108E 61 PUSH2 0x0ddc 1091 88 DUP9 1092 61 PUSH2 0x1114 1095 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1086 stack[0] = msg.sender // @1087 stack[1] = 0x1096 // @108A stack[2] = msg.sender // @108B stack[3] = 0x00 // @108D stack[4] = stack[-4] // @108E stack[5] = 0x0ddc // @1091 stack[6] = stack[-3] // } // Block ends with call to 0x1114, returns to 0x0DDC label_1096: // Incoming return from call to 0x0DDC at 0x1095 // Inputs[6] // { // @1099 stack[-4] // @10A5 memory[0x00:0x40] // @10AE stack[-5] // @10B6 memory[0x00:0x40] // @10B8 storage[keccak256(memory[0x00:0x40])] // @10B9 stack[-3] // } 1096 5B JUMPDEST 1097 60 PUSH1 0x00 1099 84 DUP5 109A 81 DUP2 109B 52 MSTORE 109C 60 PUSH1 0x20 109E 81 DUP2 109F 81 DUP2 10A0 52 MSTORE 10A1 60 PUSH1 0x40 10A3 80 DUP1 10A4 83 DUP4 10A5 20 SHA3 10A6 60 PUSH1 0x01 10A8 60 PUSH1 0x01 10AA 60 PUSH1 0xa0 10AC 1B SHL 10AD 03 SUB 10AE 89 DUP10 10AF 16 AND 10B0 84 DUP5 10B1 52 MSTORE 10B2 90 SWAP1 10B3 91 SWAP2 10B4 52 MSTORE 10B5 81 DUP2 10B6 20 SHA3 10B7 80 DUP1 10B8 54 SLOAD 10B9 85 DUP6 10BA 92 SWAP3 10BB 90 SWAP1 10BC 61 PUSH2 0x10c6 10BF 90 SWAP1 10C0 84 DUP5 10C1 90 SWAP1 10C2 61 PUSH2 0x1898 10C5 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @109B memory[0x00:0x20] = stack[-4] // @10A0 memory[0x20:0x40] = 0x00 // @10B1 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @10B4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @10B6 stack[1] = keccak256(memory[0x00:0x40]) // @10BA stack[0] = stack[-3] // @10BB stack[2] = 0x00 // @10BF stack[3] = 0x10c6 // @10C1 stack[4] = stack[-3] // @10C1 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1898, returns to 0x10C6 label_10C6: // Incoming return from call to 0x1898 at 0x10C5 // Inputs[13] // { // @10C7 stack[-2] // @10C7 stack[-1] // @10C8 stack[-3] // @10CF memory[0x40:0x60] // @10D0 stack[-8] // @10D7 stack[-7] // @10E3 stack[-9] // @10EA stack[-5] // @10F0 memory[0x00:0x20] // @10F9 memory[0x00:0x20] // @1100 memory[0x40:0x60] // @1105 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @110F stack[-6] // } 10C6 5B JUMPDEST 10C7 90 SWAP1 10C8 91 SWAP2 10C9 55 SSTORE 10CA 50 POP 10CB 50 POP 10CC 60 PUSH1 0x40 10CE 80 DUP1 10CF 51 MLOAD 10D0 85 DUP6 10D1 81 DUP2 10D2 52 MSTORE 10D3 60 PUSH1 0x20 10D5 81 DUP2 10D6 01 ADD 10D7 85 DUP6 10D8 90 SWAP1 10D9 52 MSTORE 10DA 60 PUSH1 0x01 10DC 60 PUSH1 0x01 10DE 60 PUSH1 0xa0 10E0 1B SHL 10E1 03 SUB 10E2 80 DUP1 10E3 88 DUP9 10E4 16 AND 10E5 92 SWAP3 10E6 60 PUSH1 0x00 10E8 92 SWAP3 10E9 91 SWAP2 10EA 85 DUP6 10EB 16 AND 10EC 91 SWAP2 10ED 60 PUSH1 0x00 10EF 80 DUP1 10F0 51 MLOAD 10F1 60 PUSH1 0x20 10F3 61 PUSH2 0x1aeb 10F6 83 DUP4 10F7 39 CODECOPY 10F8 81 DUP2 10F9 51 MLOAD 10FA 91 SWAP2 10FB 52 MSTORE 10FC 91 SWAP2 10FD 01 ADD 10FE 60 PUSH1 0x40 1100 51 MLOAD 1101 80 DUP1 1102 91 SWAP2 1103 03 SUB 1104 90 SWAP1 1105 A4 LOG4 1106 61 PUSH2 0x052b 1109 81 DUP2 110A 60 PUSH1 0x00 110C 87 DUP8 110D 87 DUP8 110E 87 DUP8 110F 87 DUP8 1110 61 PUSH2 0x115f 1113 56 *JUMP // Stack delta = +3 // Outputs[13] // { // @10C9 storage[stack[-3]] = stack[-1] // @10D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] // @10D9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-7] // @10F7 memory[0x00:0x20] = code[0x1aeb:0x1b0b] // @10FB memory[0x00:0x20] = memory[0x00:0x20] // @1105 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [memory[0x00:0x20], stack[-5] & (0x01 << 0xa0) - 0x01, 0x00, stack[-9] & (0x01 << 0xa0) - 0x01]); // @1106 stack[-4] = 0x052b // @1109 stack[-3] = stack[-5] // @110A stack[-2] = 0x00 // @110C stack[-1] = stack[-9] // @110D stack[0] = stack[-8] // @110E stack[1] = stack[-7] // @110F stack[2] = stack[-6] // } // Block ends with call to 0x115f, returns to 0x052B label_1114: // Incoming call from 0x0DE4, returns to 0x052B // Incoming call from 0x1095, returns to 0x0DDC // Incoming call from 0x0DDB, returns to 0x0DDC // Inputs[5] // { // @1118 memory[0x40:0x60] // @1132 msg.data.length // @1134 msg.data[msg.data.length:msg.data.length + 0x20] // @113B stack[-1] // @1140 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1114 5B JUMPDEST 1115 60 PUSH1 0x40 1117 80 DUP1 1118 51 MLOAD 1119 60 PUSH1 0x01 111B 80 DUP1 111C 82 DUP3 111D 52 MSTORE 111E 81 DUP2 111F 83 DUP4 1120 01 ADD 1121 90 SWAP1 1122 92 SWAP3 1123 52 MSTORE 1124 60 PUSH1 0x60 1126 91 SWAP2 1127 60 PUSH1 0x00 1129 91 SWAP2 112A 90 SWAP1 112B 60 PUSH1 0x20 112D 80 DUP1 112E 83 DUP4 112F 01 ADD 1130 90 SWAP1 1131 80 DUP1 1132 36 CALLDATASIZE 1133 83 DUP4 1134 37 CALLDATACOPY 1135 01 ADD 1136 90 SWAP1 1137 50 POP 1138 50 POP 1139 90 SWAP1 113A 50 POP 113B 82 DUP3 113C 81 DUP2 113D 60 PUSH1 0x00 113F 81 DUP2 1140 51 MLOAD 1141 81 DUP2 1142 10 LT 1143 61 PUSH2 0x114e 1146 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @111D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1123 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1126 stack[0] = 0x60 // @1134 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @1139 stack[1] = memory[0x40:0x60] // @113B stack[2] = stack[-1] // @113C stack[3] = memory[0x40:0x60] // @113D stack[4] = 0x00 // } // Block ends with conditional jump to 0x114e, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_1147: // Incoming jump from 0x1146, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] 1147 61 PUSH2 0x114e 114A 61 PUSH2 0x1a03 114D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1147 stack[0] = 0x114e } // Block ends with unconditional jump to 0x1a03 label_114E: // Incoming jump from 0x1146, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @1151 stack[-1] // @1154 stack[-2] // @1159 stack[-3] // @115A stack[-7] // @115A stack[-4] // @115B stack[-6] // } 114E 5B JUMPDEST 114F 60 PUSH1 0x20 1151 90 SWAP1 1152 81 DUP2 1153 02 MUL 1154 91 SWAP2 1155 90 SWAP1 1156 91 SWAP2 1157 01 ADD 1158 01 ADD 1159 52 MSTORE 115A 92 SWAP3 115B 91 SWAP2 115C 50 POP 115D 50 POP 115E 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1159 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @115A stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_115F: // Incoming call from 0x1113, returns to 0x052B // Incoming call from 0x0EB0, returns to 0x0EB1 // Inputs[2] // { // @1168 stack[-4] // @116A address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 115F 5B JUMPDEST 1160 60 PUSH1 0x01 1162 60 PUSH1 0x01 1164 60 PUSH1 0xa0 1166 1B SHL 1167 03 SUB 1168 84 DUP5 1169 16 AND 116A 3B EXTCODESIZE 116B 15 ISZERO 116C 61 PUSH2 0x0b54 116F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b54, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_1170: // Incoming jump from 0x116F, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @1172 memory[0x40:0x60] // @1185 stack[-4] // @1192 stack[-6] // @1194 stack[-5] // @1196 stack[-3] // @1198 stack[-2] // @119A stack[-1] // } 1170 60 PUSH1 0x40 1172 51 MLOAD 1173 63 PUSH4 0xf23a6e61 1178 60 PUSH1 0xe0 117A 1B SHL 117B 81 DUP2 117C 52 MSTORE 117D 60 PUSH1 0x01 117F 60 PUSH1 0x01 1181 60 PUSH1 0xa0 1183 1B SHL 1184 03 SUB 1185 85 DUP6 1186 16 AND 1187 90 SWAP1 1188 63 PUSH4 0xf23a6e61 118D 90 SWAP1 118E 61 PUSH2 0x11a3 1191 90 SWAP1 1192 89 DUP10 1193 90 SWAP1 1194 89 DUP10 1195 90 SWAP1 1196 88 DUP9 1197 90 SWAP1 1198 88 DUP9 1199 90 SWAP1 119A 88 DUP9 119B 90 SWAP1 119C 60 PUSH1 0x04 119E 01 ADD 119F 61 PUSH2 0x170e 11A2 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @117C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e61 << 0xe0 // @1187 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @118D stack[1] = 0xf23a6e61 // @1191 stack[2] = 0x11a3 // @1193 stack[3] = stack[-6] // @1195 stack[4] = stack[-5] // @1197 stack[5] = stack[-3] // @1199 stack[6] = stack[-2] // @119B stack[7] = stack[-1] // @119E stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x170e, returns to 0x11A3 label_11A3: // Incoming return from call to 0x170E at 0x11A2 // Inputs[4] // { // @11A8 memory[0x40:0x60] // @11AA stack[-1] // @11AF stack[-3] // @11B1 address(stack[-3]).code.length // } 11A3 5B JUMPDEST 11A4 60 PUSH1 0x20 11A6 60 PUSH1 0x40 11A8 51 MLOAD 11A9 80 DUP1 11AA 83 DUP4 11AB 03 SUB 11AC 81 DUP2 11AD 60 PUSH1 0x00 11AF 87 DUP8 11B0 80 DUP1 11B1 3B EXTCODESIZE 11B2 15 ISZERO 11B3 80 DUP1 11B4 15 ISZERO 11B5 61 PUSH2 0x11bd 11B8 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @11A4 stack[0] = 0x20 // @11A8 stack[1] = memory[0x40:0x60] // @11AB stack[2] = stack[-1] - memory[0x40:0x60] // @11AC stack[3] = memory[0x40:0x60] // @11AD stack[4] = 0x00 // @11AF stack[5] = stack[-3] // @11B2 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x11bd, if !!address(stack[-3]).code.length label_11B9: // Incoming jump from 0x11B8, if not !!address(stack[-3]).code.length // Inputs[1] { @11BC memory[0x00:0x00] } 11B9 60 PUSH1 0x00 11BB 80 DUP1 11BC FD *REVERT // Stack delta = +0 // Outputs[1] { @11BC revert(memory[0x00:0x00]); } // Block terminates label_11BD: // Incoming jump from 0x11B8, if !!address(stack[-3]).code.length // Inputs[10] // { // @11BF msg.gas // @11C0 stack[-2] // @11C0 stack[-7] // @11C0 stack[-4] // @11C0 stack[-6] // @11C0 memory[stack[-4]:stack[-4] + stack[-5]] // @11C0 stack[-3] // @11C0 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @11C0 stack[-5] // @11C1 stack[-10] // } 11BD 5B JUMPDEST 11BE 50 POP 11BF 5A GAS 11C0 F1 CALL 11C1 92 SWAP3 11C2 50 POP 11C3 50 POP 11C4 50 POP 11C5 80 DUP1 11C6 15 ISZERO 11C7 61 PUSH2 0x11ed 11CA 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @11C0 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @11C1 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x11ed, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_11CB: // Incoming jump from 0x11CA, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @11CF memory[0x40:0x60] // @11D2 returndata.length // } 11CB 50 POP 11CC 60 PUSH1 0x40 11CE 80 DUP1 11CF 51 MLOAD 11D0 60 PUSH1 0x1f 11D2 3D RETURNDATASIZE 11D3 90 SWAP1 11D4 81 DUP2 11D5 01 ADD 11D6 60 PUSH1 0x1f 11D8 19 NOT 11D9 16 AND 11DA 82 DUP3 11DB 01 ADD 11DC 90 SWAP1 11DD 92 SWAP3 11DE 52 MSTORE 11DF 61 PUSH2 0x11ea 11E2 91 SWAP2 11E3 81 DUP2 11E4 01 ADD 11E5 90 SWAP1 11E6 61 PUSH2 0x15e4 11E9 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @11DE memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @11E2 stack[-1] = 0x11ea // @11E5 stack[1] = memory[0x40:0x60] // @11E5 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x15e4 11EA 5B JUMPDEST 11EB 60 PUSH1 0x01 label_11ED: // Incoming jump from 0x11CA, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @11F1 stack[-1] } 11ED 5B JUMPDEST 11EE 61 PUSH2 0x11f9 11F1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11f9, if stack[-1] label_11F2: // Incoming jump from 0x11F1, if not stack[-1] 11F2 61 PUSH2 0x0f54 11F5 61 PUSH2 0x1a2f 11F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @11F2 stack[0] = 0x0f54 } // Block ends with call to 0x1a2f, returns to 0x0F54 label_11F9: // Incoming jump from 0x11F1, if stack[-1] // Inputs[1] { @1203 stack[-1] } 11F9 5B JUMPDEST 11FA 60 PUSH1 0x01 11FC 60 PUSH1 0x01 11FE 60 PUSH1 0xe0 1200 1B SHL 1201 03 SUB 1202 19 NOT 1203 81 DUP2 1204 16 AND 1205 63 PUSH4 0xf23a6e61 120A 60 PUSH1 0xe0 120C 1B SHL 120D 14 EQ 120E 61 PUSH2 0x0eb1 1211 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eb1, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1212: // Incoming jump from 0x1211, if not 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1214 memory[0x40:0x60] } 1212 60 PUSH1 0x40 1214 51 MLOAD 1215 62 PUSH3 0x461bcd 1219 60 PUSH1 0xe5 121B 1B SHL 121C 81 DUP2 121D 52 MSTORE 121E 60 PUSH1 0x04 1220 01 ADD 1221 61 PUSH2 0x02ea 1224 90 SWAP1 1225 61 PUSH2 0x179e 1228 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @121D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1224 stack[0] = 0x02ea // @1224 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x179e, returns to 0x02EA label_1229: // Incoming call from 0x144D, returns to 0x144E // Incoming call from 0x13A4, returns to 0x13A5 // Incoming call from 0x137A, returns to 0x137B // Incoming call from 0x1584, returns to 0x1585 // Incoming call from 0x1349, returns to 0x134A // Incoming call from 0x14E8, returns to 0x14E9 // Incoming call from 0x13B2, returns to 0x13B3 // Incoming call from 0x136C, returns to 0x136D // Incoming call from 0x145B, returns to 0x145C // Incoming call from 0x14AC, returns to 0x14AD // Inputs[2] // { // @122A stack[-1] // @122B msg.data[stack[-1]:stack[-1] + 0x20] // } 1229 5B JUMPDEST 122A 80 DUP1 122B 35 CALLDATALOAD 122C 60 PUSH1 0x01 122E 60 PUSH1 0x01 1230 60 PUSH1 0xa0 1232 1B SHL 1233 03 SUB 1234 81 DUP2 1235 16 AND 1236 81 DUP2 1237 14 EQ 1238 61 PUSH2 0x1240 123B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @122B stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1240, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_123C: // Incoming jump from 0x123B, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @123F memory[0x00:0x00] } 123C 60 PUSH1 0x00 123E 80 DUP1 123F FD *REVERT // Stack delta = +0 // Outputs[1] { @123F revert(memory[0x00:0x00]); } // Block terminates label_1240: // Incoming jump from 0x123B, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1241 stack[-1] // @1241 stack[-3] // @1242 stack[-2] // } 1240 5B JUMPDEST 1241 91 SWAP2 1242 90 SWAP1 1243 50 POP 1244 56 *JUMP // Stack delta = -2 // Outputs[1] { @1241 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1245: // Incoming call from 0x13DA, returns to 0x13DB // Incoming call from 0x15BC, returns to 0x15BD // Incoming call from 0x13FC, returns to 0x13FD // Inputs[2] // { // @1248 stack[-2] // @124B stack[-1] // } 1245 5B JUMPDEST 1246 60 PUSH1 0x00 1248 82 DUP3 1249 60 PUSH1 0x1f 124B 83 DUP4 124C 01 ADD 124D 12 SLT 124E 61 PUSH2 0x1256 1251 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1246 stack[0] = 0x00 } // Block ends with conditional jump to 0x1256, if stack[-1] + 0x1f i< stack[-2] label_1252: // Incoming jump from 0x1251, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1255 memory[0x00:0x00] } 1252 60 PUSH1 0x00 1254 80 DUP1 1255 FD *REVERT // Stack delta = +0 // Outputs[1] { @1255 revert(memory[0x00:0x00]); } // Block terminates label_1256: // Incoming jump from 0x1251, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1257 stack[-2] // @1258 msg.data[stack[-2]:stack[-2] + 0x20] // } 1256 5B JUMPDEST 1257 81 DUP2 1258 35 CALLDATALOAD 1259 60 PUSH1 0x20 125B 61 PUSH2 0x1263 125E 82 DUP3 125F 61 PUSH2 0x1875 1262 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1258 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1259 stack[1] = 0x20 // @125B stack[2] = 0x1263 // @125E stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1875, returns to 0x1263 label_1263: // Incoming return from call to 0x1875 at 0x1262 // Inputs[2] // { // @1266 memory[0x40:0x60] // @126A stack[-1] // } 1263 5B JUMPDEST 1264 60 PUSH1 0x40 1266 51 MLOAD 1267 61 PUSH2 0x1270 126A 82 DUP3 126B 82 DUP3 126C 61 PUSH2 0x197c 126F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1266 stack[0] = memory[0x40:0x60] // @1267 stack[1] = 0x1270 // @126A stack[2] = stack[-1] // @126B stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x197c, returns to 0x1270 label_1270: // Incoming return from call to 0x197C at 0x126F // Inputs[6] // { // @1271 stack[-4] // @1272 stack[-1] // @1274 stack[-3] // @1277 stack[-2] // @1279 stack[-6] // @1285 stack[-7] // } 1270 5B JUMPDEST 1271 83 DUP4 1272 81 DUP2 1273 52 MSTORE 1274 82 DUP3 1275 81 DUP2 1276 01 ADD 1277 91 SWAP2 1278 50 POP 1279 85 DUP6 127A 83 DUP4 127B 01 ADD 127C 60 PUSH1 0x05 127E 85 DUP6 127F 90 SWAP1 1280 1B SHL 1281 87 DUP8 1282 01 ADD 1283 84 DUP5 1284 01 ADD 1285 88 DUP9 1286 10 LT 1287 15 ISZERO 1288 61 PUSH2 0x1290 128B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1273 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1277 stack[-2] = stack[-1] + stack[-3] // @127B stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1290, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_128C: // Incoming jump from 0x128B, if not !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[1] { @128F memory[0x00:0x00] } 128C 60 PUSH1 0x00 128E 80 DUP1 128F FD *REVERT // Stack delta = +0 // Outputs[1] { @128F revert(memory[0x00:0x00]); } // Block terminates label_1290: // Incoming jump from 0x128B, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[1] { @1294 stack[-5] } 1290 5B JUMPDEST 1291 60 PUSH1 0x00 1293 5B JUMPDEST 1294 85 DUP6 1295 81 DUP2 1296 10 LT 1297 15 ISZERO 1298 61 PUSH2 0x12af 129B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1291 stack[0] = 0x00 } // Block ends with conditional jump to 0x12af, if !(0x00 < stack[-5]) label_129C: // Incoming jump from 0x129B, if not !(0x00 < stack[-5]) // Incoming jump from 0x129B, if not !(stack[-1] < stack[-6]) // Inputs[5] // { // @129C stack[-2] // @129D msg.data[stack[-2]:stack[-2] + 0x20] // @129E stack[-4] // @12A0 stack[-1] // @12A1 stack[-5] // } 129C 81 DUP2 129D 35 CALLDATALOAD 129E 84 DUP5 129F 52 MSTORE 12A0 92 SWAP3 12A1 84 DUP5 12A2 01 ADD 12A3 92 SWAP3 12A4 90 SWAP1 12A5 84 DUP5 12A6 01 ADD 12A7 90 SWAP1 12A8 60 PUSH1 0x01 12AA 01 ADD 12AB 61 PUSH2 0x1293 12AE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @129F memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @12A3 stack[-4] = stack[-5] + stack[-4] // @12A7 stack[-2] = stack[-5] + stack[-2] // @12AA stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1293 label_12AF: // Incoming jump from 0x129B, if !(0x00 < stack[-5]) // Incoming jump from 0x129B, if !(stack[-1] < stack[-6]) // Inputs[4] // { // @12B1 stack[-3] // @12B1 stack[-2] // @12B2 stack[-10] // @12B3 stack[-9] // } 12AF 5B JUMPDEST 12B0 50 POP 12B1 90 SWAP1 12B2 97 SWAP8 12B3 96 SWAP7 12B4 50 POP 12B5 50 POP 12B6 50 POP 12B7 50 POP 12B8 50 POP 12B9 50 POP 12BA 50 POP 12BB 56 *JUMP // Stack delta = -9 // Outputs[1] { @12B2 stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_12BC: // Incoming call from 0x141F, returns to 0x1420 // Incoming call from 0x1490, returns to 0x1420 // Inputs[2] // { // @12BF stack[-2] // @12C2 stack[-1] // } 12BC 5B JUMPDEST 12BD 60 PUSH1 0x00 12BF 82 DUP3 12C0 60 PUSH1 0x1f 12C2 83 DUP4 12C3 01 ADD 12C4 12 SLT 12C5 61 PUSH2 0x12cd 12C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12BD stack[0] = 0x00 } // Block ends with conditional jump to 0x12cd, if stack[-1] + 0x1f i< stack[-2] label_12C9: // Incoming jump from 0x12C8, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @12CC memory[0x00:0x00] } 12C9 60 PUSH1 0x00 12CB 80 DUP1 12CC FD *REVERT // Stack delta = +0 // Outputs[1] { @12CC revert(memory[0x00:0x00]); } // Block terminates label_12CD: // Incoming jump from 0x12C8, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @12CE stack[-2] // @12CF msg.data[stack[-2]:stack[-2] + 0x20] // } 12CD 5B JUMPDEST 12CE 81 DUP2 12CF 35 CALLDATALOAD 12D0 60 PUSH1 0x01 12D2 60 PUSH1 0x01 12D4 60 PUSH1 0x40 12D6 1B SHL 12D7 03 SUB 12D8 81 DUP2 12D9 11 GT 12DA 15 ISZERO 12DB 61 PUSH2 0x12e6 12DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12CF stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x12e6, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_12DF: // Incoming jump from 0x12DE, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) 12DF 61 PUSH2 0x12e6 12E2 61 PUSH2 0x1a19 12E5 56 *JUMP // Stack delta = +1 // Outputs[1] { @12DF stack[0] = 0x12e6 } // Block ends with unconditional jump to 0x1a19 label_12E6: // Incoming jump from 0x12DE, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @12E9 memory[0x40:0x60] // @12EF stack[-1] // } 12E6 5B JUMPDEST 12E7 60 PUSH1 0x40 12E9 51 MLOAD 12EA 61 PUSH2 0x12fd 12ED 60 PUSH1 0x1f 12EF 83 DUP4 12F0 01 ADD 12F1 60 PUSH1 0x1f 12F3 19 NOT 12F4 16 AND 12F5 60 PUSH1 0x20 12F7 01 ADD 12F8 82 DUP3 12F9 61 PUSH2 0x197c 12FC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12E9 stack[0] = memory[0x40:0x60] // @12EA stack[1] = 0x12fd // @12F7 stack[2] = 0x20 + (~0x1f & stack[-1] + 0x1f) // @12F8 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x197c, returns to 0x12FD label_12FD: // Incoming return from call to 0x197C at 0x12FC // Inputs[4] // { // @12FE stack[-2] // @12FF stack[-1] // @1301 stack[-5] // @1305 stack[-4] // } 12FD 5B JUMPDEST 12FE 81 DUP2 12FF 81 DUP2 1300 52 MSTORE 1301 84 DUP5 1302 60 PUSH1 0x20 1304 83 DUP4 1305 86 DUP7 1306 01 ADD 1307 01 ADD 1308 11 GT 1309 15 ISZERO 130A 61 PUSH2 0x1312 130D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1300 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x1312, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_130E: // Incoming jump from 0x130D, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @1311 memory[0x00:0x00] } 130E 60 PUSH1 0x00 1310 80 DUP1 1311 FD *REVERT // Stack delta = +0 // Outputs[1] { @1311 revert(memory[0x00:0x00]); } // Block terminates label_1312: // Incoming jump from 0x130D, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[6] // { // @1313 stack[-2] // @1316 stack[-4] // @131A stack[-1] // @131C msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @1329 stack[-6] // @132A stack[-5] // } 1312 5B JUMPDEST 1313 81 DUP2 1314 60 PUSH1 0x20 1316 85 DUP6 1317 01 ADD 1318 60 PUSH1 0x20 131A 83 DUP4 131B 01 ADD 131C 37 CALLDATACOPY 131D 60 PUSH1 0x00 131F 91 SWAP2 1320 81 DUP2 1321 01 ADD 1322 60 PUSH1 0x20 1324 01 ADD 1325 91 SWAP2 1326 90 SWAP1 1327 91 SWAP2 1328 52 MSTORE 1329 93 SWAP4 132A 92 SWAP3 132B 50 POP 132C 50 POP 132D 50 POP 132E 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @131C memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @1328 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] = 0x00 // @1329 stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_132F: // Incoming call from 0x0215, returns to 0x0216 // Inputs[2] // { // @1334 stack[-1] // @1335 stack[-2] // } 132F 5B JUMPDEST 1330 60 PUSH1 0x00 1332 60 PUSH1 0x20 1334 82 DUP3 1335 84 DUP5 1336 03 SUB 1337 12 SLT 1338 15 ISZERO 1339 61 PUSH2 0x1341 133C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1330 stack[0] = 0x00 } // Block ends with conditional jump to 0x1341, if !(stack[-2] - stack[-1] i< 0x20) label_133D: // Incoming jump from 0x133C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1340 memory[0x00:0x00] } 133D 60 PUSH1 0x00 133F 80 DUP1 1340 FD *REVERT // Stack delta = +0 // Outputs[1] { @1340 revert(memory[0x00:0x00]); } // Block terminates label_1341: // Incoming jump from 0x133C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1345 stack[-2] } 1341 5B JUMPDEST 1342 61 PUSH2 0x134a 1345 82 DUP3 1346 61 PUSH2 0x1229 1349 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1342 stack[0] = 0x134a // @1345 stack[1] = stack[-2] // } // Block ends with call to 0x1229, returns to 0x134A label_134A: // Incoming return from call to 0x1AD4 at 0x15E3 // Incoming return from call to 0x1655 at 0x179D // Incoming return from call to 0x1AD4 at 0x1600 // Incoming return from call to 0x1229 at 0x1349 // Incoming return from call to 0x161A at 0x1765 // Inputs[3] // { // @134B stack[-5] // @134B stack[-1] // @134C stack[-4] // } 134A 5B JUMPDEST 134B 93 SWAP4 134C 92 SWAP3 134D 50 POP 134E 50 POP 134F 50 POP 1350 56 *JUMP // Stack delta = -4 // Outputs[1] { @134B stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1351: // Incoming call from 0x0240, returns to 0x0241 // Inputs[2] // { // @1357 stack[-1] // @1358 stack[-2] // } 1351 5B JUMPDEST 1352 60 PUSH1 0x00 1354 80 DUP1 1355 60 PUSH1 0x40 1357 83 DUP4 1358 85 DUP6 1359 03 SUB 135A 12 SLT 135B 15 ISZERO 135C 61 PUSH2 0x1364 135F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1352 stack[0] = 0x00 // @1354 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1364, if !(stack[-2] - stack[-1] i< 0x40) label_1360: // Incoming jump from 0x135F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1363 memory[0x00:0x00] } 1360 60 PUSH1 0x00 1362 80 DUP1 1363 FD *REVERT // Stack delta = +0 // Outputs[1] { @1363 revert(memory[0x00:0x00]); } // Block terminates label_1364: // Incoming jump from 0x135F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1368 stack[-3] } 1364 5B JUMPDEST 1365 61 PUSH2 0x136d 1368 83 DUP4 1369 61 PUSH2 0x1229 136C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1365 stack[0] = 0x136d // @1368 stack[1] = stack[-3] // } // Block ends with call to 0x1229, returns to 0x136D label_136D: // Incoming return from call to 0x1229 at 0x136C // Inputs[3] // { // @136E stack[-3] // @136E stack[-1] // @1375 stack[-4] // } 136D 5B JUMPDEST 136E 91 SWAP2 136F 50 POP 1370 61 PUSH2 0x137b 1373 60 PUSH1 0x20 1375 84 DUP5 1376 01 ADD 1377 61 PUSH2 0x1229 137A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @136E stack[-3] = stack[-1] // @1370 stack[-1] = 0x137b // @1376 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1229, returns to 0x137B label_137B: // Incoming return from call to 0x1229 at 0x137A // Inputs[6] // { // @137C stack[-2] // @137C stack[-1] // @137E stack[-5] // @1380 stack[-3] // @1380 stack[-6] // @1381 stack[-4] // } 137B 5B JUMPDEST 137C 90 SWAP1 137D 50 POP 137E 92 SWAP3 137F 50 POP 1380 92 SWAP3 1381 90 SWAP1 1382 50 POP 1383 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @137E stack[-5] = stack[-1] // @1380 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1384: // Incoming jump from 0x0184 // Inputs[2] // { // @138F stack[-1] // @1390 stack[-2] // } 1384 5B JUMPDEST 1385 60 PUSH1 0x00 1387 80 DUP1 1388 60 PUSH1 0x00 138A 80 DUP1 138B 60 PUSH1 0x00 138D 60 PUSH1 0xa0 138F 86 DUP7 1390 88 DUP9 1391 03 SUB 1392 12 SLT 1393 15 ISZERO 1394 61 PUSH2 0x139c 1397 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1385 stack[0] = 0x00 // @1387 stack[1] = 0x00 // @1388 stack[2] = 0x00 // @138A stack[3] = 0x00 // @138B stack[4] = 0x00 // } // Block ends with conditional jump to 0x139c, if !(stack[-2] - stack[-1] i< 0xa0) label_1398: // Incoming jump from 0x1397, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @139B memory[0x00:0x00] } 1398 60 PUSH1 0x00 139A 80 DUP1 139B FD *REVERT // Stack delta = +0 // Outputs[1] { @139B revert(memory[0x00:0x00]); } // Block terminates label_139C: // Incoming jump from 0x1397, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @13A0 stack[-6] } 139C 5B JUMPDEST 139D 61 PUSH2 0x13a5 13A0 86 DUP7 13A1 61 PUSH2 0x1229 13A4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @139D stack[0] = 0x13a5 // @13A0 stack[1] = stack[-6] // } // Block ends with call to 0x1229, returns to 0x13A5 label_13A5: // Incoming return from call to 0x1229 at 0x13A4 // Inputs[3] // { // @13A6 stack[-6] // @13A6 stack[-1] // @13AD stack[-7] // } 13A5 5B JUMPDEST 13A6 94 SWAP5 13A7 50 POP 13A8 61 PUSH2 0x13b3 13AB 60 PUSH1 0x20 13AD 87 DUP8 13AE 01 ADD 13AF 61 PUSH2 0x1229 13B2 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @13A6 stack[-6] = stack[-1] // @13A8 stack[-1] = 0x13b3 // @13AE stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1229, returns to 0x13B3 label_13B3: // Incoming return from call to 0x1229 at 0x13B2 // Inputs[4] // { // @13B4 stack[-5] // @13B4 stack[-1] // @13B8 stack[-7] // @13BA msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 13B3 5B JUMPDEST 13B4 93 SWAP4 13B5 50 POP 13B6 60 PUSH1 0x40 13B8 86 DUP7 13B9 01 ADD 13BA 35 CALLDATALOAD 13BB 60 PUSH1 0x01 13BD 60 PUSH1 0x01 13BF 60 PUSH1 0x40 13C1 1B SHL 13C2 03 SUB 13C3 80 DUP1 13C4 82 DUP3 13C5 11 GT 13C6 15 ISZERO 13C7 61 PUSH2 0x13cf 13CA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @13B4 stack[-5] = stack[-1] // @13BA stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @13C2 stack[0] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x13cf, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) label_13CB: // Incoming jump from 0x13CA, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @13CE memory[0x00:0x00] } 13CB 60 PUSH1 0x00 13CD 80 DUP1 13CE FD *REVERT // Stack delta = +0 // Outputs[1] { @13CE revert(memory[0x00:0x00]); } // Block terminates label_13CF: // Incoming jump from 0x13CA, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @13D3 stack[-9] // @13D4 stack[-2] // @13D5 stack[-8] // } 13CF 5B JUMPDEST 13D0 61 PUSH2 0x13db 13D3 89 DUP10 13D4 83 DUP4 13D5 8A DUP11 13D6 01 ADD 13D7 61 PUSH2 0x1245 13DA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13D0 stack[0] = 0x13db // @13D3 stack[1] = stack[-9] // @13D6 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1245, returns to 0x13DB label_13DB: // Incoming return from call to 0x1245 at 0x13DA // Inputs[6] // { // @13DC stack[-6] // @13DC stack[-1] // @13E0 stack[-9] // @13E2 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @13E3 stack[-3] // @13E5 stack[-2] // } 13DB 5B JUMPDEST 13DC 94 SWAP5 13DD 50 POP 13DE 60 PUSH1 0x60 13E0 88 DUP9 13E1 01 ADD 13E2 35 CALLDATALOAD 13E3 91 SWAP2 13E4 50 POP 13E5 80 DUP1 13E6 82 DUP3 13E7 11 GT 13E8 15 ISZERO 13E9 61 PUSH2 0x13f1 13EC 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @13DC stack[-6] = stack[-1] // @13E3 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x13f1, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_13ED: // Incoming jump from 0x13EC, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[1] { @13F0 memory[0x00:0x00] } 13ED 60 PUSH1 0x00 13EF 80 DUP1 13F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @13F0 revert(memory[0x00:0x00]); } // Block terminates label_13F1: // Incoming jump from 0x13EC, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @13F5 stack[-9] // @13F6 stack[-2] // @13F7 stack[-8] // } 13F1 5B JUMPDEST 13F2 61 PUSH2 0x13fd 13F5 89 DUP10 13F6 83 DUP4 13F7 8A DUP11 13F8 01 ADD 13F9 61 PUSH2 0x1245 13FC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13F2 stack[0] = 0x13fd // @13F5 stack[1] = stack[-9] // @13F8 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1245, returns to 0x13FD label_13FD: // Incoming return from call to 0x1245 at 0x13FC // Inputs[6] // { // @13FE stack[-1] // @13FE stack[-5] // @1402 stack[-9] // @1404 msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @1405 stack[-3] // @1407 stack[-2] // } 13FD 5B JUMPDEST 13FE 93 SWAP4 13FF 50 POP 1400 60 PUSH1 0x80 1402 88 DUP9 1403 01 ADD 1404 35 CALLDATALOAD 1405 91 SWAP2 1406 50 POP 1407 80 DUP1 1408 82 DUP3 1409 11 GT 140A 15 ISZERO 140B 61 PUSH2 0x1413 140E 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @13FE stack[-5] = stack[-1] // @1405 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1413, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_140F: // Incoming jump from 0x140E, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[1] { @1412 memory[0x00:0x00] } 140F 60 PUSH1 0x00 1411 80 DUP1 1412 FD *REVERT // Stack delta = +0 // Outputs[1] { @1412 revert(memory[0x00:0x00]); } // Block terminates label_1413: // Incoming jump from 0x140E, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @1418 stack[-9] // @1419 stack[-2] // @141A stack[-8] // } 1413 5B JUMPDEST 1414 50 POP 1415 61 PUSH2 0x1420 1418 88 DUP9 1419 82 DUP3 141A 89 DUP10 141B 01 ADD 141C 61 PUSH2 0x12bc 141F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1415 stack[-1] = 0x1420 // @1418 stack[0] = stack[-9] // @141B stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x12bc, returns to 0x1420 label_1420: // Incoming return from call to 0x12BC at 0x141F // Incoming return from call to 0x12BC at 0x1490 // Inputs[9] // { // @1421 stack[-1] // @1421 stack[-3] // @1424 stack[-6] // @1425 stack[-9] // @1427 stack[-7] // @1427 stack[-4] // @1428 stack[-10] // @1429 stack[-5] // @142A stack[-8] // } 1420 5B JUMPDEST 1421 91 SWAP2 1422 50 POP 1423 50 POP 1424 92 SWAP3 1425 95 SWAP6 1426 50 POP 1427 92 SWAP3 1428 95 SWAP6 1429 90 SWAP1 142A 93 SWAP4 142B 50 POP 142C 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1424 stack[-6] = stack[-1] // @1425 stack[-9] = stack[-6] // @1427 stack[-7] = stack[-4] // @1428 stack[-10] = stack[-7] // @142A stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_142D: // Incoming call from 0x027C, returns to 0x027D // Inputs[2] // { // @1438 stack[-1] // @1439 stack[-2] // } 142D 5B JUMPDEST 142E 60 PUSH1 0x00 1430 80 DUP1 1431 60 PUSH1 0x00 1433 80 DUP1 1434 60 PUSH1 0x00 1436 60 PUSH1 0xa0 1438 86 DUP7 1439 88 DUP9 143A 03 SUB 143B 12 SLT 143C 15 ISZERO 143D 61 PUSH2 0x1445 1440 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @142E stack[0] = 0x00 // @1430 stack[1] = 0x00 // @1431 stack[2] = 0x00 // @1433 stack[3] = 0x00 // @1434 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1445, if !(stack[-2] - stack[-1] i< 0xa0) label_1441: // Incoming jump from 0x1440, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1444 memory[0x00:0x00] } 1441 60 PUSH1 0x00 1443 80 DUP1 1444 FD *REVERT // Stack delta = +0 // Outputs[1] { @1444 revert(memory[0x00:0x00]); } // Block terminates label_1445: // Incoming jump from 0x1440, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1449 stack[-6] } 1445 5B JUMPDEST 1446 61 PUSH2 0x144e 1449 86 DUP7 144A 61 PUSH2 0x1229 144D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1446 stack[0] = 0x144e // @1449 stack[1] = stack[-6] // } // Block ends with call to 0x1229, returns to 0x144E label_144E: // Incoming return from call to 0x1229 at 0x144D // Inputs[3] // { // @144F stack[-6] // @144F stack[-1] // @1456 stack[-7] // } 144E 5B JUMPDEST 144F 94 SWAP5 1450 50 POP 1451 61 PUSH2 0x145c 1454 60 PUSH1 0x20 1456 87 DUP8 1457 01 ADD 1458 61 PUSH2 0x1229 145B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @144F stack[-6] = stack[-1] // @1451 stack[-1] = 0x145c // @1457 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1229, returns to 0x145C label_145C: // Incoming return from call to 0x1229 at 0x145B // Inputs[8] // { // @145D stack[-1] // @145D stack[-5] // @1461 stack[-7] // @1463 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1464 stack[-4] // @146A msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @146B stack[-3] // @1471 msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 145C 5B JUMPDEST 145D 93 SWAP4 145E 50 POP 145F 60 PUSH1 0x40 1461 86 DUP7 1462 01 ADD 1463 35 CALLDATALOAD 1464 92 SWAP3 1465 50 POP 1466 60 PUSH1 0x60 1468 86 DUP7 1469 01 ADD 146A 35 CALLDATALOAD 146B 91 SWAP2 146C 50 POP 146D 60 PUSH1 0x80 146F 86 DUP7 1470 01 ADD 1471 35 CALLDATALOAD 1472 60 PUSH1 0x01 1474 60 PUSH1 0x01 1476 60 PUSH1 0x40 1478 1B SHL 1479 03 SUB 147A 81 DUP2 147B 11 GT 147C 15 ISZERO 147D 61 PUSH2 0x1485 1480 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @145D stack[-5] = stack[-1] // @1464 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @146B stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @1471 stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1485, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) label_1481: // Incoming jump from 0x1480, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1484 memory[0x00:0x00] } 1481 60 PUSH1 0x00 1483 80 DUP1 1484 FD *REVERT // Stack delta = +0 // Outputs[1] { @1484 revert(memory[0x00:0x00]); } // Block terminates label_1485: // Incoming jump from 0x1480, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1489 stack[-8] // @148A stack[-1] // @148B stack[-7] // } 1485 5B JUMPDEST 1486 61 PUSH2 0x1420 1489 88 DUP9 148A 82 DUP3 148B 89 DUP10 148C 01 ADD 148D 61 PUSH2 0x12bc 1490 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1486 stack[0] = 0x1420 // @1489 stack[1] = stack[-8] // @148C stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x12bc, returns to 0x1420 label_1491: // Incoming call from 0x01EF, returns to 0x01F0 // Inputs[2] // { // @1497 stack[-1] // @1498 stack[-2] // } 1491 5B JUMPDEST 1492 60 PUSH1 0x00 1494 80 DUP1 1495 60 PUSH1 0x40 1497 83 DUP4 1498 85 DUP6 1499 03 SUB 149A 12 SLT 149B 15 ISZERO 149C 61 PUSH2 0x14a4 149F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1492 stack[0] = 0x00 // @1494 stack[1] = 0x00 // } // Block ends with conditional jump to 0x14a4, if !(stack[-2] - stack[-1] i< 0x40) label_14A0: // Incoming jump from 0x149F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @14A3 memory[0x00:0x00] } 14A0 60 PUSH1 0x00 14A2 80 DUP1 14A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @14A3 revert(memory[0x00:0x00]); } // Block terminates label_14A4: // Incoming jump from 0x149F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @14A8 stack[-3] } 14A4 5B JUMPDEST 14A5 61 PUSH2 0x14ad 14A8 83 DUP4 14A9 61 PUSH2 0x1229 14AC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14A5 stack[0] = 0x14ad // @14A8 stack[1] = stack[-3] // } // Block ends with call to 0x1229, returns to 0x14AD label_14AD: // Incoming return from call to 0x1229 at 0x14AC // Inputs[4] // { // @14AE stack[-1] // @14AE stack[-3] // @14B2 stack[-4] // @14B4 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 14AD 5B JUMPDEST 14AE 91 SWAP2 14AF 50 POP 14B0 60 PUSH1 0x20 14B2 83 DUP4 14B3 01 ADD 14B4 35 CALLDATALOAD 14B5 80 DUP1 14B6 15 ISZERO 14B7 15 ISZERO 14B8 81 DUP2 14B9 14 EQ 14BA 61 PUSH2 0x14c2 14BD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @14AE stack[-3] = stack[-1] // @14B4 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x14c2, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_14BE: // Incoming jump from 0x14BD, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @14C1 memory[0x00:0x00] } 14BE 60 PUSH1 0x00 14C0 80 DUP1 14C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @14C1 revert(memory[0x00:0x00]); } // Block terminates label_14C2: // Incoming jump from 0x14BD, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @14C3 stack[-1] // @14C4 stack[-2] // @14C7 stack[-5] // @14C9 stack[-3] // @14C9 stack[-6] // @14CA stack[-4] // } 14C2 5B JUMPDEST 14C3 80 DUP1 14C4 91 SWAP2 14C5 50 POP 14C6 50 POP 14C7 92 SWAP3 14C8 50 POP 14C9 92 SWAP3 14CA 90 SWAP1 14CB 50 POP 14CC 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @14C7 stack[-5] = stack[-1] // @14C9 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_14CD: // Incoming call from 0x00EC, returns to 0x00ED // Inputs[2] // { // @14D3 stack[-1] // @14D4 stack[-2] // } 14CD 5B JUMPDEST 14CE 60 PUSH1 0x00 14D0 80 DUP1 14D1 60 PUSH1 0x40 14D3 83 DUP4 14D4 85 DUP6 14D5 03 SUB 14D6 12 SLT 14D7 15 ISZERO 14D8 61 PUSH2 0x14e0 14DB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14CE stack[0] = 0x00 // @14D0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x14e0, if !(stack[-2] - stack[-1] i< 0x40) label_14DC: // Incoming jump from 0x14DB, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @14DF memory[0x00:0x00] } 14DC 60 PUSH1 0x00 14DE 80 DUP1 14DF FD *REVERT // Stack delta = +0 // Outputs[1] { @14DF revert(memory[0x00:0x00]); } // Block terminates label_14E0: // Incoming jump from 0x14DB, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @14E4 stack[-3] } 14E0 5B JUMPDEST 14E1 61 PUSH2 0x14e9 14E4 83 DUP4 14E5 61 PUSH2 0x1229 14E8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14E1 stack[0] = 0x14e9 // @14E4 stack[1] = stack[-3] // } // Block ends with call to 0x1229, returns to 0x14E9 label_14E9: // Incoming return from call to 0x1229 at 0x14E8 // Inputs[5] // { // @14EA stack[-6] // @14EA stack[-1] // @14ED stack[-4] // @14F1 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @14F2 stack[-5] // } 14E9 5B JUMPDEST 14EA 94 SWAP5 14EB 60 PUSH1 0x20 14ED 93 SWAP4 14EE 90 SWAP1 14EF 93 SWAP4 14F0 01 ADD 14F1 35 CALLDATALOAD 14F2 93 SWAP4 14F3 50 POP 14F4 50 POP 14F5 50 POP 14F6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @14EA stack[-6] = stack[-1] // @14F2 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_14F7: // Incoming call from 0x0199, returns to 0x019A // Inputs[2] // { // @14FD stack[-1] // @14FE stack[-2] // } 14F7 5B JUMPDEST 14F8 60 PUSH1 0x00 14FA 80 DUP1 14FB 60 PUSH1 0x40 14FD 83 DUP4 14FE 85 DUP6 14FF 03 SUB 1500 12 SLT 1501 15 ISZERO 1502 61 PUSH2 0x150a 1505 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14F8 stack[0] = 0x00 // @14FA stack[1] = 0x00 // } // Block ends with conditional jump to 0x150a, if !(stack[-2] - stack[-1] i< 0x40) label_1506: // Incoming jump from 0x1505, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1509 memory[0x00:0x00] } 1506 60 PUSH1 0x00 1508 80 DUP1 1509 FD *REVERT // Stack delta = +0 // Outputs[1] { @1509 revert(memory[0x00:0x00]); } // Block terminates label_150A: // Incoming jump from 0x1505, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @150B stack[-3] // @150C msg.data[stack[-3]:stack[-3] + 0x20] // } 150A 5B JUMPDEST 150B 82 DUP3 150C 35 CALLDATALOAD 150D 60 PUSH1 0x01 150F 60 PUSH1 0x01 1511 60 PUSH1 0x40 1513 1B SHL 1514 03 SUB 1515 80 DUP1 1516 82 DUP3 1517 11 GT 1518 15 ISZERO 1519 61 PUSH2 0x1521 151C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @150C stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1514 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x1521, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_151D: // Incoming jump from 0x151C, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1520 memory[0x00:0x00] } 151D 60 PUSH1 0x00 151F 80 DUP1 1520 FD *REVERT // Stack delta = +0 // Outputs[1] { @1520 revert(memory[0x00:0x00]); } // Block terminates label_1521: // Incoming jump from 0x151C, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1522 stack[-2] // @1523 stack[-5] // @1527 stack[-6] // } 1521 5B JUMPDEST 1522 81 DUP2 1523 85 DUP6 1524 01 ADD 1525 91 SWAP2 1526 50 POP 1527 85 DUP6 1528 60 PUSH1 0x1f 152A 83 DUP4 152B 01 ADD 152C 12 SLT 152D 61 PUSH2 0x1535 1530 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1525 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1535, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1531: // Incoming jump from 0x1530, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1534 memory[0x00:0x00] } 1531 60 PUSH1 0x00 1533 80 DUP1 1534 FD *REVERT // Stack delta = +0 // Outputs[1] { @1534 revert(memory[0x00:0x00]); } // Block terminates label_1535: // Incoming jump from 0x1530, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1536 stack[-2] // @1537 msg.data[stack[-2]:stack[-2] + 0x20] // } 1535 5B JUMPDEST 1536 81 DUP2 1537 35 CALLDATALOAD 1538 60 PUSH1 0x20 153A 61 PUSH2 0x1542 153D 82 DUP3 153E 61 PUSH2 0x1875 1541 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1537 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1538 stack[1] = 0x20 // @153A stack[2] = 0x1542 // @153D stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1875, returns to 0x1542 label_1542: // Incoming return from call to 0x1875 at 0x1541 // Inputs[2] // { // @1545 memory[0x40:0x60] // @1549 stack[-1] // } 1542 5B JUMPDEST 1543 60 PUSH1 0x40 1545 51 MLOAD 1546 61 PUSH2 0x154f 1549 82 DUP3 154A 82 DUP3 154B 61 PUSH2 0x197c 154E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1545 stack[0] = memory[0x40:0x60] // @1546 stack[1] = 0x154f // @1549 stack[2] = stack[-1] // @154A stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x197c, returns to 0x154F label_154F: // Incoming return from call to 0x197C at 0x154E // Inputs[6] // { // @1550 stack[-4] // @1551 stack[-1] // @1553 stack[-3] // @1556 stack[-2] // @1558 stack[-6] // @1564 stack[-10] // } 154F 5B JUMPDEST 1550 83 DUP4 1551 81 DUP2 1552 52 MSTORE 1553 82 DUP3 1554 81 DUP2 1555 01 ADD 1556 91 SWAP2 1557 50 POP 1558 85 DUP6 1559 83 DUP4 155A 01 ADD 155B 60 PUSH1 0x05 155D 85 DUP6 155E 90 SWAP1 155F 1B SHL 1560 87 DUP8 1561 01 ADD 1562 84 DUP5 1563 01 ADD 1564 8B DUP12 1565 10 LT 1566 15 ISZERO 1567 61 PUSH2 0x156f 156A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1552 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1556 stack[-2] = stack[-1] + stack[-3] // @155A stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x156f, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_156B: // Incoming jump from 0x156A, if not !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[1] { @156E memory[0x00:0x00] } 156B 60 PUSH1 0x00 156D 80 DUP1 156E FD *REVERT // Stack delta = +0 // Outputs[1] { @156E revert(memory[0x00:0x00]); } // Block terminates label_156F: // Incoming jump from 0x156A, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1572 stack[-7] // @1575 stack[-5] // } 156F 5B JUMPDEST 1570 60 PUSH1 0x00 1572 96 SWAP7 1573 50 POP 1574 5B JUMPDEST 1575 84 DUP5 1576 87 DUP8 1577 10 LT 1578 15 ISZERO 1579 61 PUSH2 0x1599 157C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1572 stack[-7] = 0x00 } // Block ends with conditional jump to 0x1599, if !(0x00 < stack[-5]) label_157D: // Incoming jump from 0x157C, if not !(stack[-7] < stack[-5]) // Incoming jump from 0x157C, if not !(0x00 < stack[-5]) // Inputs[1] { @1580 stack[-1] } 157D 61 PUSH2 0x1585 1580 81 DUP2 1581 61 PUSH2 0x1229 1584 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @157D stack[0] = 0x1585 // @1580 stack[1] = stack[-1] // } // Block ends with call to 0x1229, returns to 0x1585 label_1585: // Incoming return from call to 0x1229 at 0x1584 // Inputs[5] // { // @1586 stack[-4] // @1587 stack[-1] // @158A stack[-8] // @158B stack[-2] // @1590 stack[-5] // } 1585 5B JUMPDEST 1586 83 DUP4 1587 52 MSTORE 1588 60 PUSH1 0x01 158A 96 SWAP7 158B 90 SWAP1 158C 96 SWAP7 158D 01 ADD 158E 95 SWAP6 158F 91 SWAP2 1590 83 DUP4 1591 01 ADD 1592 91 SWAP2 1593 83 DUP4 1594 01 ADD 1595 61 PUSH2 0x1574 1598 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1587 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @158E stack[-8] = 0x01 + stack[-8] // @1592 stack[-4] = stack[-5] + stack[-4] // @1594 stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x1574 label_1599: // Incoming jump from 0x157C, if !(stack[-7] < stack[-5]) // Incoming jump from 0x157C, if !(0x00 < stack[-5]) // Inputs[7] // { // @159B stack[-2] // @159B stack[-9] // @159E stack[-10] // @159F stack[-4] // @15A0 msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // @15A1 stack[-7] // @15A4 stack[-6] // } 1599 5B JUMPDEST 159A 50 POP 159B 96 SWAP7 159C 50 POP 159D 50 POP 159E 86 DUP7 159F 01 ADD 15A0 35 CALLDATALOAD 15A1 92 SWAP3 15A2 50 POP 15A3 50 POP 15A4 80 DUP1 15A5 82 DUP3 15A6 11 GT 15A7 15 ISZERO 15A8 61 PUSH2 0x15b0 15AB 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @159B stack[-9] = stack[-2] // @15A1 stack[-7] = msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // } // Block ends with conditional jump to 0x15b0, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) label_15AC: // Incoming jump from 0x15AB, if not !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[1] { @15AF memory[0x00:0x00] } 15AC 60 PUSH1 0x00 15AE 80 DUP1 15AF FD *REVERT // Stack delta = +0 // Outputs[1] { @15AF revert(memory[0x00:0x00]); } // Block terminates label_15B0: // Incoming jump from 0x15AB, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[3] // { // @15B5 stack[-6] // @15B6 stack[-2] // @15B7 stack[-5] // } 15B0 5B JUMPDEST 15B1 50 POP 15B2 61 PUSH2 0x15bd 15B5 85 DUP6 15B6 82 DUP3 15B7 86 DUP7 15B8 01 ADD 15B9 61 PUSH2 0x1245 15BC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15B2 stack[-1] = 0x15bd // @15B5 stack[0] = stack[-6] // @15B8 stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x1245, returns to 0x15BD label_15BD: // Incoming return from call to 0x1245 at 0x15BC // Inputs[6] // { // @15BE stack[-3] // @15BE stack[-1] // @15C1 stack[-6] // @15C3 stack[-7] // @15C3 stack[-4] // @15C4 stack[-5] // } 15BD 5B JUMPDEST 15BE 91 SWAP2 15BF 50 POP 15C0 50 POP 15C1 92 SWAP3 15C2 50 POP 15C3 92 SWAP3 15C4 90 SWAP1 15C5 50 POP 15C6 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @15C1 stack[-6] = stack[-1] // @15C3 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_15C7: // Incoming call from 0x0112, returns to 0x0113 // Inputs[2] // { // @15CC stack[-1] // @15CD stack[-2] // } 15C7 5B JUMPDEST 15C8 60 PUSH1 0x00 15CA 60 PUSH1 0x20 15CC 82 DUP3 15CD 84 DUP5 15CE 03 SUB 15CF 12 SLT 15D0 15 ISZERO 15D1 61 PUSH2 0x15d9 15D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15C8 stack[0] = 0x00 } // Block ends with conditional jump to 0x15d9, if !(stack[-2] - stack[-1] i< 0x20) label_15D5: // Incoming jump from 0x15D4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @15D8 memory[0x00:0x00] } 15D5 60 PUSH1 0x00 15D7 80 DUP1 15D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @15D8 revert(memory[0x00:0x00]); } // Block terminates label_15D9: // Incoming jump from 0x15D4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15DA stack[-2] // @15DB msg.data[stack[-2]:stack[-2] + 0x20] // } 15D9 5B JUMPDEST 15DA 81 DUP2 15DB 35 CALLDATALOAD 15DC 61 PUSH2 0x134a 15DF 81 DUP2 15E0 61 PUSH2 0x1ad4 15E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15DB stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @15DC stack[1] = 0x134a // @15DF stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1ad4, returns to 0x134A label_15E4: // Incoming jump from 0x11E9 // Inputs[2] // { // @15E9 stack[-1] // @15EA stack[-2] // } 15E4 5B JUMPDEST 15E5 60 PUSH1 0x00 15E7 60 PUSH1 0x20 15E9 82 DUP3 15EA 84 DUP5 15EB 03 SUB 15EC 12 SLT 15ED 15 ISZERO 15EE 61 PUSH2 0x15f6 15F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15E5 stack[0] = 0x00 } // Block ends with conditional jump to 0x15f6, if !(stack[-2] - stack[-1] i< 0x20) label_15F2: // Incoming jump from 0x15F1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @15F5 memory[0x00:0x00] } 15F2 60 PUSH1 0x00 15F4 80 DUP1 15F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @15F5 revert(memory[0x00:0x00]); } // Block terminates label_15F6: // Incoming jump from 0x15F1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @15F7 stack[-2] // @15F8 memory[stack[-2]:stack[-2] + 0x20] // } 15F6 5B JUMPDEST 15F7 81 DUP2 15F8 51 MLOAD 15F9 61 PUSH2 0x134a 15FC 81 DUP2 15FD 61 PUSH2 0x1ad4 1600 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15F8 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @15F9 stack[1] = 0x134a // @15FC stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1ad4, returns to 0x134A label_1601: // Incoming call from 0x01C1, returns to 0x01C2 // Incoming call from 0x01D4, returns to 0x01D5 // Incoming call from 0x0202, returns to 0x0203 // Incoming call from 0x014A, returns to 0x014B // Inputs[2] // { // @1606 stack[-1] // @1607 stack[-2] // } 1601 5B JUMPDEST 1602 60 PUSH1 0x00 1604 60 PUSH1 0x20 1606 82 DUP3 1607 84 DUP5 1608 03 SUB 1609 12 SLT 160A 15 ISZERO 160B 61 PUSH2 0x1613 160E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1602 stack[0] = 0x00 } // Block ends with conditional jump to 0x1613, if !(stack[-2] - stack[-1] i< 0x20) label_160F: // Incoming jump from 0x160E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1612 memory[0x00:0x00] } 160F 60 PUSH1 0x00 1611 80 DUP1 1612 FD *REVERT // Stack delta = +0 // Outputs[1] { @1612 revert(memory[0x00:0x00]); } // Block terminates label_1613: // Incoming jump from 0x160E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1615 msg.data[stack[-2]:stack[-2] + 0x20] // @1615 stack[-2] // @1616 stack[-4] // @1617 stack[-3] // } 1613 5B JUMPDEST 1614 50 POP 1615 35 CALLDATALOAD 1616 91 SWAP2 1617 90 SWAP1 1618 50 POP 1619 56 *JUMP // Stack delta = -3 // Outputs[1] { @1616 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_161A: // Incoming call from 0x1765, returns to 0x134A // Inputs[3] // { // @161D stack[-1] // @161E memory[stack[-1]:stack[-1] + 0x20] // @1620 stack[-2] // } 161A 5B JUMPDEST 161B 60 PUSH1 0x00 161D 81 DUP2 161E 51 MLOAD 161F 80 DUP1 1620 84 DUP5 1621 52 MSTORE 1622 60 PUSH1 0x20 1624 80 DUP1 1625 85 DUP6 1626 01 ADD 1627 94 SWAP5 1628 50 POP 1629 80 DUP1 162A 84 DUP5 162B 01 ADD 162C 60 PUSH1 0x00 162E 5B JUMPDEST 162F 83 DUP4 1630 81 DUP2 1631 10 LT 1632 15 ISZERO 1633 61 PUSH2 0x164a 1636 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @161B stack[0] = 0x00 // @161E stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1621 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1622 stack[2] = 0x20 // @1627 stack[-2] = stack[-2] + 0x20 // @162B stack[3] = stack[-1] + 0x20 // @162C stack[4] = 0x00 // } // Block ends with conditional jump to 0x164a, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1637: // Incoming jump from 0x1636, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1636, if not !(stack[-1] < stack[-4]) // Inputs[5] // { // @1637 stack[-2] // @1638 memory[stack[-2]:stack[-2] + 0x20] // @1639 stack[-7] // @163B stack[-1] // @163C stack[-3] // } 1637 81 DUP2 1638 51 MLOAD 1639 87 DUP8 163A 52 MSTORE 163B 95 SWAP6 163C 82 DUP3 163D 01 ADD 163E 95 SWAP6 163F 90 SWAP1 1640 82 DUP3 1641 01 ADD 1642 90 SWAP1 1643 60 PUSH1 0x01 1645 01 ADD 1646 61 PUSH2 0x162e 1649 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @163A memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @163E stack[-7] = stack[-3] + stack[-7] // @1642 stack[-2] = stack[-3] + stack[-2] // @1645 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x162e label_164A: // Incoming jump from 0x1636, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1636, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @164C stack[-7] // @164C stack[-2] // @164D stack[-8] // } 164A 5B JUMPDEST 164B 50 POP 164C 94 SWAP5 164D 95 SWAP6 164E 94 SWAP5 164F 50 POP 1650 50 POP 1651 50 POP 1652 50 POP 1653 50 POP 1654 56 *JUMP // Stack delta = -7 // Outputs[1] { @164D stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1655: // Incoming call from 0x1747, returns to 0x1748 // Incoming call from 0x179D, returns to 0x134A // Inputs[3] // { // @1658 stack[-1] // @1659 memory[stack[-1]:stack[-1] + 0x20] // @165B stack[-2] // } 1655 5B JUMPDEST 1656 60 PUSH1 0x00 1658 81 DUP2 1659 51 MLOAD 165A 80 DUP1 165B 84 DUP5 165C 52 MSTORE 165D 61 PUSH2 0x166d 1660 81 DUP2 1661 60 PUSH1 0x20 1663 86 DUP7 1664 01 ADD 1665 60 PUSH1 0x20 1667 86 DUP7 1668 01 ADD 1669 61 PUSH2 0x18fa 166C 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1656 stack[0] = 0x00 // @1659 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @165C memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @165D stack[2] = 0x166d // @1660 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1664 stack[4] = stack[-2] + 0x20 // @1668 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x18fa, returns to 0x166D label_166D: // Incoming return from call to 0x18FA at 0x166C // Inputs[4] // { // @1670 stack[-1] // @1675 stack[-4] // @1676 stack[-2] // @167C stack[-5] // } 166D 5B JUMPDEST 166E 60 PUSH1 0x1f 1670 01 ADD 1671 60 PUSH1 0x1f 1673 19 NOT 1674 16 AND 1675 92 SWAP3 1676 90 SWAP1 1677 92 SWAP3 1678 01 ADD 1679 60 PUSH1 0x20 167B 01 ADD 167C 92 SWAP3 167D 91 SWAP2 167E 50 POP 167F 50 POP 1680 56 *JUMP // Stack delta = -4 // Outputs[1] { @167C stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1681: // Incoming call from 0x0968, returns to 0x0969 // Inputs[3] // { // @1684 stack[-3] // @1685 memory[stack[-3]:stack[-3] + 0x20] // @168A stack[-1] // } 1681 5B JUMPDEST 1682 60 PUSH1 0x00 1684 83 DUP4 1685 51 MLOAD 1686 61 PUSH2 0x1693 1689 81 DUP2 168A 84 DUP5 168B 60 PUSH1 0x20 168D 88 DUP9 168E 01 ADD 168F 61 PUSH2 0x18fa 1692 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1682 stack[0] = 0x00 // @1685 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @1686 stack[2] = 0x1693 // @1689 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @168A stack[4] = stack[-1] // @168E stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x18fa, returns to 0x1693 label_1693: // Incoming return from call to 0x18FA at 0x1692 // Inputs[4] // { // @1694 stack[-4] // @1695 memory[stack[-4]:stack[-4] + 0x20] // @1696 stack[-1] // @1697 stack[-3] // } 1693 5B JUMPDEST 1694 83 DUP4 1695 51 MLOAD 1696 90 SWAP1 1697 83 DUP4 1698 01 ADD 1699 90 SWAP1 169A 61 PUSH2 0x16a7 169D 81 DUP2 169E 83 DUP4 169F 60 PUSH1 0x20 16A1 88 DUP9 16A2 01 ADD 16A3 61 PUSH2 0x18fa 16A6 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1699 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @1699 stack[-1] = stack[-3] + stack[-1] // @169A stack[1] = 0x16a7 // @169D stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @169E stack[3] = stack[-3] + stack[-1] // @16A2 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x18fa, returns to 0x16A7 label_16A7: // Incoming return from call to 0x18FA at 0x16A6 // Inputs[4] // { // @16A8 stack[-2] // @16A8 stack[-1] // @16A9 stack[-7] // @16AA stack[-6] // } 16A7 5B JUMPDEST 16A8 01 ADD 16A9 94 SWAP5 16AA 93 SWAP4 16AB 50 POP 16AC 50 POP 16AD 50 POP 16AE 50 POP 16AF 56 *JUMP // Stack delta = -6 // Outputs[1] { @16A9 stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 16B0 5B JUMPDEST 16B1 60 PUSH1 0x01 16B3 60 PUSH1 0x01 16B5 60 PUSH1 0xa0 16B7 1B SHL 16B8 03 SUB 16B9 86 DUP7 16BA 81 DUP2 16BB 16 AND 16BC 82 DUP3 16BD 52 MSTORE 16BE 85 DUP6 16BF 16 AND 16C0 60 PUSH1 0x20 16C2 82 DUP3 16C3 01 ADD 16C4 52 MSTORE 16C5 60 PUSH1 0xa0 16C7 60 PUSH1 0x40 16C9 82 DUP3 16CA 01 ADD 16CB 81 DUP2 16CC 90 SWAP1 16CD 52 MSTORE 16CE 60 PUSH1 0x00 16D0 90 SWAP1 16D1 61 PUSH2 0x16dc 16D4 90 SWAP1 16D5 83 DUP4 16D6 01 ADD 16D7 86 DUP7 16D8 61 PUSH2 0x161a 16DB 56 *JUMP 16DC 5B JUMPDEST 16DD 82 DUP3 16DE 81 DUP2 16DF 03 SUB 16E0 60 PUSH1 0x60 16E2 84 DUP5 16E3 01 ADD 16E4 52 MSTORE 16E5 61 PUSH2 0x16ee 16E8 81 DUP2 16E9 86 DUP7 16EA 61 PUSH2 0x161a 16ED 56 *JUMP 16EE 5B JUMPDEST 16EF 90 SWAP1 16F0 50 POP 16F1 82 DUP3 16F2 81 DUP2 16F3 03 SUB 16F4 60 PUSH1 0x80 16F6 84 DUP5 16F7 01 ADD 16F8 52 MSTORE 16F9 61 PUSH2 0x1702 16FC 81 DUP2 16FD 85 DUP6 16FE 61 PUSH2 0x1655 1701 56 *JUMP 1702 5B JUMPDEST 1703 98 SWAP9 1704 97 SWAP8 1705 50 POP 1706 50 POP 1707 50 POP 1708 50 POP 1709 50 POP 170A 50 POP 170B 50 POP 170C 50 POP 170D 56 *JUMP label_170E: // Incoming call from 0x11A2, returns to 0x11A3 // Inputs[6] // { // @1717 stack[-6] // @171A stack[-1] // @171C stack[-5] // @1727 stack[-4] // @172E stack[-3] // @1743 stack[-2] // } 170E 5B JUMPDEST 170F 60 PUSH1 0x01 1711 60 PUSH1 0x01 1713 60 PUSH1 0xa0 1715 1B SHL 1716 03 SUB 1717 86 DUP7 1718 81 DUP2 1719 16 AND 171A 82 DUP3 171B 52 MSTORE 171C 85 DUP6 171D 16 AND 171E 60 PUSH1 0x20 1720 82 DUP3 1721 01 ADD 1722 52 MSTORE 1723 60 PUSH1 0x40 1725 81 DUP2 1726 01 ADD 1727 84 DUP5 1728 90 SWAP1 1729 52 MSTORE 172A 60 PUSH1 0x60 172C 81 DUP2 172D 01 ADD 172E 83 DUP4 172F 90 SWAP1 1730 52 MSTORE 1731 60 PUSH1 0xa0 1733 60 PUSH1 0x80 1735 82 DUP3 1736 01 ADD 1737 81 DUP2 1738 90 SWAP1 1739 52 MSTORE 173A 60 PUSH1 0x00 173C 90 SWAP1 173D 61 PUSH2 0x1748 1740 90 SWAP1 1741 83 DUP4 1742 01 ADD 1743 84 DUP5 1744 61 PUSH2 0x1655 1747 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @171B memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1722 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1729 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @1730 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-3] // @1739 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = 0xa0 // @173C stack[0] = 0x00 // @1740 stack[1] = 0x1748 // @1742 stack[2] = stack[-1] + 0xa0 // @1743 stack[3] = stack[-2] // } // Block ends with call to 0x1655, returns to 0x1748 label_1748: // Incoming return from call to 0x1655 at 0x1747 // Inputs[3] // { // @1749 stack[-1] // @1749 stack[-9] // @174A stack[-8] // } 1748 5B JUMPDEST 1749 97 SWAP8 174A 96 SWAP7 174B 50 POP 174C 50 POP 174D 50 POP 174E 50 POP 174F 50 POP 1750 50 POP 1751 50 POP 1752 56 *JUMP // Stack delta = -8 // Outputs[1] { @1749 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_1753: // Incoming jump from 0x01AB // Inputs[2] // { // @1756 stack[-1] // @1761 stack[-2] // } 1753 5B JUMPDEST 1754 60 PUSH1 0x20 1756 81 DUP2 1757 52 MSTORE 1758 60 PUSH1 0x00 175A 61 PUSH2 0x134a 175D 60 PUSH1 0x20 175F 83 DUP4 1760 01 ADD 1761 84 DUP5 1762 61 PUSH2 0x161a 1765 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1757 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1758 stack[0] = 0x00 // @175A stack[1] = 0x134a // @1760 stack[2] = stack[-1] + 0x20 // @1761 stack[3] = stack[-2] // } // Block ends with call to 0x161a, returns to 0x134A 1766 5B JUMPDEST 1767 60 PUSH1 0x40 1769 81 DUP2 176A 52 MSTORE 176B 60 PUSH1 0x00 176D 61 PUSH2 0x1779 1770 60 PUSH1 0x40 1772 83 DUP4 1773 01 ADD 1774 85 DUP6 1775 61 PUSH2 0x161a 1778 56 *JUMP 1779 5B JUMPDEST 177A 82 DUP3 177B 81 DUP2 177C 03 SUB 177D 60 PUSH1 0x20 177F 84 DUP5 1780 01 ADD 1781 52 MSTORE 1782 61 PUSH2 0x0d1e 1785 81 DUP2 1786 85 DUP6 1787 61 PUSH2 0x161a 178A 56 *JUMP label_178B: // Incoming jump from 0x013C // Incoming jump from 0x0F8D // Inputs[2] // { // @178E stack[-1] // @1799 stack[-2] // } 178B 5B JUMPDEST 178C 60 PUSH1 0x20 178E 81 DUP2 178F 52 MSTORE 1790 60 PUSH1 0x00 1792 61 PUSH2 0x134a 1795 60 PUSH1 0x20 1797 83 DUP4 1798 01 ADD 1799 84 DUP5 179A 61 PUSH2 0x1655 179D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @178F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1790 stack[0] = 0x00 // @1792 stack[1] = 0x134a // @1798 stack[2] = stack[-1] + 0x20 // @1799 stack[3] = stack[-2] // } // Block ends with call to 0x1655, returns to 0x134A label_179E: // Incoming call from 0x1228, returns to 0x02EA // Inputs[2] // { // @17A2 stack[-1] // @17E4 stack[-2] // } 179E 5B JUMPDEST 179F 60 PUSH1 0x20 17A1 80 DUP1 17A2 82 DUP3 17A3 52 MSTORE 17A4 60 PUSH1 0x28 17A6 90 SWAP1 17A7 82 DUP3 17A8 01 ADD 17A9 52 MSTORE 17AA 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 17CB 60 PUSH1 0x40 17CD 82 DUP3 17CE 01 ADD 17CF 52 MSTORE 17D0 67 PUSH8 0x6420746f6b656e73 17D9 60 PUSH1 0xc0 17DB 1B SHL 17DC 60 PUSH1 0x60 17DE 82 DUP3 17DF 01 ADD 17E0 52 MSTORE 17E1 60 PUSH1 0x80 17E3 01 ADD 17E4 90 SWAP1 17E5 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @17A3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @17A9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x28 // @17CF memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @17E0 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6420746f6b656e73 << 0xc0 // @17E4 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_17E6: // Incoming call from 0x0DCB, returns to 0x02EA // Inputs[2] // { // @17EA stack[-1] // @1829 stack[-2] // } 17E6 5B JUMPDEST 17E7 60 PUSH1 0x20 17E9 80 DUP1 17EA 82 DUP3 17EB 52 MSTORE 17EC 60 PUSH1 0x25 17EE 90 SWAP1 17EF 82 DUP3 17F0 01 ADD 17F1 52 MSTORE 17F2 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 1813 60 PUSH1 0x40 1815 82 DUP3 1816 01 ADD 1817 52 MSTORE 1818 64 PUSH5 0x6472657373 181E 60 PUSH1 0xd8 1820 1B SHL 1821 60 PUSH1 0x60 1823 82 DUP3 1824 01 ADD 1825 52 MSTORE 1826 60 PUSH1 0x80 1828 01 ADD 1829 90 SWAP1 182A 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @17EB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @17F1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @1817 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 // @1825 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6472657373 << 0xd8 // @1829 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_182B: // Incoming call from 0x0E25, returns to 0x02EA // Inputs[2] // { // @182F stack[-1] // @1873 stack[-2] // } 182B 5B JUMPDEST 182C 60 PUSH1 0x20 182E 80 DUP1 182F 82 DUP3 1830 52 MSTORE 1831 60 PUSH1 0x2a 1833 90 SWAP1 1834 82 DUP3 1835 01 ADD 1836 52 MSTORE 1837 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 1858 60 PUSH1 0x40 185A 82 DUP3 185B 01 ADD 185C 52 MSTORE 185D 69 PUSH10 0x39103a3930b739b332b9 1868 60 PUSH1 0xb1 186A 1B SHL 186B 60 PUSH1 0x60 186D 82 DUP3 186E 01 ADD 186F 52 MSTORE 1870 60 PUSH1 0x80 1872 01 ADD 1873 90 SWAP1 1874 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1830 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1836 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2a // @185C memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a20696e73756666696369656e742062616c616e636520666f // @186F memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x39103a3930b739b332b9 << 0xb1 // @1873 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1875: // Incoming call from 0x1541, returns to 0x1542 // Incoming call from 0x1262, returns to 0x1263 // Inputs[1] { @1880 stack[-1] } 1875 5B JUMPDEST 1876 60 PUSH1 0x00 1878 60 PUSH1 0x01 187A 60 PUSH1 0x01 187C 60 PUSH1 0x40 187E 1B SHL 187F 03 SUB 1880 82 DUP3 1881 11 GT 1882 15 ISZERO 1883 61 PUSH2 0x188e 1886 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1876 stack[0] = 0x00 } // Block ends with conditional jump to 0x188e, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_1887: // Incoming jump from 0x1886, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 1887 61 PUSH2 0x188e 188A 61 PUSH2 0x1a19 188D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1887 stack[0] = 0x188e } // Block ends with unconditional jump to 0x1a19 label_188E: // Incoming jump from 0x1886, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1892 stack[-2] // @1896 stack[-3] // } 188E 5B JUMPDEST 188F 50 POP 1890 60 PUSH1 0x05 1892 1B SHL 1893 60 PUSH1 0x20 1895 01 ADD 1896 90 SWAP1 1897 56 *JUMP // Stack delta = -2 // Outputs[1] { @1896 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_1898: // Incoming call from 0x10C5, returns to 0x10C6 // Incoming call from 0x0D1D, returns to 0x0D1E // Incoming call from 0x0E62, returns to 0x0E63 // Incoming call from 0x0D59, returns to 0x0D5A // Inputs[2] // { // @189B stack[-2] // @189D stack[-1] // } 1898 5B JUMPDEST 1899 60 PUSH1 0x00 189B 82 DUP3 189C 19 NOT 189D 82 DUP3 189E 11 GT 189F 15 ISZERO 18A0 61 PUSH2 0x18ab 18A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1899 stack[0] = 0x00 } // Block ends with conditional jump to 0x18ab, if !(stack[-1] > ~stack[-2]) label_18A4: // Incoming jump from 0x18A3, if not !(stack[-1] > ~stack[-2]) 18A4 61 PUSH2 0x18ab 18A7 61 PUSH2 0x19d7 18AA 56 *JUMP // Stack delta = +1 // Outputs[1] { @18A4 stack[0] = 0x18ab } // Block ends with unconditional jump to 0x19d7 label_18AB: // Incoming jump from 0x18A3, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @18AD stack[-3] // @18AD stack[-2] // @18AE stack[-4] // } 18AB 5B JUMPDEST 18AC 50 POP 18AD 01 ADD 18AE 90 SWAP1 18AF 56 *JUMP // Stack delta = -3 // Outputs[1] { @18AE stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_18B0: // Incoming call from 0x075A, returns to 0x033E // Inputs[1] { @18B3 stack[-2] } 18B0 5B JUMPDEST 18B1 60 PUSH1 0x00 18B3 82 DUP3 18B4 61 PUSH2 0x18bf 18B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18B1 stack[0] = 0x00 } // Block ends with conditional jump to 0x18bf, if stack[-2] label_18B8: // Incoming jump from 0x18B7, if not stack[-2] 18B8 61 PUSH2 0x18bf 18BB 61 PUSH2 0x19ed 18BE 56 *JUMP // Stack delta = +1 // Outputs[1] { @18B8 stack[0] = 0x18bf } // Block ends with unconditional jump to 0x19ed label_18BF: // Incoming jump from 0x18B7, if stack[-2] // Inputs[3] // { // @18C1 stack[-3] // @18C1 stack[-2] // @18C2 stack[-4] // } 18BF 5B JUMPDEST 18C0 50 POP 18C1 04 DIV 18C2 90 SWAP1 18C3 56 *JUMP // Stack delta = -3 // Outputs[1] { @18C2 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_18C4: // Incoming call from 0x0750, returns to 0x0751 // Inputs[2] // { // @18C7 stack[-1] // @18CC stack[-2] // } 18C4 5B JUMPDEST 18C5 60 PUSH1 0x00 18C7 81 DUP2 18C8 60 PUSH1 0x00 18CA 19 NOT 18CB 04 DIV 18CC 83 DUP4 18CD 11 GT 18CE 82 DUP3 18CF 15 ISZERO 18D0 15 ISZERO 18D1 16 AND 18D2 15 ISZERO 18D3 61 PUSH2 0x18de 18D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18C5 stack[0] = 0x00 } // Block ends with conditional jump to 0x18de, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_18D7: // Incoming jump from 0x18D6, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 18D7 61 PUSH2 0x18de 18DA 61 PUSH2 0x19d7 18DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @18D7 stack[0] = 0x18de } // Block ends with unconditional jump to 0x19d7 label_18DE: // Incoming jump from 0x18D6, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @18E0 stack[-2] // @18E0 stack[-3] // @18E1 stack[-4] // } 18DE 5B JUMPDEST 18DF 50 POP 18E0 02 MUL 18E1 90 SWAP1 18E2 56 *JUMP // Stack delta = -3 // Outputs[1] { @18E1 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_18E3: // Incoming call from 0x0732, returns to 0x0733 // Incoming call from 0x0D09, returns to 0x0D0A // Inputs[2] // { // @18E6 stack[-2] // @18E7 stack[-1] // } 18E3 5B JUMPDEST 18E4 60 PUSH1 0x00 18E6 82 DUP3 18E7 82 DUP3 18E8 10 LT 18E9 15 ISZERO 18EA 61 PUSH2 0x18f5 18ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18E4 stack[0] = 0x00 } // Block ends with conditional jump to 0x18f5, if !(stack[-1] < stack[-2]) label_18EE: // Incoming jump from 0x18ED, if not !(stack[-1] < stack[-2]) 18EE 61 PUSH2 0x18f5 18F1 61 PUSH2 0x19d7 18F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @18EE stack[0] = 0x18f5 } // Block ends with unconditional jump to 0x19d7 label_18F5: // Incoming jump from 0x18ED, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @18F7 stack[-3] // @18F7 stack[-2] // @18F8 stack[-4] // } 18F5 5B JUMPDEST 18F6 50 POP 18F7 03 SUB 18F8 90 SWAP1 18F9 56 *JUMP // Stack delta = -3 // Outputs[1] { @18F8 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_18FA: // Incoming call from 0x166C, returns to 0x166D // Incoming call from 0x16A6, returns to 0x16A7 // Incoming call from 0x1692, returns to 0x1693 // Inputs[1] { @18FE stack[-3] } 18FA 5B JUMPDEST 18FB 60 PUSH1 0x00 18FD 5B JUMPDEST 18FE 83 DUP4 18FF 81 DUP2 1900 10 LT 1901 15 ISZERO 1902 61 PUSH2 0x1915 1905 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18FB stack[0] = 0x00 } // Block ends with conditional jump to 0x1915, if !(0x00 < stack[-3]) label_1906: // Incoming jump from 0x1905, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1905, if not !(0x00 < stack[-3]) // Inputs[4] // { // @1906 stack[-2] // @1907 stack[-1] // @1909 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @190A stack[-3] // } 1906 81 DUP2 1907 81 DUP2 1908 01 ADD 1909 51 MLOAD 190A 83 DUP4 190B 82 DUP3 190C 01 ADD 190D 52 MSTORE 190E 60 PUSH1 0x20 1910 01 ADD 1911 61 PUSH2 0x18fd 1914 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @190D memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1910 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x18fd label_1915: // Incoming jump from 0x1905, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1905, if !(0x00 < stack[-3]) // Inputs[2] // { // @1916 stack[-4] // @1917 stack[-1] // } 1915 5B JUMPDEST 1916 83 DUP4 1917 81 DUP2 1918 11 GT 1919 15 ISZERO 191A 61 PUSH2 0x1924 191D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1924, if !(stack[-1] > stack[-4]) label_191E: // Incoming jump from 0x191D, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1920 stack[-4] // @1921 stack[-3] // @1929 stack[-5] // } 191E 60 PUSH1 0x00 1920 84 DUP5 1921 84 DUP5 1922 01 ADD 1923 52 MSTORE 1924 5B JUMPDEST 1925 50 POP 1926 50 POP 1927 50 POP 1928 50 POP 1929 56 *JUMP // Stack delta = -5 // Outputs[1] { @1923 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_192A: // Incoming call from 0x0D30, returns to 0x0D31 // Inputs[1] { @192D stack[-1] } 192A 5B JUMPDEST 192B 60 PUSH1 0x00 192D 81 DUP2 192E 61 PUSH2 0x1939 1931 57 *JUMPI // Stack delta = +1 // Outputs[1] { @192B stack[0] = 0x00 } // Block ends with conditional jump to 0x1939, if stack[-1] label_1932: // Incoming jump from 0x1931, if not stack[-1] 1932 61 PUSH2 0x1939 1935 61 PUSH2 0x19d7 1938 56 *JUMP // Stack delta = +1 // Outputs[1] { @1932 stack[0] = 0x1939 } // Block ends with unconditional jump to 0x19d7 label_1939: // Incoming jump from 0x1931, if stack[-1] // Inputs[2] // { // @193E stack[-2] // @193F stack[-3] // } 1939 5B JUMPDEST 193A 50 POP 193B 60 PUSH1 0x00 193D 19 NOT 193E 01 ADD 193F 90 SWAP1 1940 56 *JUMP // Stack delta = -2 // Outputs[1] { @193F stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1941: // Incoming call from 0x0443, returns to 0x0444 // Incoming call from 0x0767, returns to 0x0351 // Incoming call from 0x0350, returns to 0x0351 // Incoming call from 0x085D, returns to 0x0351 // Incoming call from 0x037C, returns to 0x037D // Incoming call from 0x0417, returns to 0x0418 // Inputs[1] { @1944 stack[-1] } 1941 5B JUMPDEST 1942 60 PUSH1 0x01 1944 81 DUP2 1945 81 DUP2 1946 1C SHR 1947 90 SWAP1 1948 82 DUP3 1949 16 AND 194A 80 DUP1 194B 61 PUSH2 0x1955 194E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1947 stack[0] = stack[-1] >> 0x01 // @1949 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1955, if stack[-1] & 0x01 label_194F: // Incoming jump from 0x194E, if not stack[-1] & 0x01 // Inputs[2] // { // @1951 stack[-2] // @195A stack[-1] // } 194F 60 PUSH1 0x7f 1951 82 DUP3 1952 16 AND 1953 91 SWAP2 1954 50 POP 1955 5B JUMPDEST 1956 60 PUSH1 0x20 1958 82 DUP3 1959 10 LT 195A 81 DUP2 195B 14 EQ 195C 15 ISZERO 195D 61 PUSH2 0x1976 1960 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1953 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1976, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1961: // Incoming jump from 0x1960, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1960, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @1975 memory[0x00:0x24] } 1961 63 PUSH4 0x4e487b71 1966 60 PUSH1 0xe0 1968 1B SHL 1969 60 PUSH1 0x00 196B 52 MSTORE 196C 60 PUSH1 0x22 196E 60 PUSH1 0x04 1970 52 MSTORE 1971 60 PUSH1 0x24 1973 60 PUSH1 0x00 1975 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @196B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1970 memory[0x04:0x24] = 0x22 // @1975 revert(memory[0x00:0x24]); // } // Block terminates label_1976: // Incoming jump from 0x1960, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1960, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @1978 stack[-4] // @1978 stack[-2] // @1979 stack[-3] // } 1976 5B JUMPDEST 1977 50 POP 1978 91 SWAP2 1979 90 SWAP1 197A 50 POP 197B 56 *JUMP // Stack delta = -3 // Outputs[1] { @1978 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_197C: // Incoming call from 0x1AC8, returns to 0x1AC9 // Incoming call from 0x12FC, returns to 0x12FD // Incoming call from 0x126F, returns to 0x1270 // Incoming call from 0x154E, returns to 0x154F // Inputs[2] // { // @197F stack[-2] // @1985 stack[-1] // } 197C 5B JUMPDEST 197D 60 PUSH1 0x1f 197F 82 DUP3 1980 01 ADD 1981 60 PUSH1 0x1f 1983 19 NOT 1984 16 AND 1985 81 DUP2 1986 01 ADD 1987 60 PUSH1 0x01 1989 60 PUSH1 0x01 198B 60 PUSH1 0x40 198D 1B SHL 198E 03 SUB 198F 81 DUP2 1990 11 GT 1991 82 DUP3 1992 82 DUP3 1993 10 LT 1994 17 OR 1995 15 ISZERO 1996 61 PUSH2 0x19a1 1999 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1986 stack[0] = stack[-1] + (~0x1f & stack[-2] + 0x1f) } // Block ends with conditional jump to 0x19a1, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) label_199A: // Incoming jump from 0x1999, if not !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) 199A 61 PUSH2 0x19a1 199D 61 PUSH2 0x1a19 19A0 56 *JUMP // Stack delta = +1 // Outputs[1] { @199A stack[0] = 0x19a1 } // Block ends with unconditional jump to 0x1a19 label_19A1: // Incoming jump from 0x1999, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) // Inputs[2] // { // @19A4 stack[-1] // @19A7 stack[-4] // } 19A1 5B JUMPDEST 19A2 60 PUSH1 0x40 19A4 52 MSTORE 19A5 50 POP 19A6 50 POP 19A7 56 *JUMP // Stack delta = -4 // Outputs[1] { @19A4 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_19A8: // Incoming call from 0x064B, returns to 0x064C // Inputs[1] { @19AE stack[-1] } 19A8 5B JUMPDEST 19A9 60 PUSH1 0x00 19AB 60 PUSH1 0x00 19AD 19 NOT 19AE 82 DUP3 19AF 14 EQ 19B0 15 ISZERO 19B1 61 PUSH2 0x19bc 19B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19A9 stack[0] = 0x00 } // Block ends with conditional jump to 0x19bc, if !(stack[-1] == ~0x00) label_19B5: // Incoming jump from 0x19B4, if not !(stack[-1] == ~0x00) 19B5 61 PUSH2 0x19bc 19B8 61 PUSH2 0x19d7 19BB 56 *JUMP // Stack delta = +1 // Outputs[1] { @19B5 stack[0] = 0x19bc } // Block ends with unconditional jump to 0x19d7 label_19BC: // Incoming jump from 0x19B4, if !(stack[-1] == ~0x00) // Inputs[2] // { // @19C0 stack[-2] // @19C1 stack[-3] // } 19BC 5B JUMPDEST 19BD 50 POP 19BE 60 PUSH1 0x01 19C0 01 ADD 19C1 90 SWAP1 19C2 56 *JUMP // Stack delta = -2 // Outputs[1] { @19C1 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_19C3: // Incoming call from 0x0C9F, returns to 0x0CA0 // Inputs[1] { @19C6 stack[-2] } 19C3 5B JUMPDEST 19C4 60 PUSH1 0x00 19C6 82 DUP3 19C7 61 PUSH2 0x19d2 19CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19C4 stack[0] = 0x00 } // Block ends with conditional jump to 0x19d2, if stack[-2] label_19CB: // Incoming jump from 0x19CA, if not stack[-2] 19CB 61 PUSH2 0x19d2 19CE 61 PUSH2 0x19ed 19D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @19CB stack[0] = 0x19d2 } // Block ends with unconditional jump to 0x19ed label_19D2: // Incoming jump from 0x19CA, if stack[-2] // Inputs[3] // { // @19D4 stack[-2] // @19D4 stack[-3] // @19D5 stack[-4] // } 19D2 5B JUMPDEST 19D3 50 POP 19D4 06 MOD 19D5 90 SWAP1 19D6 56 *JUMP // Stack delta = -3 // Outputs[1] { @19D5 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_19D7: // Incoming jump from 0x18F4 // Incoming jump from 0x18DD // Incoming jump from 0x18AA // Incoming jump from 0x19BB // Incoming jump from 0x1938 // Inputs[1] { @19EC memory[0x00:0x24] } 19D7 5B JUMPDEST 19D8 63 PUSH4 0x4e487b71 19DD 60 PUSH1 0xe0 19DF 1B SHL 19E0 60 PUSH1 0x00 19E2 52 MSTORE 19E3 60 PUSH1 0x11 19E5 60 PUSH1 0x04 19E7 52 MSTORE 19E8 60 PUSH1 0x24 19EA 60 PUSH1 0x00 19EC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @19E2 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @19E7 memory[0x04:0x24] = 0x11 // @19EC revert(memory[0x00:0x24]); // } // Block terminates label_19ED: // Incoming jump from 0x18BE // Incoming jump from 0x19D1 // Inputs[1] { @1A02 memory[0x00:0x24] } 19ED 5B JUMPDEST 19EE 63 PUSH4 0x4e487b71 19F3 60 PUSH1 0xe0 19F5 1B SHL 19F6 60 PUSH1 0x00 19F8 52 MSTORE 19F9 60 PUSH1 0x12 19FB 60 PUSH1 0x04 19FD 52 MSTORE 19FE 60 PUSH1 0x24 1A00 60 PUSH1 0x00 1A02 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @19F8 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @19FD memory[0x04:0x24] = 0x12 // @1A02 revert(memory[0x00:0x24]); // } // Block terminates label_1A03: // Incoming jump from 0x05FE // Incoming jump from 0x114D // Incoming jump from 0x0637 // Incoming jump from 0x0CFD // Incoming jump from 0x0742 // Incoming jump from 0x0618 // Inputs[1] { @1A18 memory[0x00:0x24] } 1A03 5B JUMPDEST 1A04 63 PUSH4 0x4e487b71 1A09 60 PUSH1 0xe0 1A0B 1B SHL 1A0C 60 PUSH1 0x00 1A0E 52 MSTORE 1A0F 60 PUSH1 0x32 1A11 60 PUSH1 0x04 1A13 52 MSTORE 1A14 60 PUSH1 0x24 1A16 60 PUSH1 0x00 1A18 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A0E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1A13 memory[0x04:0x24] = 0x32 // @1A18 revert(memory[0x00:0x24]); // } // Block terminates label_1A19: // Incoming jump from 0x12E5 // Incoming jump from 0x19A0 // Incoming jump from 0x05B1 // Incoming jump from 0x188D // Inputs[1] { @1A2E memory[0x00:0x24] } 1A19 5B JUMPDEST 1A1A 63 PUSH4 0x4e487b71 1A1F 60 PUSH1 0xe0 1A21 1B SHL 1A22 60 PUSH1 0x00 1A24 52 MSTORE 1A25 60 PUSH1 0x41 1A27 60 PUSH1 0x04 1A29 52 MSTORE 1A2A 60 PUSH1 0x24 1A2C 60 PUSH1 0x00 1A2E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A24 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1A29 memory[0x04:0x24] = 0x41 // @1A2E revert(memory[0x00:0x24]); // } // Block terminates label_1A2F: // Incoming call from 0x11F8, returns to 0x0F54 // Inputs[1] { @1A34 returndata.length } 1A2F 5B JUMPDEST 1A30 60 PUSH1 0x00 1A32 60 PUSH1 0x03 1A34 3D RETURNDATASIZE 1A35 11 GT 1A36 15 ISZERO 1A37 61 PUSH2 0x1a48 1A3A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A30 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a48, if !(returndata.length > 0x03) label_1A3B: // Incoming jump from 0x1A3A, if not !(returndata.length > 0x03) // Inputs[3] // { // @1A40 returndata[0x00:0x04] // @1A44 memory[0x00:0x20] // @1A49 stack[-2] // } 1A3B 60 PUSH1 0x04 1A3D 60 PUSH1 0x00 1A3F 80 DUP1 1A40 3E RETURNDATACOPY 1A41 50 POP 1A42 60 PUSH1 0x00 1A44 51 MLOAD 1A45 60 PUSH1 0xe0 1A47 1C SHR 1A48 5B JUMPDEST 1A49 90 SWAP1 1A4A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1A40 memory[0x00:0x04] = returndata[0x00:0x04] // @1A49 stack[-2] = memory[0x00:0x20] >> 0xe0 // } // Block ends with unconditional jump to stack[-2] label_1A4B: // Incoming call from 0x0F68, returns to 0x0F69 // Inputs[1] { @1A50 returndata.length } 1A4B 5B JUMPDEST 1A4C 60 PUSH1 0x00 1A4E 60 PUSH1 0x44 1A50 3D RETURNDATASIZE 1A51 10 LT 1A52 15 ISZERO 1A53 61 PUSH2 0x1a59 1A56 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A4C stack[0] = 0x00 } // Block ends with conditional jump to 0x1a59, if !(returndata.length < 0x44) label_1A57: // Incoming jump from 0x1A56, if not !(returndata.length < 0x44) // Inputs[2] // { // @1A57 stack[-1] // @1A57 stack[-2] // } 1A57 90 SWAP1 1A58 56 *JUMP // Stack delta = -1 // Outputs[1] { @1A57 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1A59: // Incoming jump from 0x1A56, if !(returndata.length < 0x44) // Inputs[5] // { // @1A5C memory[0x40:0x60] // @1A60 returndata.length // @1A66 returndata[0x04:0x04 + ~0x03 + returndata.length] // @1A68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1A69 returndata.length // } 1A59 5B JUMPDEST 1A5A 60 PUSH1 0x40 1A5C 51 MLOAD 1A5D 60 PUSH1 0x03 1A5F 19 NOT 1A60 3D RETURNDATASIZE 1A61 81 DUP2 1A62 01 ADD 1A63 60 PUSH1 0x04 1A65 83 DUP4 1A66 3E RETURNDATACOPY 1A67 81 DUP2 1A68 51 MLOAD 1A69 3D RETURNDATASIZE 1A6A 60 PUSH1 0x01 1A6C 60 PUSH1 0x01 1A6E 60 PUSH1 0x40 1A70 1B SHL 1A71 03 SUB 1A72 80 DUP1 1A73 83 DUP4 1A74 11 GT 1A75 60 PUSH1 0x24 1A77 84 DUP5 1A78 01 ADD 1A79 83 DUP4 1A7A 10 LT 1A7B 17 OR 1A7C 15 ISZERO 1A7D 61 PUSH2 0x1a88 1A80 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @1A5C stack[0] = memory[0x40:0x60] // @1A5F stack[1] = ~0x03 // @1A66 memory[memory[0x40:0x60]:memory[0x40:0x60] + ~0x03 + returndata.length] = returndata[0x04:0x04 + ~0x03 + returndata.length] // @1A68 stack[2] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1A69 stack[3] = returndata.length // @1A71 stack[4] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x1a88, if !((returndata.length < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > (0x01 << 0x40) - 0x01)) label_1A81: // Incoming jump from 0x1A80, if not !((returndata.length < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > (0x01 << 0x40) - 0x01)) // Inputs[2] // { // @1A86 stack[-6] // @1A86 stack[-7] // } 1A81 50 POP 1A82 50 POP 1A83 50 POP 1A84 50 POP 1A85 50 POP 1A86 90 SWAP1 1A87 56 *JUMP // Stack delta = -6 // Outputs[1] { @1A86 stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_1A88: // Incoming jump from 0x1A80, if !((returndata.length < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > (0x01 << 0x40) - 0x01)) // Inputs[5] // { // @1A89 stack[-3] // @1A8A stack[-5] // @1A8C stack[-2] // @1A8F memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // @1A90 stack[-1] // } 1A88 5B JUMPDEST 1A89 82 DUP3 1A8A 85 DUP6 1A8B 01 ADD 1A8C 91 SWAP2 1A8D 50 POP 1A8E 81 DUP2 1A8F 51 MLOAD 1A90 81 DUP2 1A91 81 DUP2 1A92 11 GT 1A93 15 ISZERO 1A94 61 PUSH2 0x1aa0 1A97 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1A8C stack[-2] = stack[-5] + stack[-3] // @1A8F stack[0] = memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x1aa0, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) label_1A98: // Incoming jump from 0x1A97, if not !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[2] // { // @1A9E stack[-7] // @1A9E stack[-8] // } 1A98 50 POP 1A99 50 POP 1A9A 50 POP 1A9B 50 POP 1A9C 50 POP 1A9D 50 POP 1A9E 90 SWAP1 1A9F 56 *JUMP // Stack delta = -7 // Outputs[1] { @1A9E stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1AA0: // Incoming jump from 0x1A97, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[5] // { // @1AA1 stack[-5] // @1AA2 returndata.length // @1AA3 stack[-6] // @1AA8 stack[-1] // @1AA9 stack[-3] // } 1AA0 5B JUMPDEST 1AA1 84 DUP5 1AA2 3D RETURNDATASIZE 1AA3 87 DUP8 1AA4 01 ADD 1AA5 01 ADD 1AA6 60 PUSH1 0x20 1AA8 82 DUP3 1AA9 85 DUP6 1AAA 01 ADD 1AAB 01 ADD 1AAC 11 GT 1AAD 15 ISZERO 1AAE 61 PUSH2 0x1aba 1AB1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1aba, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) label_1AB2: // Incoming jump from 0x1AB1, if not !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[2] // { // @1AB8 stack[-8] // @1AB8 stack[-7] // } 1AB2 50 POP 1AB3 50 POP 1AB4 50 POP 1AB5 50 POP 1AB6 50 POP 1AB7 50 POP 1AB8 90 SWAP1 1AB9 56 *JUMP // Stack delta = -7 // Outputs[1] { @1AB8 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1ABA: // Incoming jump from 0x1AB1, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[3] // { // @1AC0 stack[-1] // @1AC1 stack[-4] // @1AC4 stack[-6] // } 1ABA 5B JUMPDEST 1ABB 61 PUSH2 0x1ac9 1ABE 60 PUSH1 0x20 1AC0 82 DUP3 1AC1 86 DUP7 1AC2 01 ADD 1AC3 01 ADD 1AC4 87 DUP8 1AC5 61 PUSH2 0x197c 1AC8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1ABB stack[0] = 0x1ac9 // @1AC3 stack[1] = stack[-4] + stack[-1] + 0x20 // @1AC4 stack[2] = stack[-6] // } // Block ends with call to 0x197c, returns to 0x1AC9 label_1AC9: // Incoming return from call to 0x197C at 0x1AC8 // Inputs[4] // { // @1ACB stack[-2] // @1ACB stack[-3] // @1ACC stack[-8] // @1ACD stack[-7] // } 1AC9 5B JUMPDEST 1ACA 50 POP 1ACB 90 SWAP1 1ACC 95 SWAP6 1ACD 94 SWAP5 1ACE 50 POP 1ACF 50 POP 1AD0 50 POP 1AD1 50 POP 1AD2 50 POP 1AD3 56 *JUMP // Stack delta = -7 // Outputs[1] { @1ACC stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_1AD4: // Incoming call from 0x15E3, returns to 0x134A // Incoming call from 0x1600, returns to 0x134A // Inputs[1] { @1ADE stack[-1] } 1AD4 5B JUMPDEST 1AD5 60 PUSH1 0x01 1AD7 60 PUSH1 0x01 1AD9 60 PUSH1 0xe0 1ADB 1B SHL 1ADC 03 SUB 1ADD 19 NOT 1ADE 81 DUP2 1ADF 16 AND 1AE0 81 DUP2 1AE1 14 EQ 1AE2 61 PUSH2 0x0c33 1AE5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c33, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1AE6: // Incoming jump from 0x1AE5, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1AE9 memory[0x00:0x00] } 1AE6 60 PUSH1 0x00 1AE8 80 DUP1 1AE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AE9 revert(memory[0x00:0x00]); } // Block terminates 1AEA FE *ASSERT 1AEB C3 C3 1AEC D5 D5 1AED 81 DUP2 1AEE 68 PUSH9 0xc5ae7397731d063d5b 1AF8 BF BF 1AF9 3D RETURNDATASIZE 1AFA 65 PUSH6 0x7854427343f4 1B01 C0 C0 1B02 83 DUP4 1B03 24 24 1B04 0F 0F 1B05 7A PUSH27 0xacaa2d0f62a2646970667358221220954ecf14f652abd352eb7493 1B21 DC DC 1B22 FC FC 1B23 2D 2D 1B24 22 22 1B25 B4 B4 1B26 79 PUSH26 0x07154a340bdc738d96e08edf230864736f6c63430008060033