Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 36 CALLDATASIZE 0006 61 PUSH2 0x000b 0009 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x000b, if msg.data.length label_000A: // Incoming jump from 0x0009, if not msg.data.length 000A 00 *STOP // Stack delta = +0 // Outputs[1] { @000A stop(); } // Block terminates label_000B: // Incoming jump from 0x0009, if msg.data.length // Inputs[1] { @000E msg.data[0x00:0x20] } 000B 5B JUMPDEST 000C 60 PUSH1 0x00 000E 35 CALLDATALOAD 000F 60 PUSH1 0xe0 0011 1C SHR 0012 80 DUP1 0013 15 ISZERO 0014 61 PUSH2 0x00d8 0017 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0011 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00d8, if !(msg.data[0x00:0x20] >> 0xe0) label_0018: // Incoming jump from 0x0017, if not !(msg.data[0x00:0x20] >> 0xe0) // Inputs[1] { @001D stack[-1] } 0018 63 PUSH4 0xf04f2707 001D 81 DUP2 001E 14 EQ 001F 61 PUSH2 0x00fc 0022 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fc, if stack[-1] == 0xf04f2707 label_0023: // Incoming jump from 0x0022, if not stack[-1] == 0xf04f2707 // Inputs[1] { @0025 msg.data.length } 0023 60 PUSH1 0xa3 0025 36 CALLDATASIZE 0026 10 LT 0027 15 ISZERO 0028 61 PUSH2 0x0033 002B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0033, if !(msg.data.length < 0xa3) label_002C: // Incoming jump from 0x002B, if not !(msg.data.length < 0xa3) 002C 61 PUSH2 0x0033 002F 61 PUSH2 0x0125 0032 56 *JUMP // Stack delta = +1 // Outputs[1] { @002C stack[0] = 0x0033 } // Block ends with unconditional jump to 0x0125 label_0033: // Incoming jump from 0x002B, if !(msg.data.length < 0xa3) 0033 5B JUMPDEST 0034 60 PUSH1 0x00 0036 80 DUP1 0037 60 PUSH1 0x04 0039 80 DUP1 003A 5B JUMPDEST 003B 60 PUSH1 0xa5 003D 81 DUP2 003E 10 LT 003F 15 ISZERO 0040 61 PUSH2 0x00bd 0043 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0034 stack[0] = 0x00 // @0036 stack[1] = 0x00 // @0037 stack[2] = 0x04 // @0039 stack[3] = 0x04 // } // Block ends with conditional jump to 0x00bd, if !(0x04 < 0xa5) label_0044: // Incoming jump from 0x0043, if not !(0x04 < 0xa5) // Incoming jump from 0x0043, if not !(stack[-1] < 0xa5) // Inputs[3] // { // @0044 stack[-1] // @0045 msg.data[stack[-1]:stack[-1] + 0x20] // @0047 stack[-2] // } 0044 80 DUP1 0045 35 CALLDATALOAD 0046 80 DUP1 0047 83 DUP4 0048 01 ADD 0049 60 PUSH1 0x20 004B 80 DUP1 004C 84 DUP5 004D 01 ADD 004E 82 DUP3 004F 03 SUB 0050 61 PUSH2 0x00b2 0053 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0045 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0048 stack[1] = stack[-2] + msg.data[stack[-1]:stack[-1] + 0x20] // @0049 stack[2] = 0x20 // } // Block ends with conditional jump to 0x00b2, if (stack[-2] + msg.data[stack[-1]:stack[-1] + 0x20]) - (stack[-1] + 0x20) label_0054: // Incoming jump from 0x0053, if not (stack[-2] + msg.data[stack[-1]:stack[-1] + 0x20]) - (stack[-1] + 0x20) // Inputs[3] // { // @0054 stack[-2] // @0055 msg.data[stack[-2]:stack[-2] + 0x20] // @0056 stack[-6] // } 0054 81 DUP2 0055 35 CALLDATALOAD 0056 95 SWAP6 0057 50 POP 0058 60 PUSH1 0x5f 005A 86 DUP7 005B 11 GT 005C 15 ISZERO 005D 61 PUSH2 0x00b2 0060 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0056 stack[-6] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x00b2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x5f) label_0061: // Incoming jump from 0x0060, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x5f) // Inputs[6] // { // @0064 memory[0x40:0x60] // @0066 stack[-6] // @006B stack[-7] // @0070 stack[-3] // @0073 msg.data[stack[-3] + 0x24:stack[-3] + 0x24 + stack[-6]] // @0076 stack[-4] // } 0061 60 PUSH1 0x40 0063 80 DUP1 0064 51 MLOAD 0065 80 DUP1 0066 88 DUP9 0067 01 ADD 0068 90 SWAP1 0069 91 SWAP2 006A 52 MSTORE 006B 96 SWAP7 006C 50 POP 006D 85 DUP6 006E 60 PUSH1 0x24 0070 84 DUP5 0071 01 ADD 0072 88 DUP9 0073 37 CALLDATACOPY 0074 60 PUSH1 0x23 0076 84 DUP5 0077 11 GT 0078 15 ISZERO 0079 61 PUSH2 0x00aa 007C 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @006A memory[0x40:0x60] = stack[-6] + memory[0x40:0x60] // @006B stack[-7] = memory[0x40:0x60] // @0073 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-6]] = msg.data[stack[-3] + 0x24:stack[-3] + 0x24 + stack[-6]] // } // Block ends with conditional jump to 0x00aa, if !(stack[-4] > 0x23) label_007D: // Incoming jump from 0x007C, if not !(stack[-4] > 0x23) // Inputs[2] // { // @0080 stack[-4] // @0082 msg.data[stack[-4] + ~0x1f:stack[-4] + ~0x1f + 0x20] // } 007D 60 PUSH1 0x1f 007F 19 NOT 0080 84 DUP5 0081 01 ADD 0082 35 CALLDATALOAD 0083 80 DUP1 0084 15 ISZERO 0085 61 PUSH2 0x008e 0088 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0082 stack[0] = msg.data[stack[-4] + ~0x1f:stack[-4] + ~0x1f + 0x20] } // Block ends with conditional jump to 0x008e, if !msg.data[stack[-4] + ~0x1f:stack[-4] + ~0x1f + 0x20] label_0089: // Incoming jump from 0x0088, if not !msg.data[stack[-4] + ~0x1f:stack[-4] + ~0x1f + 0x20] // Inputs[4] // { // @0089 stack[-1] // @008A stack[-2] // @008B stack[-8] // @0092 stack[-5] // } 0089 80 DUP1 008A 82 DUP3 008B 89 DUP10 008C 01 ADD 008D 52 MSTORE 008E 5B JUMPDEST 008F 50 POP 0090 60 PUSH1 0x43 0092 84 DUP5 0093 11 GT 0094 15 ISZERO 0095 61 PUSH2 0x00aa 0098 57 *JUMPI // Stack delta = -1 // Outputs[1] { @008D memory[stack[-8] + stack[-2]:stack[-8] + stack[-2] + 0x20] = stack[-1] } // Block ends with conditional jump to 0x00aa, if !(stack[-5] > 0x43) label_0099: // Incoming jump from 0x0098, if not !(stack[-5] > 0x43) // Incoming jump from 0x0098, if not !(stack[-5] > 0x43) // Inputs[2] // { // @009C stack[-4] // @009E msg.data[stack[-4] + ~0x3f:stack[-4] + ~0x3f + 0x20] // } 0099 60 PUSH1 0x3f 009B 19 NOT 009C 84 DUP5 009D 01 ADD 009E 35 CALLDATALOAD 009F 80 DUP1 00A0 15 ISZERO 00A1 61 PUSH2 0x00a8 00A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @009E stack[0] = msg.data[stack[-4] + ~0x3f:stack[-4] + ~0x3f + 0x20] } // Block ends with conditional jump to 0x00a8, if !msg.data[stack[-4] + ~0x3f:stack[-4] + ~0x3f + 0x20] label_00A5: // Incoming jump from 0x00A4, if not !msg.data[stack[-4] + ~0x3f:stack[-4] + ~0x3f + 0x20] // Inputs[2] // { // @00A5 stack[-1] // @00A6 stack[-8] // } 00A5 80 DUP1 00A6 88 DUP9 00A7 52 MSTORE 00A8 5B JUMPDEST 00A9 50 POP // Stack delta = -1 // Outputs[1] { @00A7 memory[stack[-8]:stack[-8] + 0x20] = stack[-1] } // Block continues label_00AA: // Incoming jump from 0x007C, if !(stack[-4] > 0x23) // Incoming jump from 0x0098, if !(stack[-5] > 0x43) // Incoming jump from 0x00A9 // Incoming jump from 0x00A9 // Incoming jump from 0x0098, if !(stack[-5] > 0x43) 00AA 5B JUMPDEST 00AB 50 POP 00AC 50 POP 00AD 50 POP 00AE 61 PUSH2 0x00bd 00B1 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to 0x00bd label_00B2: // Incoming jump from 0x0053, if (stack[-2] + msg.data[stack[-1]:stack[-1] + 0x20]) - (stack[-1] + 0x20) // Incoming jump from 0x0060, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x5f) // Inputs[1] { @00B8 stack[-4] } 00B2 5B JUMPDEST 00B3 50 POP 00B4 50 POP 00B5 50 POP 00B6 60 PUSH1 0x20 00B8 01 ADD 00B9 61 PUSH2 0x003a 00BC 56 *JUMP // Stack delta = -3 // Outputs[1] { @00B8 stack[-4] = 0x20 + stack[-4] } // Block ends with unconditional jump to 0x003a label_00BD: // Incoming jump from 0x0043, if !(0x04 < 0xa5) // Incoming jump from 0x00B1 // Incoming jump from 0x0043, if !(stack[-1] < 0xa5) // Inputs[1] { @00C0 stack[-4] } 00BD 5B JUMPDEST 00BE 50 POP 00BF 50 POP 00C0 81 DUP2 00C1 61 PUSH2 0x00cc 00C4 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x00cc, if stack[-4] label_00C5: // Incoming jump from 0x00C4, if not stack[-4] 00C5 61 PUSH2 0x00cc 00C8 61 PUSH2 0x0125 00CB 56 *JUMP // Stack delta = +1 // Outputs[1] { @00C5 stack[0] = 0x00cc } // Block ends with unconditional jump to 0x0125 label_00CC: // Incoming jump from 0x00C4, if stack[-4] // Inputs[2] // { // @00D0 stack[-1] // @00D1 stack[-2] // } 00CC 5B JUMPDEST 00CD 61 PUSH2 0x00d6 00D0 81 DUP2 00D1 83 DUP4 00D2 61 PUSH2 0x01e9 00D5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @00CD stack[0] = 0x00d6 // @00D0 stack[1] = stack[-1] // @00D1 stack[2] = stack[-2] // } // Block ends with call to 0x01e9, returns to 0x00D6 label_00D6: // Incoming return from call to 0x01E9 at 0x0124 // Incoming return from call to 0x01E9 at 0x00FB // Incoming return from call to 0x01E9 at 0x00D5 00D6 5B JUMPDEST 00D7 00 *STOP // Stack delta = +0 // Outputs[1] { @00D7 stop(); } // Block terminates label_00D8: // Incoming jump from 0x0017, if !(msg.data[0x00:0x20] >> 0xe0) // Inputs[2] // { // @00D9 msg.data.length // @00E5 memory[0x40:0x60] // } 00D8 5B JUMPDEST 00D9 36 CALLDATASIZE 00DA 60 PUSH1 0x03 00DC 19 NOT 00DD 01 ADD 00DE 61 PUSH2 0x00ed 00E1 81 DUP2 00E2 60 PUSH1 0x40 00E4 80 DUP1 00E5 51 MLOAD 00E6 91 SWAP2 00E7 82 DUP3 00E8 01 ADD 00E9 90 SWAP1 00EA 52 MSTORE 00EB 90 SWAP1 00EC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00DD stack[0] = ~0x03 + msg.data.length // @00EA memory[0x40:0x60] = memory[0x40:0x60] + ~0x03 + msg.data.length // @00EB stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00ed label_00ED: // Incoming jump from 0x00EC // Inputs[3] // { // @00EE stack[-2] // @00F1 stack[-1] // @00F2 msg.data[0x04:0x04 + stack[-2]] // } 00ED 5B JUMPDEST 00EE 81 DUP2 00EF 60 PUSH1 0x04 00F1 82 DUP3 00F2 37 CALLDATACOPY 00F3 61 PUSH2 0x00d6 00F6 82 DUP3 00F7 82 DUP3 00F8 61 PUSH2 0x01e9 00FB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @00F2 memory[stack[-1]:stack[-1] + stack[-2]] = msg.data[0x04:0x04 + stack[-2]] // @00F3 stack[0] = 0x00d6 // @00F6 stack[1] = stack[-2] // @00F7 stack[2] = stack[-1] // } // Block ends with call to 0x01e9, returns to 0x00D6 label_00FC: // Incoming jump from 0x0022, if stack[-1] == 0xf04f2707 // Inputs[3] // { // @00FF msg.data[0x64:0x84] // @0104 msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] // @010C memory[0x40:0x60] // } 00FC 5B JUMPDEST 00FD 60 PUSH1 0x64 00FF 35 CALLDATALOAD 0100 80 DUP1 0101 60 PUSH1 0x04 0103 01 ADD 0104 35 CALLDATALOAD 0105 61 PUSH2 0x0114 0108 81 DUP2 0109 60 PUSH1 0x40 010B 80 DUP1 010C 51 MLOAD 010D 91 SWAP2 010E 82 DUP3 010F 01 ADD 0110 90 SWAP1 0111 52 MSTORE 0112 90 SWAP1 0113 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @00FF stack[0] = msg.data[0x64:0x84] // @0104 stack[1] = msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] // @0111 memory[0x40:0x60] = memory[0x40:0x60] + msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] // @0112 stack[2] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0114 label_0114: // Incoming jump from 0x0113 // Inputs[4] // { // @0115 stack[-2] // @0118 stack[-3] // @011A stack[-1] // @011B msg.data[stack[-3] + 0x24:stack[-3] + 0x24 + stack[-2]] // } 0114 5B JUMPDEST 0115 81 DUP2 0116 60 PUSH1 0x24 0118 84 DUP5 0119 01 ADD 011A 82 DUP3 011B 37 CALLDATACOPY 011C 61 PUSH2 0x00d6 011F 82 DUP3 0120 82 DUP3 0121 61 PUSH2 0x01e9 0124 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @011B memory[stack[-1]:stack[-1] + stack[-2]] = msg.data[stack[-3] + 0x24:stack[-3] + 0x24 + stack[-2]] // @011C stack[0] = 0x00d6 // @011F stack[1] = stack[-2] // @0120 stack[2] = stack[-1] // } // Block ends with call to 0x01e9, returns to 0x00D6 label_0125: // Incoming jump from 0x0032 // Incoming jump from 0x00CB // Inputs[1] { @0129 msg.data[0x00:0x20] } 0125 5B JUMPDEST 0126 60 PUSH1 0x00 0128 80 DUP1 0129 35 CALLDATALOAD 012A 60 PUSH1 0xe0 012C 1C SHR 012D 80 DUP1 012E 63 PUSH4 0x83197ef0 0133 81 DUP2 0134 14 EQ 0135 61 PUSH2 0x0148 0138 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0126 stack[0] = 0x00 // @012C stack[1] = msg.data[0x00:0x20] >> 0xe0 // @012D stack[2] = msg.data[0x00:0x20] >> 0xe0 // } // Block ends with conditional jump to 0x0148, if msg.data[0x00:0x20] >> 0xe0 == 0x83197ef0 label_0139: // Incoming jump from 0x0138, if not msg.data[0x00:0x20] >> 0xe0 == 0x83197ef0 // Inputs[1] { @013E stack[-1] } 0139 63 PUSH4 0xcc066bb8 013E 81 DUP2 013F 14 EQ 0140 61 PUSH2 0x0175 0143 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if stack[-1] == 0xcc066bb8 label_0144: // Incoming jump from 0x0143, if not stack[-1] == 0xcc066bb8 0144 61 PUSH2 0x017e 0147 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x017e label_0148: // Incoming jump from 0x0138, if msg.data[0x00:0x20] >> 0xe0 == 0x83197ef0 // Inputs[1] { @0149 tx.origin } 0148 5B JUMPDEST 0149 32 ORIGIN 014A 6E PUSH15 0x02e33d9a86567c6dfe6d92f6777d1e 015A 81 DUP2 015B 14 EQ 015C 61 PUSH2 0x0163 015F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0149 stack[0] = tx.origin } // Block ends with conditional jump to 0x0163, if tx.origin == 0x02e33d9a86567c6dfe6d92f6777d1e label_0160: // Incoming jump from 0x015F, if not tx.origin == 0x02e33d9a86567c6dfe6d92f6777d1e // Inputs[2] // { // @0160 stack[-4] // @0162 memory[stack[-4]:stack[-4] + stack[-4]] // } 0160 83 DUP4 0161 84 DUP5 0162 FD *REVERT // Stack delta = +0 // Outputs[1] { @0162 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_0163: // Incoming jump from 0x015F, if tx.origin == 0x02e33d9a86567c6dfe6d92f6777d1e 0163 5B JUMPDEST 0164 6E PUSH15 0x02e33d9a86567c6dfe6d92f6777d1e 0174 FF *SELFDESTRUCT // Stack delta = +0 // Outputs[1] { @0174 selfdestruct(0x02e33d9a86567c6dfe6d92f6777d1e); } // Block terminates label_0175: // Incoming jump from 0x0143, if stack[-1] == 0xcc066bb8 // Inputs[2] // { // @0178 stack[-3] // @017D memory[stack[-3]:stack[-3] + 0x20] // } 0175 5B JUMPDEST 0176 60 PUSH1 0x01 0178 83 DUP4 0179 52 MSTORE 017A 60 PUSH1 0x20 017C 83 DUP4 017D F3 *RETURN // Stack delta = +0 // Outputs[2] // { // @0179 memory[stack[-3]:stack[-3] + 0x20] = 0x01 // @017D return memory[stack[-3]:stack[-3] + 0x20]; // } // Block terminates label_017E: // Incoming jump from 0x0147 // Inputs[3] // { // @0180 stack[-2] // @0181 storage[stack[-2]] // @0184 stack[-3] // } 017E 5B JUMPDEST 017F 50 POP 0180 80 DUP1 0181 54 SLOAD 0182 60 PUSH1 0x01 0184 83 DUP4 0185 81 DUP2 0186 83 DUP4 0187 16 AND 0188 60 PUSH1 0x01 018A 81 DUP2 018B 14 EQ 018C 61 PUSH2 0x01a3 018F 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @0181 stack[-1] = storage[stack[-2]] // @0182 stack[0] = 0x01 // @0184 stack[1] = stack[-3] // @0187 stack[2] = storage[stack[-2]] & 0x01 // } // Block ends with conditional jump to 0x01a3, if storage[stack[-2]] & 0x01 == 0x01 label_0190: // Incoming jump from 0x018F, if not storage[stack[-2]] & 0x01 == 0x01 // Inputs[4] // { // @0193 stack[-4] // @0195 stack[-6] // @0198 stack[-3] // @019D stack[-2] // } 0190 60 PUSH1 0xff 0192 19 NOT 0193 84 DUP5 0194 16 AND 0195 86 DUP7 0196 52 MSTORE 0197 83 DUP4 0198 83 DUP4 0199 1C SHR 019A 60 PUSH1 0x7f 019C 16 AND 019D 91 SWAP2 019E 50 POP 019F 61 PUSH2 0x01cd 01A2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0196 memory[stack[-6]:stack[-6] + 0x20] = stack[-4] & ~0xff // @019D stack[-2] = 0x7f & (stack[-4] >> stack[-3]) // } // Block ends with unconditional jump to 0x01cd label_01A3: // Incoming jump from 0x018F, if storage[stack[-2]] & 0x01 == 0x01 // Inputs[6] // { // @01A4 stack[-4] // @01A5 stack[-3] // @01A7 stack[-2] // @01A9 stack[-5] // @01AA stack[-6] // @01B0 memory[stack[-6]:stack[-6] + 0x20] // } 01A3 5B JUMPDEST 01A4 83 DUP4 01A5 83 DUP4 01A6 1C SHR 01A7 91 SWAP2 01A8 50 POP 01A9 84 DUP5 01AA 86 DUP7 01AB 52 MSTORE 01AC 60 PUSH1 0x20 01AE 80 DUP1 01AF 87 DUP8 01B0 20 SHA3 01B1 87 DUP8 01B2 5B JUMPDEST 01B3 84 DUP5 01B4 81 DUP2 01B5 10 LT 01B6 15 ISZERO 01B7 61 PUSH2 0x01c9 01BA 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @01A7 stack[-2] = stack[-4] >> stack[-3] // @01AB memory[stack[-6]:stack[-6] + 0x20] = stack[-5] // @01AC stack[0] = 0x20 // @01B0 stack[1] = keccak256(memory[stack[-6]:stack[-6] + 0x20]) // @01B1 stack[2] = stack[-6] // } // Block ends with conditional jump to 0x01c9, if !(stack[-6] < stack[-4] >> stack[-3]) label_01BB: // Incoming jump from 0x01BA, if not !(stack[-6] < stack[-4] >> stack[-3]) // Incoming jump from 0x01BA, if not !(stack[-1] < stack[-5]) // Inputs[5] // { // @01BB stack[-2] // @01BC storage[stack[-2]] // @01BD stack[-1] // @01C0 stack[-6] // @01C3 stack[-3] // } 01BB 81 DUP2 01BC 54 SLOAD 01BD 81 DUP2 01BE 52 MSTORE 01BF 90 SWAP1 01C0 85 DUP6 01C1 01 ADD 01C2 90 SWAP1 01C3 82 DUP3 01C4 01 ADD 01C5 61 PUSH2 0x01b2 01C8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @01BE memory[stack[-1]:stack[-1] + 0x20] = storage[stack[-2]] // @01C2 stack[-2] = stack[-6] + stack[-2] // @01C4 stack[-1] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x01b2 label_01C9: // Incoming jump from 0x01BA, if !(stack[-6] < stack[-4] >> stack[-3]) // Incoming jump from 0x01BA, if !(stack[-1] < stack[-5]) // Inputs[1] { @01CF stack[-5] } 01C9 5B JUMPDEST 01CA 50 POP 01CB 50 POP 01CC 50 POP 01CD 5B JUMPDEST 01CE 50 POP 01CF 80 DUP1 01D0 15 ISZERO 01D1 61 PUSH2 0x01d8 01D4 57 *JUMPI // Stack delta = -4 // Block ends with conditional jump to 0x01d8, if !stack[-5] label_01D5: // Incoming jump from 0x01D4, if not !stack[-5] // Incoming jump from 0x01D4, if not !stack[-2] // Inputs[3] // { // @01D5 stack[-1] // @01D6 stack[-5] // @01D7 memory[stack[-5]:stack[-5] + stack[-1]] // } 01D5 80 DUP1 01D6 85 DUP6 01D7 F3 *RETURN // Stack delta = +0 // Outputs[1] { @01D7 return memory[stack[-5]:stack[-5] + stack[-1]]; } // Block terminates label_01D8: // Incoming jump from 0x01D4, if !stack[-5] // Incoming jump from 0x01D4, if !stack[-2] // Inputs[3] // { // @01DD stack[-5] // @01E4 msg.data[stack[-5]:stack[-5] + 0x04] // @01E8 memory[stack[-5]:stack[-5] + 0x20] // } 01D8 5B JUMPDEST 01D9 50 POP 01DA 50 POP 01DB 50 POP 01DC 50 POP 01DD 80 DUP1 01DE 81 DUP2 01DF 52 MSTORE 01E0 60 PUSH1 0x04 01E2 81 DUP2 01E3 82 DUP3 01E4 37 CALLDATACOPY 01E5 60 PUSH1 0x20 01E7 81 DUP2 01E8 F3 *RETURN // Stack delta = -4 // Outputs[3] // { // @01DF memory[stack[-5]:stack[-5] + 0x20] = stack[-5] // @01E4 memory[stack[-5]:stack[-5] + 0x04] = msg.data[stack[-5]:stack[-5] + 0x04] // @01E8 return memory[stack[-5]:stack[-5] + 0x20]; // } // Block terminates label_01E9: // Incoming call from 0x0124, returns to 0x00D6 // Incoming call from 0x00FB, returns to 0x00D6 // Incoming call from 0x00D5, returns to 0x00D6 // Inputs[1] { @01EA tx.origin } 01E9 5B JUMPDEST 01EA 32 ORIGIN 01EB 6E PUSH15 0x02e33d9a86567c6dfe6d92f6777d1e 01FB 81 DUP2 01FC 14 EQ 01FD 61 PUSH2 0x0231 0200 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01EA stack[0] = tx.origin } // Block ends with conditional jump to 0x0231, if tx.origin == 0x02e33d9a86567c6dfe6d92f6777d1e label_0201: // Incoming jump from 0x0200, if not tx.origin == 0x02e33d9a86567c6dfe6d92f6777d1e // Inputs[1] { @0211 stack[-1] } 0201 6E PUSH15 0x0531209e12531ac2360186a8c9cd6b 0211 81 DUP2 0212 14 EQ 0213 61 PUSH2 0x0231 0216 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0231, if stack[-1] == 0x0531209e12531ac2360186a8c9cd6b label_0217: // Incoming jump from 0x0216, if not stack[-1] == 0x0531209e12531ac2360186a8c9cd6b // Inputs[1] { @0227 stack[-1] } 0217 6E PUSH15 0x05dfe874f01071d0e05f99178a5cfc 0227 81 DUP2 0228 14 EQ 0229 61 PUSH2 0x0231 022C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0231, if stack[-1] == 0x05dfe874f01071d0e05f99178a5cfc label_022D: // Incoming jump from 0x022C, if not stack[-1] == 0x05dfe874f01071d0e05f99178a5cfc // Inputs[1] { @0230 memory[0x00:0x00] } 022D 60 PUSH1 0x00 022F 80 DUP1 0230 FD *REVERT // Stack delta = +0 // Outputs[1] { @0230 revert(memory[0x00:0x00]); } // Block terminates label_0231: // Incoming jump from 0x0200, if tx.origin == 0x02e33d9a86567c6dfe6d92f6777d1e // Incoming jump from 0x0216, if stack[-1] == 0x0531209e12531ac2360186a8c9cd6b // Incoming jump from 0x022C, if stack[-1] == 0x05dfe874f01071d0e05f99178a5cfc // Inputs[2] // { // @0233 stack[-2] // @0234 stack[-3] // } 0231 5B JUMPDEST 0232 50 POP 0233 80 DUP1 0234 82 DUP3 0235 82 DUP3 0236 01 ADD 0237 5B JUMPDEST 0238 80 DUP1 0239 82 DUP3 023A 10 LT 023B 15 ISZERO 023C 61 PUSH2 0x0577 023F 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0233 stack[-1] = stack[-2] // @0236 stack[0] = stack[-2] + stack[-3] // } // Block ends with conditional jump to 0x0577, if !(stack[-2] < stack[-2] + stack[-3]) label_0240: // Incoming jump from 0x023F, if not !(stack[-2] < stack[-2] + stack[-3]) // Incoming jump from 0x023F, if not !(stack[-2] < stack[-1]) // Inputs[4] // { // @0240 stack[-2] // @0241 memory[stack[-2]:stack[-2] + 0x20] // @0247 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @024D memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 0240 81 DUP2 0241 51 MLOAD 0242 60 PUSH1 0x20 0244 83 DUP4 0245 01 ADD 0246 80 DUP1 0247 51 MLOAD 0248 60 PUSH1 0x40 024A 80 DUP1 024B 86 DUP7 024C 01 ADD 024D 51 MLOAD 024E 80 DUP1 024F 60 PUSH1 0x0b 0251 1A BYTE 0252 80 DUP1 0253 15 ISZERO 0254 61 PUSH2 0x0268 0257 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0241 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @0245 stack[1] = stack[-2] + 0x20 // @0247 stack[2] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0248 stack[3] = 0x40 // @024D stack[4] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0251 stack[5] = byte(memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20], 0x0b) // } // Block ends with conditional jump to 0x0268, if !byte(memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20], 0x0b) label_0258: // Incoming jump from 0x0257, if not !byte(memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20], 0x0b) // Inputs[3] // { // @025B stack[-9] // @025C stack[-6] // @025D stack[-1] // } 0258 61 PUSH2 0x0262 025B 89 DUP10 025C 87 DUP8 025D 83 DUP4 025E 61 PUSH2 0x057d 0261 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0258 stack[0] = 0x0262 // @025B stack[1] = stack[-9] // @025C stack[2] = stack[-6] // @025D stack[3] = stack[-1] // } // Block ends with call to 0x057d, returns to 0x0262 label_0262: // Incoming return from call to 0x057D at 0x0261 // Inputs[3] // { // @0263 stack[-7] // @0263 stack[-1] // @0266 stack[-9] // } 0262 5B JUMPDEST 0263 95 SWAP6 0264 50 POP 0265 85 DUP6 0266 88 DUP9 0267 52 MSTORE // Stack delta = -1 // Outputs[2] // { // @0263 stack[-7] = stack[-1] // @0267 memory[stack[-9]:stack[-9] + 0x20] = stack[-1] // } // Block continues label_0268: // Incoming jump from 0x0257, if !byte(memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20], 0x0b) // Incoming jump from 0x0267 // Inputs[1] { @026A stack[-2] } 0268 5B JUMPDEST 0269 50 POP 026A 80 DUP1 026B 60 PUSH1 0x0c 026D 1A BYTE 026E 80 DUP1 026F 15 ISZERO 0270 61 PUSH2 0x0284 0273 57 *JUMPI // Stack delta = +0 // Outputs[1] { @026D stack[-1] = byte(stack[-2], 0x0c) } // Block ends with conditional jump to 0x0284, if !byte(stack[-2], 0x0c) label_0274: // Incoming jump from 0x0273, if not !byte(stack[-2], 0x0c) // Inputs[3] // { // @0277 stack[-9] // @0278 stack[-4] // @0279 stack[-1] // } 0274 61 PUSH2 0x027e 0277 89 DUP10 0278 85 DUP6 0279 83 DUP4 027A 61 PUSH2 0x057d 027D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0274 stack[0] = 0x027e // @0277 stack[1] = stack[-9] // @0278 stack[2] = stack[-4] // @0279 stack[3] = stack[-1] // } // Block ends with call to 0x057d, returns to 0x027E label_027E: // Incoming return from call to 0x057D at 0x027D // Inputs[3] // { // @027F stack[-5] // @027F stack[-1] // @0282 stack[-6] // } 027E 5B JUMPDEST 027F 93 SWAP4 0280 50 POP 0281 83 DUP4 0282 85 DUP6 0283 52 MSTORE // Stack delta = -1 // Outputs[2] // { // @027F stack[-5] = stack[-1] // @0283 memory[stack[-6]:stack[-6] + 0x20] = stack[-1] // } // Block continues label_0284: // Incoming jump from 0x0273, if !byte(stack[-2], 0x0c) // Incoming jump from 0x0283 // Inputs[2] // { // @0286 stack[-2] // @028A stack[-5] // } 0284 5B JUMPDEST 0285 50 POP 0286 80 DUP1 0287 60 PUSH1 0x0d 0289 1A BYTE 028A 93 SWAP4 028B 50 POP 028C 83 DUP4 028D 15 ISZERO 028E 61 PUSH2 0x03e4 0291 57 *JUMPI // Stack delta = -1 // Outputs[1] { @028A stack[-5] = byte(stack[-2], 0x0d) } // Block ends with conditional jump to 0x03e4, if !byte(stack[-2], 0x0d) label_0292: // Incoming jump from 0x0291, if not !byte(stack[-2], 0x0d) // Inputs[1] { @0292 stack[-4] } 0292 83 DUP4 0293 60 PUSH1 0x10 0295 81 DUP2 0296 14 EQ 0297 61 PUSH2 0x0330 029A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0292 stack[0] = stack[-4] } // Block ends with conditional jump to 0x0330, if stack[-4] == 0x10 label_029B: // Incoming jump from 0x029A, if not stack[-4] == 0x10 // Inputs[1] { @029D stack[-1] } 029B 60 PUSH1 0x11 029D 81 DUP2 029E 14 EQ 029F 61 PUSH2 0x033a 02A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033a, if stack[-1] == 0x11 label_02A3: // Incoming jump from 0x02A2, if not stack[-1] == 0x11 // Inputs[1] { @02A5 stack[-1] } 02A3 60 PUSH1 0x12 02A5 81 DUP2 02A6 14 EQ 02A7 61 PUSH2 0x0344 02AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0344, if stack[-1] == 0x12 label_02AB: // Incoming jump from 0x02AA, if not stack[-1] == 0x12 // Inputs[1] { @02AD stack[-1] } 02AB 60 PUSH1 0x13 02AD 81 DUP2 02AE 14 EQ 02AF 61 PUSH2 0x034e 02B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034e, if stack[-1] == 0x13 label_02B3: // Incoming jump from 0x02B2, if not stack[-1] == 0x13 // Inputs[1] { @02B5 stack[-1] } 02B3 60 PUSH1 0x19 02B5 81 DUP2 02B6 14 EQ 02B7 61 PUSH2 0x0358 02BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0358, if stack[-1] == 0x19 label_02BB: // Incoming jump from 0x02BA, if not stack[-1] == 0x19 // Inputs[1] { @02BD stack[-1] } 02BB 60 PUSH1 0x01 02BD 81 DUP2 02BE 14 EQ 02BF 61 PUSH2 0x0360 02C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0360, if stack[-1] == 0x01 label_02C3: // Incoming jump from 0x02C2, if not stack[-1] == 0x01 // Inputs[1] { @02C5 stack[-1] } 02C3 60 PUSH1 0x02 02C5 81 DUP2 02C6 14 EQ 02C7 61 PUSH2 0x0369 02CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0369, if stack[-1] == 0x02 label_02CB: // Incoming jump from 0x02CA, if not stack[-1] == 0x02 // Inputs[1] { @02CD stack[-1] } 02CB 60 PUSH1 0x03 02CD 81 DUP2 02CE 14 EQ 02CF 61 PUSH2 0x0372 02D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0372, if stack[-1] == 0x03 label_02D3: // Incoming jump from 0x02D2, if not stack[-1] == 0x03 // Inputs[1] { @02D5 stack[-1] } 02D3 60 PUSH1 0x04 02D5 81 DUP2 02D6 14 EQ 02D7 61 PUSH2 0x037c 02DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037c, if stack[-1] == 0x04 label_02DB: // Incoming jump from 0x02DA, if not stack[-1] == 0x04 // Inputs[1] { @02DD stack[-1] } 02DB 60 PUSH1 0x14 02DD 81 DUP2 02DE 14 EQ 02DF 61 PUSH2 0x0386 02E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0386, if stack[-1] == 0x14 label_02E3: // Incoming jump from 0x02E2, if not stack[-1] == 0x14 // Inputs[1] { @02E5 stack[-1] } 02E3 60 PUSH1 0x1e 02E5 81 DUP2 02E6 14 EQ 02E7 61 PUSH2 0x038f 02EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038f, if stack[-1] == 0x1e label_02EB: // Incoming jump from 0x02EA, if not stack[-1] == 0x1e // Inputs[1] { @02ED stack[-1] } 02EB 60 PUSH1 0x05 02ED 81 DUP2 02EE 14 EQ 02EF 61 PUSH2 0x0399 02F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0399, if stack[-1] == 0x05 label_02F3: // Incoming jump from 0x02F2, if not stack[-1] == 0x05 // Inputs[1] { @02F5 stack[-1] } 02F3 60 PUSH1 0x06 02F5 81 DUP2 02F6 14 EQ 02F7 61 PUSH2 0x03a3 02FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a3, if stack[-1] == 0x06 label_02FB: // Incoming jump from 0x02FA, if not stack[-1] == 0x06 // Inputs[1] { @02FD stack[-1] } 02FB 60 PUSH1 0x07 02FD 81 DUP2 02FE 14 EQ 02FF 61 PUSH2 0x03ad 0302 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ad, if stack[-1] == 0x07 label_0303: // Incoming jump from 0x0302, if not stack[-1] == 0x07 // Inputs[1] { @0305 stack[-1] } 0303 60 PUSH1 0x0a 0305 81 DUP2 0306 14 EQ 0307 61 PUSH2 0x03b7 030A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b7, if stack[-1] == 0x0a label_030B: // Incoming jump from 0x030A, if not stack[-1] == 0x0a // Inputs[1] { @030D stack[-1] } 030B 60 PUSH1 0x16 030D 81 DUP2 030E 14 EQ 030F 61 PUSH2 0x03c1 0312 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c1, if stack[-1] == 0x16 label_0313: // Incoming jump from 0x0312, if not stack[-1] == 0x16 // Inputs[1] { @0315 stack[-1] } 0313 60 PUSH1 0x17 0315 81 DUP2 0316 14 EQ 0317 61 PUSH2 0x03ca 031A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if stack[-1] == 0x17 label_031B: // Incoming jump from 0x031A, if not stack[-1] == 0x17 // Inputs[1] { @031D stack[-1] } 031B 60 PUSH1 0x18 031D 81 DUP2 031E 14 EQ 031F 61 PUSH2 0x03d3 0322 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d3, if stack[-1] == 0x18 label_0323: // Incoming jump from 0x0322, if not stack[-1] == 0x18 // Inputs[1] { @0325 stack[-1] } 0323 60 PUSH1 0x1d 0325 81 DUP2 0326 14 EQ 0327 61 PUSH2 0x03dc 032A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03dc, if stack[-1] == 0x1d label_032B: // Incoming jump from 0x032A, if not stack[-1] == 0x1d // Inputs[1] { @032F memory[0x00:0x00] } 032B 60 PUSH1 0x00 032D 80 DUP1 032E 81 DUP2 032F FD *REVERT // Stack delta = +1 // Outputs[2] // { // @032B stack[0] = 0x00 // @032F revert(memory[0x00:0x00]); // } // Block terminates label_0330: // Incoming jump from 0x029A, if stack[-4] == 0x10 // Inputs[2] // { // @0331 stack[-4] // @0332 stack[-6] // } 0330 5B JUMPDEST 0331 83 DUP4 0332 86 DUP7 0333 10 LT 0334 95 SWAP6 0335 50 POP 0336 61 PUSH2 0x03e2 0339 56 *JUMP // Stack delta = +0 // Outputs[1] { @0334 stack[-6] = stack[-6] < stack[-4] } // Block ends with unconditional jump to 0x03e2 label_033A: // Incoming jump from 0x02A2, if stack[-1] == 0x11 // Inputs[2] // { // @033B stack[-4] // @033C stack[-6] // } 033A 5B JUMPDEST 033B 83 DUP4 033C 86 DUP7 033D 11 GT 033E 95 SWAP6 033F 50 POP 0340 61 PUSH2 0x03e2 0343 56 *JUMP // Stack delta = +0 // Outputs[1] { @033E stack[-6] = stack[-6] > stack[-4] } // Block ends with unconditional jump to 0x03e2 label_0344: // Incoming jump from 0x02AA, if stack[-1] == 0x12 // Inputs[2] // { // @0345 stack[-4] // @0346 stack[-6] // } 0344 5B JUMPDEST 0345 83 DUP4 0346 86 DUP7 0347 12 SLT 0348 95 SWAP6 0349 50 POP 034A 61 PUSH2 0x03e2 034D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0348 stack[-6] = stack[-6] i< stack[-4] } // Block ends with unconditional jump to 0x03e2 label_034E: // Incoming jump from 0x02B2, if stack[-1] == 0x13 // Inputs[2] // { // @034F stack[-4] // @0350 stack[-6] // } 034E 5B JUMPDEST 034F 83 DUP4 0350 86 DUP7 0351 13 SGT 0352 95 SWAP6 0353 50 POP 0354 61 PUSH2 0x03e2 0357 56 *JUMP // Stack delta = +0 // Outputs[1] { @0352 stack[-6] = stack[-6] i> stack[-4] } // Block ends with unconditional jump to 0x03e2 label_0358: // Incoming jump from 0x02BA, if stack[-1] == 0x19 // Inputs[2] // { // @0359 stack[-6] // @0359 stack[-1] // } 0358 5B JUMPDEST 0359 94 SWAP5 035A 19 NOT 035B 94 SWAP5 035C 61 PUSH2 0x03e2 035F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @035B stack[-1] = stack[-1] // @035B stack[-6] = ~stack[-6] // } // Block ends with unconditional jump to 0x03e2 label_0360: // Incoming jump from 0x02C2, if stack[-1] == 0x01 // Inputs[3] // { // @0361 stack[-1] // @0361 stack[-6] // @0362 stack[-4] // } 0360 5B JUMPDEST 0361 94 SWAP5 0362 83 DUP4 0363 01 ADD 0364 94 SWAP5 0365 61 PUSH2 0x03e2 0368 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0364 stack[-1] = stack[-1] // @0364 stack[-6] = stack[-4] + stack[-6] // } // Block ends with unconditional jump to 0x03e2 label_0369: // Incoming jump from 0x02CA, if stack[-1] == 0x02 // Inputs[3] // { // @036A stack[-1] // @036A stack[-6] // @036B stack[-4] // } 0369 5B JUMPDEST 036A 94 SWAP5 036B 83 DUP4 036C 02 MUL 036D 94 SWAP5 036E 61 PUSH2 0x03e2 0371 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @036D stack[-1] = stack[-1] // @036D stack[-6] = stack[-4] * stack[-6] // } // Block ends with unconditional jump to 0x03e2 label_0372: // Incoming jump from 0x02D2, if stack[-1] == 0x03 // Inputs[2] // { // @0373 stack[-4] // @0374 stack[-6] // } 0372 5B JUMPDEST 0373 83 DUP4 0374 86 DUP7 0375 03 SUB 0376 95 SWAP6 0377 50 POP 0378 61 PUSH2 0x03e2 037B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0376 stack[-6] = stack[-6] - stack[-4] } // Block ends with unconditional jump to 0x03e2 label_037C: // Incoming jump from 0x02DA, if stack[-1] == 0x04 // Inputs[2] // { // @037D stack[-4] // @037E stack[-6] // } 037C 5B JUMPDEST 037D 83 DUP4 037E 86 DUP7 037F 04 DIV 0380 95 SWAP6 0381 50 POP 0382 61 PUSH2 0x03e2 0385 56 *JUMP // Stack delta = +0 // Outputs[1] { @0380 stack[-6] = stack[-6] / stack[-4] } // Block ends with unconditional jump to 0x03e2 label_0386: // Incoming jump from 0x02E2, if stack[-1] == 0x14 // Inputs[3] // { // @0387 stack[-6] // @0387 stack[-1] // @0388 stack[-4] // } 0386 5B JUMPDEST 0387 94 SWAP5 0388 83 DUP4 0389 14 EQ 038A 94 SWAP5 038B 61 PUSH2 0x03e2 038E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @038A stack[-1] = stack[-1] // @038A stack[-6] = stack[-4] == stack[-6] // } // Block ends with unconditional jump to 0x03e2 label_038F: // Incoming jump from 0x02EA, if stack[-1] == 0x1e // Inputs[3] // { // @0390 stack[-6] // @0390 stack[-1] // @0391 stack[-4] // } 038F 5B JUMPDEST 0390 94 SWAP5 0391 83 DUP4 0392 14 EQ 0393 15 ISZERO 0394 94 SWAP5 0395 61 PUSH2 0x03e2 0398 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0394 stack[-1] = stack[-1] // @0394 stack[-6] = !(stack[-4] == stack[-6]) // } // Block ends with unconditional jump to 0x03e2 label_0399: // Incoming jump from 0x02F2, if stack[-1] == 0x05 // Inputs[2] // { // @039A stack[-4] // @039B stack[-6] // } 0399 5B JUMPDEST 039A 83 DUP4 039B 86 DUP7 039C 05 SDIV 039D 95 SWAP6 039E 50 POP 039F 61 PUSH2 0x03e2 03A2 56 *JUMP // Stack delta = +0 // Outputs[1] { @039D stack[-6] = stack[-6] i/ stack[-4] } // Block ends with unconditional jump to 0x03e2 label_03A3: // Incoming jump from 0x02FA, if stack[-1] == 0x06 // Inputs[2] // { // @03A4 stack[-4] // @03A5 stack[-6] // } 03A3 5B JUMPDEST 03A4 83 DUP4 03A5 86 DUP7 03A6 06 MOD 03A7 95 SWAP6 03A8 50 POP 03A9 61 PUSH2 0x03e2 03AC 56 *JUMP // Stack delta = +0 // Outputs[1] { @03A7 stack[-6] = stack[-6] % stack[-4] } // Block ends with unconditional jump to 0x03e2 label_03AD: // Incoming jump from 0x0302, if stack[-1] == 0x07 // Inputs[2] // { // @03AE stack[-4] // @03AF stack[-6] // } 03AD 5B JUMPDEST 03AE 83 DUP4 03AF 86 DUP7 03B0 07 SMOD 03B1 95 SWAP6 03B2 50 POP 03B3 61 PUSH2 0x03e2 03B6 56 *JUMP // Stack delta = +0 // Outputs[1] { @03B1 stack[-6] = stack[-6] i% stack[-4] } // Block ends with unconditional jump to 0x03e2 label_03B7: // Incoming jump from 0x030A, if stack[-1] == 0x0a // Inputs[2] // { // @03B8 stack[-4] // @03B9 stack[-6] // } 03B7 5B JUMPDEST 03B8 83 DUP4 03B9 86 DUP7 03BA 0A EXP 03BB 95 SWAP6 03BC 50 POP 03BD 61 PUSH2 0x03e2 03C0 56 *JUMP // Stack delta = +0 // Outputs[1] { @03BB stack[-6] = stack[-6] ** stack[-4] } // Block ends with unconditional jump to 0x03e2 label_03C1: // Incoming jump from 0x0312, if stack[-1] == 0x16 // Inputs[3] // { // @03C2 stack[-1] // @03C2 stack[-6] // @03C3 stack[-4] // } 03C1 5B JUMPDEST 03C2 94 SWAP5 03C3 83 DUP4 03C4 16 AND 03C5 94 SWAP5 03C6 61 PUSH2 0x03e2 03C9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03C5 stack[-1] = stack[-1] // @03C5 stack[-6] = stack[-4] & stack[-6] // } // Block ends with unconditional jump to 0x03e2 label_03CA: // Incoming jump from 0x031A, if stack[-1] == 0x17 // Inputs[3] // { // @03CB stack[-6] // @03CB stack[-1] // @03CC stack[-4] // } 03CA 5B JUMPDEST 03CB 94 SWAP5 03CC 83 DUP4 03CD 17 OR 03CE 94 SWAP5 03CF 61 PUSH2 0x03e2 03D2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03CE stack[-1] = stack[-1] // @03CE stack[-6] = stack[-4] | stack[-6] // } // Block ends with unconditional jump to 0x03e2 label_03D3: // Incoming jump from 0x0322, if stack[-1] == 0x18 // Inputs[3] // { // @03D4 stack[-6] // @03D4 stack[-1] // @03D5 stack[-4] // } 03D3 5B JUMPDEST 03D4 94 SWAP5 03D5 83 DUP4 03D6 18 XOR 03D7 94 SWAP5 03D8 61 PUSH2 0x03e2 03DB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03D7 stack[-1] = stack[-1] // @03D7 stack[-6] = stack[-4] ~ stack[-6] // } // Block ends with unconditional jump to 0x03e2 label_03DC: // Incoming jump from 0x032A, if stack[-1] == 0x1d // Inputs[2] // { // @03DD stack[-4] // @03DE stack[-6] // } 03DC 5B JUMPDEST 03DD 83 DUP4 03DE 86 DUP7 03DF 1D SAR 03E0 95 SWAP6 03E1 50 POP // Stack delta = +0 // Outputs[1] { @03E0 stack[-6] = stack[-4] i>> stack[-6] } // Block continues label_03E2: // Incoming jump from 0x0339 // Incoming jump from 0x0357 // Incoming jump from 0x0385 // Incoming jump from 0x03DB // Incoming jump from 0x03AC // Incoming jump from 0x038E // Incoming jump from 0x037B // Incoming jump from 0x0368 // Incoming jump from 0x0343 // Incoming jump from 0x03E1 // Incoming jump from 0x03C0 // Incoming jump from 0x034D // Incoming jump from 0x03B6 // Incoming jump from 0x03C9 // Incoming jump from 0x03A2 // Incoming jump from 0x03D2 // Incoming jump from 0x035F // Incoming jump from 0x0371 // Incoming jump from 0x0398 03E2 5B JUMPDEST 03E3 50 POP // Stack delta = -1 // Block continues label_03E4: // Incoming jump from 0x03E3 // Incoming jump from 0x0291, if !byte(stack[-2], 0x0d) // Inputs[3] // { // @03E7 stack[-4] // @03EA stack[-7] // @03EC stack[-1] // } 03E4 5B JUMPDEST 03E5 60 PUSH1 0x60 03E7 93 SWAP4 03E8 50 POP 03E9 83 DUP4 03EA 87 DUP8 03EB 01 ADD 03EC 81 DUP2 03ED 60 PUSH1 0x0e 03EF 1A BYTE 03F0 80 DUP1 03F1 15 ISZERO 03F2 61 PUSH2 0x0480 03F5 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03E7 stack[-4] = 0x60 // @03EB stack[0] = stack[-7] + 0x60 // @03EF stack[1] = byte(stack[-1], 0x0e) // } // Block ends with conditional jump to 0x0480, if !byte(stack[-1], 0x0e) label_03F6: // Incoming jump from 0x03F5, if not !byte(stack[-1], 0x0e) // Inputs[6] // { // @03F8 stack[-6] // @03F9 stack[-3] // @03FF stack[-9] // @0405 stack[-10] // @0407 memory[stack[-9] + (byte(stack[-3], 0x0f) << 0x05) + stack[-6]:stack[-9] + (byte(stack[-3], 0x0f) << 0x05) + stack[-6] + 0x20] // @0408 stack[-1] // } 03F6 60 PUSH1 0x05 03F8 86 DUP7 03F9 84 DUP5 03FA 60 PUSH1 0x0f 03FC 1A BYTE 03FD 82 DUP3 03FE 1B SHL 03FF 8B DUP12 0400 01 ADD 0401 01 ADD 0402 61 PUSH2 0x040d 0405 8C DUP13 0406 82 DUP3 0407 51 MLOAD 0408 85 DUP6 0409 61 PUSH2 0x057d 040C 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @03F6 stack[0] = 0x05 // @0401 stack[1] = stack[-9] + (byte(stack[-3], 0x0f) << 0x05) + stack[-6] // @0402 stack[2] = 0x040d // @0405 stack[3] = stack[-10] // @0407 stack[4] = memory[stack[-9] + (byte(stack[-3], 0x0f) << 0x05) + stack[-6]:stack[-9] + (byte(stack[-3], 0x0f) << 0x05) + stack[-6] + 0x20] // @0408 stack[5] = stack[-1] // } // Block ends with call to 0x057d, returns to 0x040D label_040D: // Incoming return from call to 0x057D at 0x040C // Inputs[3] // { // @040E stack[-2] // @040F stack[-1] // @0411 stack[-6] // } 040D 5B JUMPDEST 040E 81 DUP2 040F 52 MSTORE 0410 50 POP 0411 83 DUP4 0412 60 PUSH1 0x10 0414 1A BYTE 0415 80 DUP1 0416 15 ISZERO 0417 61 PUSH2 0x047d 041A 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @040F memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @0414 stack[-2] = byte(stack[-6], 0x10) // } // Block ends with conditional jump to 0x047d, if !byte(stack[-6], 0x10) label_041B: // Incoming jump from 0x041A, if not !byte(stack[-6], 0x10) // Inputs[7] // { // @041B stack[-8] // @041C stack[-5] // @0420 stack[-2] // @0422 stack[-11] // @0428 stack[-12] // @042A memory[stack[-11] + (byte(stack[-5], 0x11) << stack[-2]) + stack[-8]:stack[-11] + (byte(stack[-5], 0x11) << stack[-2]) + stack[-8] + 0x20] // @042B stack[-1] // } 041B 87 DUP8 041C 85 DUP6 041D 60 PUSH1 0x11 041F 1A BYTE 0420 83 DUP4 0421 1B SHL 0422 8C DUP13 0423 01 ADD 0424 01 ADD 0425 61 PUSH2 0x0430 0428 8D DUP14 0429 82 DUP3 042A 51 MLOAD 042B 84 DUP5 042C 61 PUSH2 0x057d 042F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0424 stack[0] = stack[-11] + (byte(stack[-5], 0x11) << stack[-2]) + stack[-8] // @0425 stack[1] = 0x0430 // @0428 stack[2] = stack[-12] // @042A stack[3] = memory[stack[-11] + (byte(stack[-5], 0x11) << stack[-2]) + stack[-8]:stack[-11] + (byte(stack[-5], 0x11) << stack[-2]) + stack[-8] + 0x20] // @042B stack[4] = stack[-1] // } // Block ends with call to 0x057d, returns to 0x0430 label_0430: // Incoming return from call to 0x057D at 0x042F // Inputs[3] // { // @0431 stack[-2] // @0432 stack[-1] // @0434 stack[-7] // } 0430 5B JUMPDEST 0431 81 DUP2 0432 52 MSTORE 0433 50 POP 0434 84 DUP5 0435 60 PUSH1 0x12 0437 1A BYTE 0438 80 DUP1 0439 15 ISZERO 043A 61 PUSH2 0x047b 043D 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0432 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @0437 stack[-2] = byte(stack[-7], 0x12) // } // Block ends with conditional jump to 0x047b, if !byte(stack[-7], 0x12) label_043E: // Incoming jump from 0x043D, if not !byte(stack[-7], 0x12) // Inputs[7] // { // @043E stack[-9] // @043F stack[-6] // @0443 stack[-3] // @0445 stack[-12] // @044B stack[-13] // @044D memory[stack[-12] + (byte(stack[-6], 0x13) << stack[-3]) + stack[-9]:stack[-12] + (byte(stack[-6], 0x13) << stack[-3]) + stack[-9] + 0x20] // @044E stack[-1] // } 043E 88 DUP9 043F 86 DUP7 0440 60 PUSH1 0x13 0442 1A BYTE 0443 84 DUP5 0444 1B SHL 0445 8D DUP14 0446 01 ADD 0447 01 ADD 0448 61 PUSH2 0x0453 044B 8E DUP15 044C 82 DUP3 044D 51 MLOAD 044E 84 DUP5 044F 61 PUSH2 0x057d 0452 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0447 stack[0] = stack[-12] + (byte(stack[-6], 0x13) << stack[-3]) + stack[-9] // @0448 stack[1] = 0x0453 // @044B stack[2] = stack[-13] // @044D stack[3] = memory[stack[-12] + (byte(stack[-6], 0x13) << stack[-3]) + stack[-9]:stack[-12] + (byte(stack[-6], 0x13) << stack[-3]) + stack[-9] + 0x20] // @044E stack[4] = stack[-1] // } // Block ends with call to 0x057d, returns to 0x0453 label_0453: // Incoming return from call to 0x057D at 0x0452 // Inputs[3] // { // @0454 stack[-2] // @0455 stack[-1] // @0457 stack[-8] // } 0453 5B JUMPDEST 0454 81 DUP2 0455 52 MSTORE 0456 50 POP 0457 85 DUP6 0458 60 PUSH1 0x14 045A 1A BYTE 045B 80 DUP1 045C 15 ISZERO 045D 61 PUSH2 0x0479 0460 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0455 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @045A stack[-2] = byte(stack[-8], 0x14) // } // Block ends with conditional jump to 0x0479, if !byte(stack[-8], 0x14) label_0461: // Incoming jump from 0x0460, if not !byte(stack[-8], 0x14) // Inputs[7] // { // @0461 stack[-10] // @0462 stack[-7] // @0466 stack[-4] // @0468 stack[-13] // @046E stack[-14] // @0470 memory[stack[-13] + (byte(stack[-7], 0x15) << stack[-4]) + stack[-10]:stack[-13] + (byte(stack[-7], 0x15) << stack[-4]) + stack[-10] + 0x20] // @0471 stack[-1] // } 0461 89 DUP10 0462 87 DUP8 0463 60 PUSH1 0x15 0465 1A BYTE 0466 85 DUP6 0467 1B SHL 0468 8E DUP15 0469 01 ADD 046A 01 ADD 046B 61 PUSH2 0x0476 046E 8F DUP16 046F 82 DUP3 0470 51 MLOAD 0471 84 DUP5 0472 61 PUSH2 0x057d 0475 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @046A stack[0] = stack[-13] + (byte(stack[-7], 0x15) << stack[-4]) + stack[-10] // @046B stack[1] = 0x0476 // @046E stack[2] = stack[-14] // @0470 stack[3] = memory[stack[-13] + (byte(stack[-7], 0x15) << stack[-4]) + stack[-10]:stack[-13] + (byte(stack[-7], 0x15) << stack[-4]) + stack[-10] + 0x20] // @0471 stack[4] = stack[-1] // } // Block ends with call to 0x057d, returns to 0x0476 label_0476: // Incoming return from call to 0x057D at 0x0475 // Inputs[2] // { // @0477 stack[-1] // @0477 stack[-2] // } 0476 5B JUMPDEST 0477 90 SWAP1 0478 52 MSTORE // Stack delta = -2 // Outputs[1] { @0478 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] } // Block continues label_0479: // Incoming jump from 0x0460, if !byte(stack[-8], 0x14) // Incoming jump from 0x0478 0479 5B JUMPDEST 047A 50 POP // Stack delta = -1 // Block continues label_047B: // Incoming jump from 0x047A // Incoming jump from 0x043D, if !byte(stack[-7], 0x12) 047B 5B JUMPDEST 047C 50 POP // Stack delta = -1 // Block continues label_047D: // Incoming jump from 0x047C // Incoming jump from 0x041A, if !byte(stack[-6], 0x10) 047D 5B JUMPDEST 047E 50 POP 047F 50 POP // Stack delta = -2 // Block continues label_0480: // Incoming jump from 0x03F5, if !byte(stack[-1], 0x0e) // Incoming jump from 0x047F // Inputs[2] // { // @0486 stack[-3] // @0487 stack[-4] // } 0480 5B JUMPDEST 0481 50 POP 0482 61 PUSH2 0xffff 0485 80 DUP1 0486 83 DUP4 0487 85 DUP6 0488 1C SHR 0489 16 AND 048A 93 SWAP4 048B 50 POP 048C 80 DUP1 048D 83 DUP4 048E 60 PUSH1 0x30 0490 1C SHR 0491 16 AND 0492 90 SWAP1 0493 50 POP 0494 82 DUP3 0495 60 PUSH1 0x0a 0497 1A BYTE 0498 60 PUSH1 0xff 049A 81 DUP2 049B 14 EQ 049C 61 PUSH2 0x04e5 049F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @048A stack[-4] = (stack[-3] >> stack[-4]) & 0xffff // @0492 stack[-1] = (stack[-3] >> 0x30) & 0xffff // @0497 stack[0] = byte(stack[-3], 0x0a) // } // Block ends with conditional jump to 0x04e5, if byte(stack[-3], 0x0a) == 0xff label_04A0: // Incoming jump from 0x049F, if not byte(stack[-3], 0x0a) == 0xff // Inputs[1] { @04A2 stack[-1] } 04A0 60 PUSH1 0xf1 04A2 81 DUP2 04A3 14 EQ 04A4 61 PUSH2 0x04ea 04A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ea, if stack[-1] == 0xf1 label_04A8: // Incoming jump from 0x04A7, if not stack[-1] == 0xf1 // Inputs[1] { @04AA stack[-1] } 04A8 60 PUSH1 0xf3 04AA 81 DUP2 04AB 14 EQ 04AC 61 PUSH2 0x0511 04AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0511, if stack[-1] == 0xf3 label_04B0: // Incoming jump from 0x04AF, if not stack[-1] == 0xf3 // Inputs[1] { @04B2 stack[-1] } 04B0 60 PUSH1 0xfe 04B2 81 DUP2 04B3 14 EQ 04B4 61 PUSH2 0x051b 04B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051b, if stack[-1] == 0xfe label_04B8: // Incoming jump from 0x04B7, if not stack[-1] == 0xfe // Inputs[1] { @04BA stack[-1] } 04B8 60 PUSH1 0x57 04BA 81 DUP2 04BB 14 EQ 04BC 61 PUSH2 0x052a 04BF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052a, if stack[-1] == 0x57 label_04C0: // Incoming jump from 0x04BF, if not stack[-1] == 0x57 // Inputs[1] { @04C2 stack[-1] } 04C0 60 PUSH1 0xf5 04C2 81 DUP2 04C3 14 EQ 04C4 61 PUSH2 0x0538 04C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0538, if stack[-1] == 0xf5 label_04C8: // Incoming jump from 0x04C7, if not stack[-1] == 0xf5 // Inputs[1] { @04CA stack[-1] } 04C8 60 PUSH1 0x5d 04CA 81 DUP2 04CB 14 EQ 04CC 61 PUSH2 0x0544 04CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0544, if stack[-1] == 0x5d label_04D0: // Incoming jump from 0x04CF, if not stack[-1] == 0x5d // Inputs[1] { @04D2 stack[-1] } 04D0 60 PUSH1 0x52 04D2 81 DUP2 04D3 14 EQ 04D4 61 PUSH2 0x054f 04D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054f, if stack[-1] == 0x52 label_04D8: // Incoming jump from 0x04D7, if not stack[-1] == 0x52 // Inputs[1] { @04DA stack[-1] } 04D8 60 PUSH1 0x55 04DA 81 DUP2 04DB 14 EQ 04DC 61 PUSH2 0x055c 04DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055c, if stack[-1] == 0x55 label_04E0: // Incoming jump from 0x04DF, if not stack[-1] == 0x55 // Inputs[1] { @04E4 memory[0x00:0x00] } 04E0 60 PUSH1 0x00 04E2 80 DUP1 04E3 81 DUP2 04E4 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @04E0 stack[0] = 0x00 // @04E4 revert(memory[0x00:0x00]); // } // Block terminates label_04E5: // Incoming jump from 0x0521, if !stack[-8] // Incoming jump from 0x0517, if !stack[-8] // Incoming return from call to 0x0760 at 0x054E // Incoming jump from 0x052F, if stack[-8] // Incoming jump from 0x049F, if byte(stack[-3], 0x0a) == 0xff 04E5 5B JUMPDEST 04E6 61 PUSH2 0x0560 04E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0560 label_04EA: // Incoming jump from 0x04A7, if stack[-1] == 0xf1 // Inputs[8] // { // @04EB stack[-4] // @04F2 stack[-10] // @04F3 stack[-2] // @04F8 stack[-8] // @04F9 stack[-6] // @04FA msg.gas // @04FB memory[stack[-10] + 0x5c:stack[-10] + 0x5c + stack[-2]] // @04FB address(stack[-6]).call.gas(msg.gas).value(stack[-8])(memory[stack[-10] + 0x5c:stack[-10] + 0x5c + stack[-2]]) // } 04EA 5B JUMPDEST 04EB 83 DUP4 04EC 60 PUSH1 0x1a 04EE 1A BYTE 04EF 60 PUSH1 0x05 04F1 1B SHL 04F2 8A DUP11 04F3 83 DUP4 04F4 60 PUSH1 0x5c 04F6 8D DUP14 04F7 01 ADD 04F8 8B DUP12 04F9 8A DUP11 04FA 5A GAS 04FB F1 CALL 04FC 61 PUSH2 0x0508 04FF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04FB memory[stack[-10]:stack[-10] + byte(stack[-4], 0x1a) << 0x05] = address(stack[-6]).call.gas(msg.gas).value(stack[-8])(memory[stack[-10] + 0x5c:stack[-10] + 0x5c + stack[-2]]) } // Block ends with conditional jump to 0x0508, if address(stack[-6]).call.gas(msg.gas).value(stack[-8])(memory[stack[-10] + 0x5c:stack[-10] + 0x5c + stack[-2]]) label_0500: // Incoming jump from 0x04FF, if not address(stack[-6]).call.gas(msg.gas).value(stack[-8])(memory[stack[-10] + 0x5c:stack[-10] + 0x5c + stack[-2]]) // Inputs[1] { @0503 stack[-4] } 0500 61 PUSH2 0x0508 0503 84 DUP5 0504 61 PUSH2 0x06b2 0507 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0500 stack[0] = 0x0508 // @0503 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x06b2 label_0508: // Incoming jump from 0x04FF, if address(stack[-6]).call.gas(msg.gas).value(stack[-8])(memory[stack[-10] + 0x5c:stack[-10] + 0x5c + stack[-2]]) // Inputs[3] // { // @0509 stack[-10] // @050A memory[stack[-10]:stack[-10] + 0x20] // @050B stack[-8] // } 0508 5B JUMPDEST 0509 89 DUP10 050A 51 MLOAD 050B 97 SWAP8 050C 50 POP 050D 61 PUSH2 0x0560 0510 56 *JUMP // Stack delta = +0 // Outputs[1] { @050B stack[-8] = memory[stack[-10]:stack[-10] + 0x20] } // Block ends with unconditional jump to 0x0560 label_0511: // Incoming jump from 0x04AF, if stack[-1] == 0xf3 // Inputs[1] { @0512 stack[-8] } 0511 5B JUMPDEST 0512 87 DUP8 0513 15 ISZERO 0514 61 PUSH2 0x04e5 0517 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e5, if !stack[-8] label_0518: // Incoming jump from 0x0517, if not !stack[-8] // Inputs[3] // { // @0518 stack[-2] // @0519 stack[-3] // @051A memory[stack[-3]:stack[-3] + stack[-2]] // } 0518 81 DUP2 0519 83 DUP4 051A F3 *RETURN // Stack delta = +0 // Outputs[1] { @051A return memory[stack[-3]:stack[-3] + stack[-2]]; } // Block terminates label_051B: // Incoming jump from 0x04B7, if stack[-1] == 0xfe // Inputs[1] { @051C stack[-8] } 051B 5B JUMPDEST 051C 87 DUP8 051D 15 ISZERO 051E 61 PUSH2 0x04e5 0521 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e5, if !stack[-8] label_0522: // Incoming jump from 0x0521, if not !stack[-8] // Inputs[1] { @0525 stack[-4] } 0522 61 PUSH2 0x04e5 0525 84 DUP5 0526 61 PUSH2 0x0734 0529 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0522 stack[0] = 0x04e5 // @0525 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x0734 label_052A: // Incoming jump from 0x04BF, if stack[-1] == 0x57 // Inputs[1] { @052B stack[-8] } 052A 5B JUMPDEST 052B 87 DUP8 052C 61 PUSH2 0x04e5 052F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e5, if stack[-8] label_0530: // Incoming jump from 0x052F, if not stack[-8] // Inputs[1] { @0532 stack[-5] } 0530 60 PUSH1 0x00 0532 94 SWAP5 0533 50 POP 0534 61 PUSH2 0x0560 0537 56 *JUMP // Stack delta = +0 // Outputs[1] { @0532 stack[-5] = 0x00 } // Block ends with unconditional jump to 0x0560 label_0538: // Incoming jump from 0x04C7, if stack[-1] == 0xf5 // Inputs[6] // { // @0539 stack[-6] // @053A stack[-2] // @053B stack[-3] // @053C stack[-8] // @053D memory[stack[-3]:stack[-3] + stack[-2]] // @053D new(memory[stack[-3]:stack[-3] + stack[-2]]).value(stack[-8]).salt(stack[-6])() // } 0538 5B JUMPDEST 0539 85 DUP6 053A 82 DUP3 053B 84 DUP5 053C 8A DUP11 053D F5 CREATE2 053E 97 SWAP8 053F 50 POP 0540 61 PUSH2 0x0560 0543 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @053D new(memory[stack[-3]:stack[-3] + stack[-2]]).value(stack[-8]).salt(stack[-6])() // @053E stack[-8] = new(memory[stack[-3]:stack[-3] + stack[-2]]).value(stack[-8]).salt(stack[-6])() // } // Block ends with unconditional jump to 0x0560 label_0544: // Incoming jump from 0x04CF, if stack[-1] == 0x5d // Inputs[3] // { // @0548 stack[-2] // @0549 stack[-3] // @054A stack[-8] // } 0544 5B JUMPDEST 0545 61 PUSH2 0x04e5 0548 82 DUP3 0549 84 DUP5 054A 8A DUP11 054B 61 PUSH2 0x0760 054E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0545 stack[0] = 0x04e5 // @0548 stack[1] = stack[-2] // @0549 stack[2] = stack[-3] // @054A stack[3] = stack[-8] // } // Block ends with call to 0x0760, returns to 0x04E5 label_054F: // Incoming jump from 0x04D7, if stack[-1] == 0x52 // Inputs[3] // { // @0550 stack[-8] // @0551 stack[-6] // @0555 stack[-11] // } 054F 5B JUMPDEST 0550 87 DUP8 0551 86 DUP7 0552 60 PUSH1 0x05 0554 1B SHL 0555 8C DUP13 0556 01 ADD 0557 52 MSTORE 0558 61 PUSH2 0x0560 055B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0557 memory[stack[-11] + (stack[-6] << 0x05):stack[-11] + (stack[-6] << 0x05) + 0x20] = stack[-8] } // Block ends with unconditional jump to 0x0560 label_055C: // Incoming jump from 0x04DF, if stack[-1] == 0x55 // Inputs[2] // { // @055D stack[-6] // @055E stack[-8] // } 055C 5B JUMPDEST 055D 85 DUP6 055E 88 DUP9 055F 55 SSTORE // Stack delta = +0 // Outputs[1] { @055F storage[stack[-8]] = stack[-6] } // Block continues label_0560: // Incoming jump from 0x0537 // Incoming jump from 0x0510 // Incoming jump from 0x0543 // Incoming jump from 0x055B // Incoming jump from 0x04E9 // Incoming jump from 0x055F // Inputs[6] // { // @0566 stack[-4] // @0567 stack[-5] // @0568 stack[-8] // @056A stack[-10] // @056D stack[-7] // @056F stack[-9] // } 0560 5B JUMPDEST 0561 50 POP 0562 50 POP 0563 50 POP 0564 60 PUSH1 0x1b 0566 1A BYTE 0567 90 SWAP1 0568 93 SWAP4 0569 03 SUB 056A 85 DUP6 056B 52 MSTORE 056C 50 POP 056D 92 SWAP3 056E 01 ADD 056F 90 SWAP1 0570 91 SWAP2 0571 01 ADD 0572 90 SWAP1 0573 61 PUSH2 0x0237 0576 56 *JUMP // Stack delta = -8 // Outputs[3] // { // @056B memory[stack[-10]:stack[-10] + 0x20] = stack[-8] - byte(stack[-4], 0x1b) // @0572 stack[-10] = stack[-7] + stack[-10] + stack[-5] // @0572 stack[-9] = stack[-9] // } // Block ends with unconditional jump to 0x0237 label_0577: // Incoming jump from 0x023F, if !(stack[-2] < stack[-2] + stack[-3]) // Incoming jump from 0x023F, if !(stack[-2] < stack[-1]) // Inputs[1] { @057C stack[-5] } 0577 5B JUMPDEST 0578 50 POP 0579 50 POP 057A 50 POP 057B 50 POP 057C 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_057D: // Incoming call from 0x027D, returns to 0x027E // Incoming call from 0x0475, returns to 0x0476 // Incoming call from 0x042F, returns to 0x0430 // Incoming call from 0x040C, returns to 0x040D // Incoming call from 0x0452, returns to 0x0453 // Incoming call from 0x0261, returns to 0x0262 // Inputs[1] { @0580 stack[-1] } 057D 5B JUMPDEST 057E 60 PUSH1 0x00 0580 81 DUP2 0581 60 PUSH1 0x51 0583 81 DUP2 0584 14 EQ 0585 61 PUSH2 0x0615 0588 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @057E stack[0] = 0x00 // @0580 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0615, if stack[-1] == 0x51 label_0589: // Incoming jump from 0x0588, if not stack[-1] == 0x51 // Inputs[1] { @058B stack[-1] } 0589 60 PUSH1 0x5a 058B 81 DUP2 058C 14 EQ 058D 61 PUSH2 0x0623 0590 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0623, if stack[-1] == 0x5a label_0591: // Incoming jump from 0x0590, if not stack[-1] == 0x5a // Inputs[1] { @0593 stack[-1] } 0591 60 PUSH1 0x47 0593 81 DUP2 0594 14 EQ 0595 61 PUSH2 0x062b 0598 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062b, if stack[-1] == 0x47 label_0599: // Incoming jump from 0x0598, if not stack[-1] == 0x47 // Inputs[1] { @059B stack[-1] } 0599 60 PUSH1 0x41 059B 81 DUP2 059C 14 EQ 059D 61 PUSH2 0x0633 05A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0633, if stack[-1] == 0x41 label_05A1: // Incoming jump from 0x05A0, if not stack[-1] == 0x41 // Inputs[1] { @05A3 stack[-1] } 05A1 60 PUSH1 0x19 05A3 81 DUP2 05A4 14 EQ 05A5 61 PUSH2 0x063b 05A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063b, if stack[-1] == 0x19 label_05A9: // Incoming jump from 0x05A8, if not stack[-1] == 0x19 // Inputs[1] { @05AB stack[-1] } 05A9 60 PUSH1 0x43 05AB 81 DUP2 05AC 14 EQ 05AD 61 PUSH2 0x0644 05B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0644, if stack[-1] == 0x43 label_05B1: // Incoming jump from 0x05B0, if not stack[-1] == 0x43 // Inputs[1] { @05B3 stack[-1] } 05B1 60 PUSH1 0x31 05B3 81 DUP2 05B4 14 EQ 05B5 61 PUSH2 0x064c 05B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064c, if stack[-1] == 0x31 label_05B9: // Incoming jump from 0x05B8, if not stack[-1] == 0x31 // Inputs[1] { @05BB stack[-1] } 05B9 60 PUSH1 0x34 05BB 81 DUP2 05BC 14 EQ 05BD 61 PUSH2 0x0655 05C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0655, if stack[-1] == 0x34 label_05C1: // Incoming jump from 0x05C0, if not stack[-1] == 0x34 // Inputs[1] { @05C3 stack[-1] } 05C1 60 PUSH1 0x33 05C3 81 DUP2 05C4 14 EQ 05C5 61 PUSH2 0x065d 05C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065d, if stack[-1] == 0x33 label_05C9: // Incoming jump from 0x05C8, if not stack[-1] == 0x33 // Inputs[1] { @05CB stack[-1] } 05C9 60 PUSH1 0x42 05CB 81 DUP2 05CC 14 EQ 05CD 61 PUSH2 0x0665 05D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0665, if stack[-1] == 0x42 label_05D1: // Incoming jump from 0x05D0, if not stack[-1] == 0x42 // Inputs[1] { @05D3 stack[-1] } 05D1 60 PUSH1 0x36 05D3 81 DUP2 05D4 14 EQ 05D5 61 PUSH2 0x066d 05D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066d, if stack[-1] == 0x36 label_05D9: // Incoming jump from 0x05D8, if not stack[-1] == 0x36 // Inputs[1] { @05DB stack[-1] } 05D9 60 PUSH1 0x3a 05DB 81 DUP2 05DC 14 EQ 05DD 61 PUSH2 0x0675 05E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0675, if stack[-1] == 0x3a label_05E1: // Incoming jump from 0x05E0, if not stack[-1] == 0x3a // Inputs[1] { @05E3 stack[-1] } 05E1 60 PUSH1 0x40 05E3 81 DUP2 05E4 14 EQ 05E5 61 PUSH2 0x067d 05E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067d, if stack[-1] == 0x40 label_05E9: // Incoming jump from 0x05E8, if not stack[-1] == 0x40 // Inputs[1] { @05EB stack[-1] } 05E9 60 PUSH1 0x44 05EB 81 DUP2 05EC 14 EQ 05ED 61 PUSH2 0x0686 05F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0686, if stack[-1] == 0x44 label_05F1: // Incoming jump from 0x05F0, if not stack[-1] == 0x44 // Inputs[1] { @05F3 stack[-1] } 05F1 60 PUSH1 0x45 05F3 81 DUP2 05F4 14 EQ 05F5 61 PUSH2 0x068e 05F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068e, if stack[-1] == 0x45 label_05F9: // Incoming jump from 0x05F8, if not stack[-1] == 0x45 // Inputs[1] { @05FB stack[-1] } 05F9 60 PUSH1 0x48 05FB 81 DUP2 05FC 14 EQ 05FD 61 PUSH2 0x0696 0600 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0696, if stack[-1] == 0x48 label_0601: // Incoming jump from 0x0600, if not stack[-1] == 0x48 // Inputs[1] { @0603 stack[-1] } 0601 60 PUSH1 0x30 0603 81 DUP2 0604 14 EQ 0605 61 PUSH2 0x069e 0608 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x069e, if stack[-1] == 0x30 label_0609: // Incoming jump from 0x0608, if not stack[-1] == 0x30 // Inputs[1] { @060B stack[-1] } 0609 60 PUSH1 0x32 060B 81 DUP2 060C 14 EQ 060D 61 PUSH2 0x06a6 0610 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a6, if stack[-1] == 0x32 label_0611: // Incoming jump from 0x0610, if not stack[-1] == 0x32 // Inputs[1] { @0614 memory[0x00:0x00] } 0611 60 PUSH1 0x00 0613 80 DUP1 0614 FD *REVERT // Stack delta = +0 // Outputs[1] { @0614 revert(memory[0x00:0x00]); } // Block terminates label_0615: // Incoming jump from 0x0588, if stack[-1] == 0x51 // Inputs[4] // { // @0616 stack[-4] // @061A stack[-5] // @061C memory[stack[-5] + (stack[-4] << 0x05):stack[-5] + (stack[-4] << 0x05) + 0x20] // @061D stack[-2] // } 0615 5B JUMPDEST 0616 83 DUP4 0617 60 PUSH1 0x05 0619 1B SHL 061A 85 DUP6 061B 01 ADD 061C 51 MLOAD 061D 91 SWAP2 061E 50 POP 061F 61 PUSH2 0x06aa 0622 56 *JUMP // Stack delta = +0 // Outputs[1] { @061D stack[-2] = memory[stack[-5] + (stack[-4] << 0x05):stack[-5] + (stack[-4] << 0x05) + 0x20] } // Block ends with unconditional jump to 0x06aa label_0623: // Incoming jump from 0x0590, if stack[-1] == 0x5a // Inputs[2] // { // @0624 msg.gas // @0625 stack[-2] // } 0623 5B JUMPDEST 0624 5A GAS 0625 91 SWAP2 0626 50 POP 0627 61 PUSH2 0x06aa 062A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0625 stack[-2] = msg.gas } // Block ends with unconditional jump to 0x06aa label_062B: // Incoming jump from 0x0598, if stack[-1] == 0x47 // Inputs[3] // { // @062C address(this).balance // @062C address(this) // @062D stack[-2] // } 062B 5B JUMPDEST 062C 47 SELFBALANCE 062D 91 SWAP2 062E 50 POP 062F 61 PUSH2 0x06aa 0632 56 *JUMP // Stack delta = +0 // Outputs[1] { @062D stack[-2] = address(this).balance } // Block ends with unconditional jump to 0x06aa label_0633: // Incoming jump from 0x05A0, if stack[-1] == 0x41 // Inputs[2] // { // @0634 block.coinbase // @0635 stack[-2] // } 0633 5B JUMPDEST 0634 41 COINBASE 0635 91 SWAP2 0636 50 POP 0637 61 PUSH2 0x06aa 063A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0635 stack[-2] = block.coinbase } // Block ends with unconditional jump to 0x06aa label_063B: // Incoming jump from 0x05A8, if stack[-1] == 0x19 // Inputs[2] // { // @063C stack[-4] // @063E stack[-2] // } 063B 5B JUMPDEST 063C 83 DUP4 063D 19 NOT 063E 91 SWAP2 063F 50 POP 0640 61 PUSH2 0x06aa 0643 56 *JUMP // Stack delta = +0 // Outputs[1] { @063E stack[-2] = ~stack[-4] } // Block ends with unconditional jump to 0x06aa label_0644: // Incoming jump from 0x05B0, if stack[-1] == 0x43 // Inputs[2] // { // @0645 block.number // @0646 stack[-2] // } 0644 5B JUMPDEST 0645 43 NUMBER 0646 91 SWAP2 0647 50 POP 0648 61 PUSH2 0x06aa 064B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0646 stack[-2] = block.number } // Block ends with unconditional jump to 0x06aa label_064C: // Incoming jump from 0x05B8, if stack[-1] == 0x31 // Inputs[3] // { // @064D stack[-4] // @064E address(stack[-4]).balance // @064F stack[-2] // } 064C 5B JUMPDEST 064D 83 DUP4 064E 31 BALANCE 064F 91 SWAP2 0650 50 POP 0651 61 PUSH2 0x06aa 0654 56 *JUMP // Stack delta = +0 // Outputs[1] { @064F stack[-2] = address(stack[-4]).balance } // Block ends with unconditional jump to 0x06aa label_0655: // Incoming jump from 0x05C0, if stack[-1] == 0x34 // Inputs[2] // { // @0656 msg.value // @0657 stack[-2] // } 0655 5B JUMPDEST 0656 34 CALLVALUE 0657 91 SWAP2 0658 50 POP 0659 61 PUSH2 0x06aa 065C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0657 stack[-2] = msg.value } // Block ends with unconditional jump to 0x06aa label_065D: // Incoming jump from 0x05C8, if stack[-1] == 0x33 // Inputs[2] // { // @065E msg.sender // @065F stack[-2] // } 065D 5B JUMPDEST 065E 33 CALLER 065F 91 SWAP2 0660 50 POP 0661 61 PUSH2 0x06aa 0664 56 *JUMP // Stack delta = +0 // Outputs[1] { @065F stack[-2] = msg.sender } // Block ends with unconditional jump to 0x06aa label_0665: // Incoming jump from 0x05D0, if stack[-1] == 0x42 // Inputs[2] // { // @0666 block.timestamp // @0667 stack[-2] // } 0665 5B JUMPDEST 0666 42 TIMESTAMP 0667 91 SWAP2 0668 50 POP 0669 61 PUSH2 0x06aa 066C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0667 stack[-2] = block.timestamp } // Block ends with unconditional jump to 0x06aa label_066D: // Incoming jump from 0x05D8, if stack[-1] == 0x36 // Inputs[2] // { // @066E msg.data.length // @066F stack[-2] // } 066D 5B JUMPDEST 066E 36 CALLDATASIZE 066F 91 SWAP2 0670 50 POP 0671 61 PUSH2 0x06aa 0674 56 *JUMP // Stack delta = +0 // Outputs[1] { @066F stack[-2] = msg.data.length } // Block ends with unconditional jump to 0x06aa label_0675: // Incoming jump from 0x05E0, if stack[-1] == 0x3a // Inputs[2] // { // @0676 tx.gasprice // @0677 stack[-2] // } 0675 5B JUMPDEST 0676 3A GASPRICE 0677 91 SWAP2 0678 50 POP 0679 61 PUSH2 0x06aa 067C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0677 stack[-2] = tx.gasprice } // Block ends with unconditional jump to 0x06aa label_067D: // Incoming jump from 0x05E8, if stack[-1] == 0x40 // Inputs[3] // { // @067E stack[-4] // @067F block.blockHash(stack[-4]) // @0680 stack[-2] // } 067D 5B JUMPDEST 067E 83 DUP4 067F 40 BLOCKHASH 0680 91 SWAP2 0681 50 POP 0682 61 PUSH2 0x06aa 0685 56 *JUMP // Stack delta = +0 // Outputs[1] { @0680 stack[-2] = block.blockHash(stack[-4]) } // Block ends with unconditional jump to 0x06aa label_0686: // Incoming jump from 0x05F0, if stack[-1] == 0x44 // Inputs[2] // { // @0687 block.difficulty // @0688 stack[-2] // } 0686 5B JUMPDEST 0687 44 DIFFICULTY 0688 91 SWAP2 0689 50 POP 068A 61 PUSH2 0x06aa 068D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0688 stack[-2] = block.difficulty } // Block ends with unconditional jump to 0x06aa label_068E: // Incoming jump from 0x05F8, if stack[-1] == 0x45 // Inputs[2] // { // @068F block.gaslimit // @0690 stack[-2] // } 068E 5B JUMPDEST 068F 45 GASLIMIT 0690 91 SWAP2 0691 50 POP 0692 61 PUSH2 0x06aa 0695 56 *JUMP // Stack delta = +0 // Outputs[1] { @0690 stack[-2] = block.gaslimit } // Block ends with unconditional jump to 0x06aa label_0696: // Incoming jump from 0x0600, if stack[-1] == 0x48 // Inputs[2] // { // @0697 BASEFEE() // @0698 stack[-2] // } 0696 5B JUMPDEST 0697 48 BASEFEE 0698 91 SWAP2 0699 50 POP 069A 61 PUSH2 0x06aa 069D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0698 stack[-2] = BASEFEE() } // Block ends with unconditional jump to 0x06aa label_069E: // Incoming jump from 0x0608, if stack[-1] == 0x30 // Inputs[2] // { // @069F address(this) // @06A0 stack[-2] // } 069E 5B JUMPDEST 069F 30 ADDRESS 06A0 91 SWAP2 06A1 50 POP 06A2 61 PUSH2 0x06aa 06A5 56 *JUMP // Stack delta = +0 // Outputs[1] { @06A0 stack[-2] = address(this) } // Block ends with unconditional jump to 0x06aa label_06A6: // Incoming jump from 0x0610, if stack[-1] == 0x32 // Inputs[2] // { // @06A7 tx.origin // @06A8 stack[-2] // } 06A6 5B JUMPDEST 06A7 32 ORIGIN 06A8 91 SWAP2 06A9 50 POP // Stack delta = +0 // Outputs[1] { @06A8 stack[-2] = tx.origin } // Block continues label_06AA: // Incoming jump from 0x069D // Incoming jump from 0x067C // Incoming jump from 0x0695 // Incoming jump from 0x065C // Incoming jump from 0x064B // Incoming jump from 0x0622 // Incoming jump from 0x066C // Incoming jump from 0x0643 // Incoming jump from 0x068D // Incoming jump from 0x062A // Incoming jump from 0x06A9 // Incoming jump from 0x063A // Incoming jump from 0x0654 // Incoming jump from 0x0674 // Incoming jump from 0x0664 // Incoming jump from 0x06A5 // Incoming jump from 0x0685 // Incoming jump from 0x0632 // Inputs[3] // { // @06AC stack[-2] // @06AC stack[-6] // @06AD stack[-5] // } 06AA 5B JUMPDEST 06AB 50 POP 06AC 93 SWAP4 06AD 92 SWAP3 06AE 50 POP 06AF 50 POP 06B0 50 POP 06B1 56 *JUMP // Stack delta = -5 // Outputs[1] { @06AC stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_06B2: // Incoming jump from 0x0507 // Inputs[3] // { // @06B5 memory[0x40:0x60] // @06C7 stack[-1] // @06D0 returndata.length // } 06B2 5B JUMPDEST 06B3 60 PUSH1 0x40 06B5 51 MLOAD 06B6 63 PUSH4 0x08c379a0 06BB 81 DUP2 06BC 52 MSTORE 06BD 60 PUSH1 0x20 06BF 80 DUP1 06C0 82 DUP3 06C1 01 ADD 06C2 52 MSTORE 06C3 60 PUSH1 0x60 06C5 81 DUP2 06C6 01 ADD 06C7 82 DUP3 06C8 90 SWAP1 06C9 52 MSTORE 06CA 60 PUSH1 0x6a 06CC 81 DUP2 06CD 01 ADD 06CE 60 PUSH1 0x0a 06D0 3D RETURNDATASIZE 06D1 15 ISZERO 06D2 61 PUSH2 0x0713 06D5 57 *JUMPI // Stack delta = +3 // Outputs[6] // { // @06B5 stack[0] = memory[0x40:0x60] // @06BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a0 // @06C2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x20 // @06C9 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-1] // @06CD stack[1] = memory[0x40:0x60] + 0x6a // @06CE stack[2] = 0x0a // } // Block ends with conditional jump to 0x0713, if !returndata.length label_06D6: // Incoming jump from 0x06D5, if not !returndata.length // Inputs[4] // { // @06D6 returndata.length // @06D9 stack[-2] // @06DA returndata[0x00:0x00 + returndata.length] // @06DC memory[stack[-2]:stack[-2] + 0x20] // } 06D6 3D RETURNDATASIZE 06D7 60 PUSH1 0x00 06D9 83 DUP4 06DA 3E RETURNDATACOPY 06DB 81 DUP2 06DC 51 MLOAD 06DD 60 PUSH1 0xe0 06DF 1C SHR 06E0 63 PUSH4 0x08c379a0 06E5 81 DUP2 06E6 14 EQ 06E7 61 PUSH2 0x06f9 06EA 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @06DA memory[stack[-2]:stack[-2] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @06DF stack[0] = memory[stack[-2]:stack[-2] + 0x20] >> 0xe0 // } // Block ends with conditional jump to 0x06f9, if memory[stack[-2]:stack[-2] + 0x20] >> 0xe0 == 0x08c379a0 label_06EB: // Incoming jump from 0x06EA, if not memory[stack[-2]:stack[-2] + 0x20] >> 0xe0 == 0x08c379a0 // Inputs[4] // { // @06EB returndata.length // @06EC stack[-3] // @06F0 returndata.length // @06F1 stack[-2] // } 06EB 3D RETURNDATASIZE 06EC 83 DUP4 06ED 01 ADD 06EE 92 SWAP3 06EF 50 POP 06F0 3D RETURNDATASIZE 06F1 82 DUP3 06F2 01 ADD 06F3 91 SWAP2 06F4 50 POP 06F5 61 PUSH2 0x0711 06F8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06EE stack[-3] = stack[-3] + returndata.length // @06F3 stack[-2] = stack[-2] + returndata.length // } // Block ends with unconditional jump to 0x0711 label_06F9: // Incoming jump from 0x06EA, if memory[stack[-2]:stack[-2] + 0x20] >> 0xe0 == 0x08c379a0 // Inputs[6] // { // @06FC stack[-4] // @06FE memory[stack[-4] + 0x8e:stack[-4] + 0x8e + 0x20] // @0702 stack[-3] // @0703 returndata[0x44:0x44 + memory[stack[-4] + 0x8e:stack[-4] + 0x8e + 0x20]] // @070C stack[-2] // @070D stack[-1] // } 06F9 5B JUMPDEST 06FA 60 PUSH1 0x8e 06FC 84 DUP5 06FD 01 ADD 06FE 51 MLOAD 06FF 80 DUP1 0700 60 PUSH1 0x44 0702 85 DUP6 0703 3E RETURNDATACOPY 0704 84 DUP5 0705 81 DUP2 0706 01 ADD 0707 60 PUSH1 0x6a 0709 01 ADD 070A 93 SWAP4 070B 50 POP 070C 91 SWAP2 070D 90 SWAP1 070E 91 SWAP2 070F 01 ADD 0710 90 SWAP1 0711 5B JUMPDEST 0712 50 POP // Stack delta = -1 // Outputs[3] // { // @0703 memory[stack[-3]:stack[-3] + memory[stack[-4] + 0x8e:stack[-4] + 0x8e + 0x20]] = returndata[0x44:0x44 + memory[stack[-4] + 0x8e:stack[-4] + 0x8e + 0x20]] // @070A stack[-3] = 0x6a + memory[stack[-4] + 0x8e:stack[-4] + 0x8e + 0x20] + stack[-4] // @0710 stack[-2] = memory[stack[-4] + 0x8e:stack[-4] + 0x8e + 0x20] + stack[-2] // } // Block continues label_0713: // Incoming jump from 0x0712 // Incoming jump from 0x06D5, if !returndata.length // Incoming jump from 0x0712 // Inputs[4] // { // @0714 stack[-1] // @0717 stack[-3] // @071C stack[-2] // @0733 memory[stack[-3] + 0x1c:stack[-3] + 0x1c + 0x44 + ((stack[-1] >> 0x05) + !!(stack[-1] & 0x1f) << 0x05)] // } 0713 5B JUMPDEST 0714 80 DUP1 0715 60 PUSH1 0x40 0717 84 DUP5 0718 01 ADD 0719 52 MSTORE 071A 60 PUSH1 0x00 071C 82 DUP3 071D 52 MSTORE 071E 60 PUSH1 0x1f 0720 81 DUP2 0721 16 AND 0722 15 ISZERO 0723 15 ISZERO 0724 81 DUP2 0725 60 PUSH1 0x05 0727 1C SHR 0728 01 ADD 0729 60 PUSH1 0x05 072B 1B SHL 072C 60 PUSH1 0x44 072E 01 ADD 072F 60 PUSH1 0x1c 0731 84 DUP5 0732 01 ADD 0733 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0719 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] = stack[-1] // @071D memory[stack[-2]:stack[-2] + 0x20] = 0x00 // @0733 revert(memory[stack[-3] + 0x1c:stack[-3] + 0x1c + 0x44 + ((stack[-1] >> 0x05) + !!(stack[-1] & 0x1f) << 0x05)]); // } // Block terminates label_0734: // Incoming jump from 0x0529 // Inputs[3] // { // @0737 memory[0x40:0x60] // @0745 stack[-1] // @075F memory[memory[0x40:0x60] + 0x1c:memory[0x40:0x60] + 0x1c + 0x64] // } 0734 5B JUMPDEST 0735 60 PUSH1 0x40 0737 51 MLOAD 0738 63 PUSH4 0x08c379a0 073D 81 DUP2 073E 52 MSTORE 073F 60 PUSH1 0x20 0741 80 DUP1 0742 82 DUP3 0743 01 ADD 0744 52 MSTORE 0745 81 DUP2 0746 60 PUSH1 0x60 0748 82 DUP3 0749 01 ADD 074A 52 MSTORE 074B 60 PUSH1 0x0a 074D 60 PUSH1 0x40 074F 82 DUP3 0750 01 ADD 0751 52 MSTORE 0752 60 PUSH1 0x00 0754 60 PUSH1 0x6a 0756 82 DUP3 0757 01 ADD 0758 52 MSTORE 0759 60 PUSH1 0x64 075B 60 PUSH1 0x1c 075D 82 DUP3 075E 01 ADD 075F FD *REVERT // Stack delta = +1 // Outputs[7] // { // @0737 stack[0] = memory[0x40:0x60] // @073E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a0 // @0744 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x20 // @074A memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-1] // @0751 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x0a // @0758 memory[memory[0x40:0x60] + 0x6a:memory[0x40:0x60] + 0x6a + 0x20] = 0x00 // @075F revert(memory[memory[0x40:0x60] + 0x1c:memory[0x40:0x60] + 0x1c + 0x64]); // } // Block terminates label_0760: // Incoming call from 0x054E, returns to 0x04E5 // Inputs[1] { @0764 stack[-3] } 0760 5B JUMPDEST 0761 60 PUSH1 0x20 0763 80 DUP1 0764 84 DUP5 0765 10 LT 0766 60 PUSH1 0x01 0768 81 DUP2 0769 14 EQ 076A 61 PUSH2 0x07a1 076D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0761 stack[0] = 0x20 // @0765 stack[1] = stack[-3] < 0x20 // } // Block ends with conditional jump to 0x07a1, if (stack[-3] < 0x20) == 0x01 label_076E: // Incoming jump from 0x076D, if not (stack[-3] < 0x20) == 0x01 // Inputs[4] // { // @0771 stack[-5] // @0775 stack[-3] // @077D stack[-2] // @077F memory[0x00:0x00 + stack[-2]] // } 076E 60 PUSH1 0x01 0770 80 DUP1 0771 86 DUP7 0772 82 DUP3 0773 1B SHL 0774 01 ADD 0775 84 DUP5 0776 55 SSTORE 0777 83 DUP4 0778 60 PUSH1 0x00 077A 52 MSTORE 077B 60 PUSH1 0x00 077D 83 DUP4 077E 81 DUP2 077F 20 SHA3 0780 5B JUMPDEST 0781 87 DUP8 0782 82 DUP3 0783 10 LT 0784 15 ISZERO 0785 61 PUSH2 0x0799 0788 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @076E stack[0] = 0x01 // @0776 storage[stack[-3]] = (stack[-5] << 0x01) + 0x01 // @077A memory[0x00:0x20] = stack[-3] // @077B stack[1] = 0x00 // @077F stack[2] = keccak256(memory[0x00:0x00 + stack[-2]]) // } // Block ends with conditional jump to 0x0799, if !(0x00 < stack[-5]) label_0789: // Incoming jump from 0x0788, if not !(stack[-2] < stack[-8]) // Incoming jump from 0x0788, if not !(0x00 < stack[-5]) // Inputs[6] // { // @0789 stack[-7] // @078A stack[-2] // @078C memory[stack[-2] + stack[-7]:stack[-2] + stack[-7] + 0x20] // @078D stack[-1] // @0790 stack[-5] // @0793 stack[-3] // } 0789 86 DUP7 078A 82 DUP3 078B 01 ADD 078C 51 MLOAD 078D 81 DUP2 078E 55 SSTORE 078F 90 SWAP1 0790 84 DUP5 0791 01 ADD 0792 90 SWAP1 0793 82 DUP3 0794 01 ADD 0795 61 PUSH2 0x0780 0798 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @078E storage[stack[-1]] = memory[stack[-2] + stack[-7]:stack[-2] + stack[-7] + 0x20] // @0792 stack[-2] = stack[-5] + stack[-2] // @0794 stack[-1] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x0780 label_0799: // Incoming jump from 0x0788, if !(stack[-2] < stack[-8]) // Incoming jump from 0x0788, if !(0x00 < stack[-5]) 0799 5B JUMPDEST 079A 50 POP 079B 50 POP 079C 50 POP 079D 61 PUSH2 0x07ab 07A0 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to 0x07ab label_07A1: // Incoming jump from 0x076D, if (stack[-3] < 0x20) == 0x01 // Inputs[5] // { // @07A2 stack[-5] // @07A6 stack[-4] // @07A7 memory[stack[-4]:stack[-4] + 0x20] // @07A9 stack[-3] // @07B1 stack[-6] // } 07A1 5B JUMPDEST 07A2 84 DUP5 07A3 60 PUSH1 0x01 07A5 1B SHL 07A6 84 DUP5 07A7 51 MLOAD 07A8 01 ADD 07A9 83 DUP4 07AA 55 SSTORE 07AB 5B JUMPDEST 07AC 50 POP 07AD 50 POP 07AE 50 POP 07AF 50 POP 07B0 50 POP 07B1 56 *JUMP // Stack delta = -6 // Outputs[1] { @07AA storage[stack[-3]] = memory[stack[-4]:stack[-4] + 0x20] + (stack[-5] << 0x01) } // Block ends with unconditional jump to stack[-6] 07B2 FE *ASSERT 07B3 A2 LOG2 07B4 64 PUSH5 0x6970667358 07BA 22 22 07BB 12 SLT 07BC 20 SHA3 07BD B0 PUSH 07BE B1 DUP 07BF 7D PUSH30 0x7c3e7364608074ea2176b69d32076404618957d5709b57eb25c22b12f964 07DE 73 PUSH20 0x6f6c63430008120033