Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0098 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0098, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @0032 msg.data[0x00:0x20] } 000D 63 PUSH4 0xffffffff 0012 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0030 60 PUSH1 0x00 0032 35 CALLDATALOAD 0033 04 DIV 0034 16 AND 0035 63 PUSH4 0x31d2111c 003A 81 DUP2 003B 14 EQ 003C 61 PUSH2 0x009d 003F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0034 stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff } // Block ends with conditional jump to 0x009d, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x31d2111c label_0040: // Incoming jump from 0x003F, if not msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x31d2111c // Inputs[1] { @0040 stack[-1] } 0040 80 DUP1 0041 63 PUSH4 0x3e27df2a 0046 14 EQ 0047 61 PUSH2 0x00c8 004A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c8, if 0x3e27df2a == stack[-1] label_004B: // Incoming jump from 0x004A, if not 0x3e27df2a == stack[-1] // Inputs[1] { @004B stack[-1] } 004B 80 DUP1 004C 63 PUSH4 0x7fd4b61a 0051 14 EQ 0052 61 PUSH2 0x00ea 0055 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ea, if 0x7fd4b61a == stack[-1] label_0056: // Incoming jump from 0x0055, if not 0x7fd4b61a == stack[-1] // Inputs[1] { @0056 stack[-1] } 0056 80 DUP1 0057 63 PUSH4 0x8d578121 005C 14 EQ 005D 61 PUSH2 0x010a 0060 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x010a, if 0x8d578121 == stack[-1] label_0061: // Incoming jump from 0x0060, if not 0x8d578121 == stack[-1] // Inputs[1] { @0061 stack[-1] } 0061 80 DUP1 0062 63 PUSH4 0x8da5cb5b 0067 14 EQ 0068 61 PUSH2 0x0137 006B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0137, if 0x8da5cb5b == stack[-1] label_006C: // Incoming jump from 0x006B, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @006C stack[-1] } 006C 80 DUP1 006D 63 PUSH4 0x9d9ca28d 0072 14 EQ 0073 61 PUSH2 0x014c 0076 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014c, if 0x9d9ca28d == stack[-1] label_0077: // Incoming jump from 0x0076, if not 0x9d9ca28d == stack[-1] // Inputs[1] { @0077 stack[-1] } 0077 80 DUP1 0078 63 PUSH4 0xc3e85124 007D 14 EQ 007E 61 PUSH2 0x0179 0081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0179, if 0xc3e85124 == stack[-1] label_0082: // Incoming jump from 0x0081, if not 0xc3e85124 == stack[-1] // Inputs[1] { @0082 stack[-1] } 0082 80 DUP1 0083 63 PUSH4 0xd2ec9fe7 0088 14 EQ 0089 61 PUSH2 0x0199 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0199, if 0xd2ec9fe7 == stack[-1] label_008D: // Incoming jump from 0x008C, if not 0xd2ec9fe7 == stack[-1] // Inputs[1] { @008D stack[-1] } 008D 80 DUP1 008E 63 PUSH4 0xd4a55161 0093 14 EQ 0094 61 PUSH2 0x01bb 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01bb, if 0xd4a55161 == stack[-1] label_0098: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0097, if not 0xd4a55161 == stack[-1] // Inputs[1] { @009C memory[0x00:0x00] } 0098 5B JUMPDEST 0099 60 PUSH1 0x00 009B 80 DUP1 009C FD *REVERT // Stack delta = +0 // Outputs[1] { @009C revert(memory[0x00:0x00]); } // Block terminates label_009D: // Incoming jump from 0x003F, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x31d2111c // Inputs[1] { @009E msg.value } 009D 5B JUMPDEST 009E 34 CALLVALUE 009F 80 DUP1 00A0 15 ISZERO 00A1 61 PUSH2 0x00a9 00A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @009E stack[0] = msg.value } // Block ends with conditional jump to 0x00a9, if !msg.value label_00A5: // Incoming jump from 0x00A4, if not !msg.value // Inputs[1] { @00A8 memory[0x00:0x00] } 00A5 60 PUSH1 0x00 00A7 80 DUP1 00A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A8 revert(memory[0x00:0x00]); } // Block terminates label_00A9: // Incoming jump from 0x00A4, if !msg.value 00A9 5B JUMPDEST 00AA 50 POP 00AB 61 PUSH2 0x00b2 00AE 61 PUSH2 0x01e8 00B1 56 *JUMP // Stack delta = +0 // Outputs[1] { @00AB stack[-1] = 0x00b2 } // Block ends with call to 0x01e8, returns to 0x00B2 label_00B2: // Incoming return from call to 0x01E8 at 0x00B1 // Inputs[2] // { // @00B5 memory[0x40:0x60] // @00B9 stack[-1] // } 00B2 5B JUMPDEST 00B3 60 PUSH1 0x40 00B5 51 MLOAD 00B6 61 PUSH2 0x00bf 00B9 91 SWAP2 00BA 90 SWAP1 00BB 61 PUSH2 0x0cf3 00BE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00B9 stack[-1] = 0x00bf // @00BA stack[1] = memory[0x40:0x60] // @00BA stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x0cf3 label_00BF: // Incoming return from call to 0x0C9F at 0x0136 // Inputs[3] // { // @00C2 memory[0x40:0x60] // @00C4 stack[-1] // @00C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00BF 5B JUMPDEST 00C0 60 PUSH1 0x40 00C2 51 MLOAD 00C3 80 DUP1 00C4 91 SWAP2 00C5 03 SUB 00C6 90 SWAP1 00C7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @00C7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00C8: // Incoming jump from 0x004A, if 0x3e27df2a == stack[-1] // Inputs[1] { @00C9 msg.value } 00C8 5B JUMPDEST 00C9 34 CALLVALUE 00CA 80 DUP1 00CB 15 ISZERO 00CC 61 PUSH2 0x00d4 00CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00C9 stack[0] = msg.value } // Block ends with conditional jump to 0x00d4, if !msg.value label_00D0: // Incoming jump from 0x00CF, if not !msg.value // Inputs[1] { @00D3 memory[0x00:0x00] } 00D0 60 PUSH1 0x00 00D2 80 DUP1 00D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D3 revert(memory[0x00:0x00]); } // Block terminates label_00D4: // Incoming jump from 0x00CF, if !msg.value // Inputs[1] { @00DC msg.data.length } 00D4 5B JUMPDEST 00D5 50 POP 00D6 61 PUSH2 0x00e8 00D9 61 PUSH2 0x00e3 00DC 36 CALLDATASIZE 00DD 60 PUSH1 0x04 00DF 61 PUSH2 0x0ab2 00E2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @00D6 stack[-1] = 0x00e8 // @00D9 stack[0] = 0x00e3 // @00DC stack[1] = msg.data.length // @00DD stack[2] = 0x04 // } // Block ends with call to 0x0ab2, returns to 0x00E3 label_00E3: // Incoming return from call to 0x0AB2 at 0x00E2 00E3 5B JUMPDEST 00E4 61 PUSH2 0x02c1 00E7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02c1 label_00E8: // Incoming return from call to 0x0194 at 0x0193 00E8 5B JUMPDEST 00E9 00 *STOP // Stack delta = +0 // Outputs[1] { @00E9 stop(); } // Block terminates label_00EA: // Incoming jump from 0x0055, if 0x7fd4b61a == stack[-1] // Inputs[1] { @00EB msg.value } 00EA 5B JUMPDEST 00EB 34 CALLVALUE 00EC 80 DUP1 00ED 15 ISZERO 00EE 61 PUSH2 0x00f6 00F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00EB stack[0] = msg.value } // Block ends with conditional jump to 0x00f6, if !msg.value label_00F2: // Incoming jump from 0x00F1, if not !msg.value // Inputs[1] { @00F5 memory[0x00:0x00] } 00F2 60 PUSH1 0x00 00F4 80 DUP1 00F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F5 revert(memory[0x00:0x00]); } // Block terminates label_00F6: // Incoming jump from 0x00F1, if !msg.value // Inputs[1] { @00FE msg.data.length } 00F6 5B JUMPDEST 00F7 50 POP 00F8 61 PUSH2 0x00e8 00FB 61 PUSH2 0x0105 00FE 36 CALLDATASIZE 00FF 60 PUSH1 0x04 0101 61 PUSH2 0x0ab2 0104 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @00F8 stack[-1] = 0x00e8 // @00FB stack[0] = 0x0105 // @00FE stack[1] = msg.data.length // @00FF stack[2] = 0x04 // } // Block ends with call to 0x0ab2, returns to 0x0105 label_0105: // Incoming return from call to 0x0AB2 at 0x0104 0105 5B JUMPDEST 0106 61 PUSH2 0x034b 0109 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x034b label_010A: // Incoming jump from 0x0060, if 0x8d578121 == stack[-1] // Inputs[1] { @010B msg.value } 010A 5B JUMPDEST 010B 34 CALLVALUE 010C 80 DUP1 010D 15 ISZERO 010E 61 PUSH2 0x0116 0111 57 *JUMPI // Stack delta = +1 // Outputs[1] { @010B stack[0] = msg.value } // Block ends with conditional jump to 0x0116, if !msg.value label_0112: // Incoming jump from 0x0111, if not !msg.value // Inputs[1] { @0115 memory[0x00:0x00] } 0112 60 PUSH1 0x00 0114 80 DUP1 0115 FD *REVERT // Stack delta = +0 // Outputs[1] { @0115 revert(memory[0x00:0x00]); } // Block terminates label_0116: // Incoming jump from 0x0111, if !msg.value // Inputs[1] { @011E msg.data.length } 0116 5B JUMPDEST 0117 50 POP 0118 61 PUSH2 0x012a 011B 61 PUSH2 0x0125 011E 36 CALLDATASIZE 011F 60 PUSH1 0x04 0121 61 PUSH2 0x0b17 0124 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0118 stack[-1] = 0x012a // @011B stack[0] = 0x0125 // @011E stack[1] = msg.data.length // @011F stack[2] = 0x04 // } // Block ends with call to 0x0b17, returns to 0x0125 label_0125: // Incoming return from call to 0x0B17 at 0x0124 0125 5B JUMPDEST 0126 61 PUSH2 0x065e 0129 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x065e label_012A: // Incoming return from call to 0x0686 at 0x014B // Incoming return from call to 0x0125 at 0x0124 // Inputs[2] // { // @012D memory[0x40:0x60] // @0131 stack[-1] // } 012A 5B JUMPDEST 012B 60 PUSH1 0x40 012D 51 MLOAD 012E 61 PUSH2 0x00bf 0131 91 SWAP2 0132 90 SWAP1 0133 61 PUSH2 0x0c9f 0136 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0131 stack[-1] = 0x00bf // @0132 stack[1] = memory[0x40:0x60] // @0132 stack[0] = stack[-1] // } // Block ends with call to 0x0c9f, returns to 0x00BF label_0137: // Incoming jump from 0x006B, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0138 msg.value } 0137 5B JUMPDEST 0138 34 CALLVALUE 0139 80 DUP1 013A 15 ISZERO 013B 61 PUSH2 0x0143 013E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0138 stack[0] = msg.value } // Block ends with conditional jump to 0x0143, if !msg.value label_013F: // Incoming jump from 0x013E, if not !msg.value // Inputs[1] { @0142 memory[0x00:0x00] } 013F 60 PUSH1 0x00 0141 80 DUP1 0142 FD *REVERT // Stack delta = +0 // Outputs[1] { @0142 revert(memory[0x00:0x00]); } // Block terminates label_0143: // Incoming jump from 0x013E, if !msg.value 0143 5B JUMPDEST 0144 50 POP 0145 61 PUSH2 0x012a 0148 61 PUSH2 0x0686 014B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0145 stack[-1] = 0x012a } // Block ends with call to 0x0686, returns to 0x012A label_014C: // Incoming jump from 0x0076, if 0x9d9ca28d == stack[-1] // Inputs[1] { @014D msg.value } 014C 5B JUMPDEST 014D 34 CALLVALUE 014E 80 DUP1 014F 15 ISZERO 0150 61 PUSH2 0x0158 0153 57 *JUMPI // Stack delta = +1 // Outputs[1] { @014D stack[0] = msg.value } // Block ends with conditional jump to 0x0158, if !msg.value label_0154: // Incoming jump from 0x0153, if not !msg.value // Inputs[1] { @0157 memory[0x00:0x00] } 0154 60 PUSH1 0x00 0156 80 DUP1 0157 FD *REVERT // Stack delta = +0 // Outputs[1] { @0157 revert(memory[0x00:0x00]); } // Block terminates label_0158: // Incoming jump from 0x0153, if !msg.value // Inputs[1] { @0160 msg.data.length } 0158 5B JUMPDEST 0159 50 POP 015A 61 PUSH2 0x016c 015D 61 PUSH2 0x0167 0160 36 CALLDATASIZE 0161 60 PUSH1 0x04 0163 61 PUSH2 0x0a8c 0166 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @015A stack[-1] = 0x016c // @015D stack[0] = 0x0167 // @0160 stack[1] = msg.data.length // @0161 stack[2] = 0x04 // } // Block ends with call to 0x0a8c, returns to 0x0167 label_0167: // Incoming return from call to 0x0A8C at 0x0166 0167 5B JUMPDEST 0168 61 PUSH2 0x0695 016B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0695 label_016C: // Incoming return from call to 0x0167 at 0x0166 // Inputs[2] // { // @016F memory[0x40:0x60] // @0173 stack[-1] // } 016C 5B JUMPDEST 016D 60 PUSH1 0x40 016F 51 MLOAD 0170 61 PUSH2 0x00bf 0173 91 SWAP2 0174 90 SWAP1 0175 61 PUSH2 0x0d04 0178 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0173 stack[-1] = 0x00bf // @0174 stack[1] = memory[0x40:0x60] // @0174 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x0d04 label_0179: // Incoming jump from 0x0081, if 0xc3e85124 == stack[-1] // Inputs[1] { @017A msg.value } 0179 5B JUMPDEST 017A 34 CALLVALUE 017B 80 DUP1 017C 15 ISZERO 017D 61 PUSH2 0x0185 0180 57 *JUMPI // Stack delta = +1 // Outputs[1] { @017A stack[0] = msg.value } // Block ends with conditional jump to 0x0185, if !msg.value label_0181: // Incoming jump from 0x0180, if not !msg.value // Inputs[1] { @0184 memory[0x00:0x00] } 0181 60 PUSH1 0x00 0183 80 DUP1 0184 FD *REVERT // Stack delta = +0 // Outputs[1] { @0184 revert(memory[0x00:0x00]); } // Block terminates label_0185: // Incoming jump from 0x0180, if !msg.value // Inputs[1] { @018D msg.data.length } 0185 5B JUMPDEST 0186 50 POP 0187 61 PUSH2 0x00e8 018A 61 PUSH2 0x0194 018D 36 CALLDATASIZE 018E 60 PUSH1 0x04 0190 61 PUSH2 0x0a8c 0193 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0187 stack[-1] = 0x00e8 // @018A stack[0] = 0x0194 // @018D stack[1] = msg.data.length // @018E stack[2] = 0x04 // } // Block ends with call to 0x0a8c, returns to 0x0194 label_0194: // Incoming return from call to 0x0A8C at 0x0193 0194 5B JUMPDEST 0195 61 PUSH2 0x06b3 0198 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06b3 label_0199: // Incoming jump from 0x008C, if 0xd2ec9fe7 == stack[-1] // Inputs[1] { @019A msg.value } 0199 5B JUMPDEST 019A 34 CALLVALUE 019B 80 DUP1 019C 15 ISZERO 019D 61 PUSH2 0x01a5 01A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @019A stack[0] = msg.value } // Block ends with conditional jump to 0x01a5, if !msg.value label_01A1: // Incoming jump from 0x01A0, if not !msg.value // Inputs[1] { @01A4 memory[0x00:0x00] } 01A1 60 PUSH1 0x00 01A3 80 DUP1 01A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A4 revert(memory[0x00:0x00]); } // Block terminates label_01A5: // Incoming jump from 0x01A0, if !msg.value 01A5 5B JUMPDEST 01A6 50 POP 01A7 61 PUSH2 0x01ae 01AA 61 PUSH2 0x06f9 01AD 56 *JUMP // Stack delta = +0 // Outputs[1] { @01A7 stack[-1] = 0x01ae } // Block ends with call to 0x06f9, returns to 0x01AE label_01AE: // Incoming return from call to 0x06F9 at 0x01AD // Inputs[2] // { // @01B1 memory[0x40:0x60] // @01B5 stack[-1] // } 01AE 5B JUMPDEST 01AF 60 PUSH1 0x40 01B1 51 MLOAD 01B2 61 PUSH2 0x00bf 01B5 91 SWAP2 01B6 90 SWAP1 01B7 61 PUSH2 0x0ce2 01BA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01B5 stack[-1] = 0x00bf // @01B6 stack[1] = memory[0x40:0x60] // @01B6 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x0ce2 label_01BB: // Incoming jump from 0x0097, if 0xd4a55161 == stack[-1] // Inputs[1] { @01BC msg.value } 01BB 5B JUMPDEST 01BC 34 CALLVALUE 01BD 80 DUP1 01BE 15 ISZERO 01BF 61 PUSH2 0x01c7 01C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01BC stack[0] = msg.value } // Block ends with conditional jump to 0x01c7, if !msg.value label_01C3: // Incoming jump from 0x01C2, if not !msg.value // Inputs[1] { @01C6 memory[0x00:0x00] } 01C3 60 PUSH1 0x00 01C5 80 DUP1 01C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C6 revert(memory[0x00:0x00]); } // Block terminates label_01C7: // Incoming jump from 0x01C2, if !msg.value // Inputs[1] { @01CF msg.data.length } 01C7 5B JUMPDEST 01C8 50 POP 01C9 61 PUSH2 0x01db 01CC 61 PUSH2 0x01d6 01CF 36 CALLDATASIZE 01D0 60 PUSH1 0x04 01D2 61 PUSH2 0x0b17 01D5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01C9 stack[-1] = 0x01db // @01CC stack[0] = 0x01d6 // @01CF stack[1] = msg.data.length // @01D0 stack[2] = 0x04 // } // Block ends with call to 0x0b17, returns to 0x01D6 label_01D6: // Incoming return from call to 0x0B17 at 0x01D5 01D6 5B JUMPDEST 01D7 61 PUSH2 0x075b 01DA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x075b label_01DB: // Incoming return from call to 0x01D6 at 0x01D5 // Inputs[2] // { // @01DE memory[0x40:0x60] // @01E2 stack[-1] // } 01DB 5B JUMPDEST 01DC 60 PUSH1 0x40 01DE 51 MLOAD 01DF 61 PUSH2 0x00bf 01E2 91 SWAP2 01E3 90 SWAP1 01E4 61 PUSH2 0x0d12 01E7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01E2 stack[-1] = 0x00bf // @01E3 stack[1] = memory[0x40:0x60] // @01E3 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x0d12 label_01E8: // Incoming call from 0x00B1, returns to 0x00B2 // Inputs[2] // { // @01EE storage[0x06] // @01F8 memory[0x40:0x60] // } 01E8 5B JUMPDEST 01E9 60 PUSH1 0x60 01EB 60 PUSH1 0x06 01ED 80 DUP1 01EE 54 SLOAD 01EF 80 DUP1 01F0 60 PUSH1 0x20 01F2 02 MUL 01F3 60 PUSH1 0x20 01F5 01 ADD 01F6 60 PUSH1 0x40 01F8 51 MLOAD 01F9 90 SWAP1 01FA 81 DUP2 01FB 01 ADD 01FC 60 PUSH1 0x40 01FE 52 MSTORE 01FF 80 DUP1 0200 92 SWAP3 0201 91 SWAP2 0202 90 SWAP1 0203 81 DUP2 0204 81 DUP2 0205 52 MSTORE 0206 60 PUSH1 0x20 0208 01 ADD 0209 60 PUSH1 0x00 020B 90 SWAP1 020C 5B JUMPDEST 020D 82 DUP3 020E 82 DUP3 020F 10 LT 0210 15 ISZERO 0211 61 PUSH2 0x02b7 0214 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @01E9 stack[0] = 0x60 // @01FE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x06] // @0200 stack[1] = memory[0x40:0x60] // @0201 stack[2] = 0x06 // @0202 stack[3] = storage[0x06] // @0205 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x06] // @020B stack[4] = 0x00 // @020B stack[5] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x02b7, if !(0x00 < storage[0x06]) label_0215: // Incoming jump from 0x0214, if not !(0x00 < storage[0x06]) // Incoming jump from 0x0214, if not !(stack[-2] < stack[-3]) // Inputs[5] // { // @0217 stack[-4] // @021F memory[0x00:0x20] // @0220 stack[-2] // @0223 storage[stack[-2] + keccak256(memory[0x00:0x20])] // @0227 memory[0x40:0x60] // } 0215 60 PUSH1 0x00 0217 84 DUP5 0218 81 DUP2 0219 52 MSTORE 021A 60 PUSH1 0x20 021C 90 SWAP1 021D 81 DUP2 021E 90 SWAP1 021F 20 SHA3 0220 83 DUP4 0221 01 ADD 0222 80 DUP1 0223 54 SLOAD 0224 60 PUSH1 0x40 0226 80 DUP1 0227 51 MLOAD 0228 60 PUSH1 0x1f 022A 60 PUSH1 0x02 022C 60 PUSH1 0x00 022E 19 NOT 022F 61 PUSH2 0x0100 0232 60 PUSH1 0x01 0234 87 DUP8 0235 16 AND 0236 15 ISZERO 0237 02 MUL 0238 01 ADD 0239 90 SWAP1 023A 94 SWAP5 023B 16 AND 023C 93 SWAP4 023D 90 SWAP1 023E 93 SWAP4 023F 04 DIV 0240 92 SWAP3 0241 83 DUP4 0242 01 ADD 0243 85 DUP6 0244 90 SWAP1 0245 04 DIV 0246 85 DUP6 0247 02 MUL 0248 81 DUP2 0249 01 ADD 024A 85 DUP6 024B 01 ADD 024C 90 SWAP1 024D 91 SWAP2 024E 52 MSTORE 024F 81 DUP2 0250 81 DUP2 0251 52 MSTORE 0252 92 SWAP3 0253 83 DUP4 0254 01 ADD 0255 82 DUP3 0256 82 DUP3 0257 80 DUP1 0258 15 ISZERO 0259 61 PUSH2 0x02a3 025C 57 *JUMPI // Stack delta = +6 // Outputs[9] // { // @0219 memory[0x00:0x20] = stack[-4] // @0221 stack[1] = stack[-2] + keccak256(memory[0x00:0x20]) // @0240 stack[2] = (storage[stack[-2] + keccak256(memory[0x00:0x20])] & !(storage[stack[-2] + keccak256(memory[0x00:0x20])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @024E memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[stack[-2] + keccak256(memory[0x00:0x20])] & !(storage[stack[-2] + keccak256(memory[0x00:0x20])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0251 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[stack[-2] + keccak256(memory[0x00:0x20])] & !(storage[stack[-2] + keccak256(memory[0x00:0x20])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0252 stack[0] = memory[0x40:0x60] // @0254 stack[3] = memory[0x40:0x60] + 0x20 // @0255 stack[4] = stack[-2] + keccak256(memory[0x00:0x20]) // @0256 stack[5] = (storage[stack[-2] + keccak256(memory[0x00:0x20])] & !(storage[stack[-2] + keccak256(memory[0x00:0x20])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x02a3, if !((storage[stack[-2] + keccak256(memory[0x00:0x20])] & !(storage[stack[-2] + keccak256(memory[0x00:0x20])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_025D: // Incoming jump from 0x025C, if not !((storage[stack[-2] + keccak256(memory[0x00:0x20])] & !(storage[stack[-2] + keccak256(memory[0x00:0x20])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @025D stack[-1] } 025D 80 DUP1 025E 60 PUSH1 0x1f 0260 10 LT 0261 61 PUSH2 0x0278 0264 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0278, if 0x1f < stack[-1] label_0265: // Incoming jump from 0x0264, if not 0x1f < stack[-1] // Inputs[4] // { // @0269 stack[-2] // @026A storage[stack[-2]] // @026D stack[-3] // @026F stack[-1] // } 0265 61 PUSH2 0x0100 0268 80 DUP1 0269 83 DUP4 026A 54 SLOAD 026B 04 DIV 026C 02 MUL 026D 83 DUP4 026E 52 MSTORE 026F 91 SWAP2 0270 60 PUSH1 0x20 0272 01 ADD 0273 91 SWAP2 0274 61 PUSH2 0x02a3 0277 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @026E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0273 stack[-1] = stack[-1] // @0273 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x02a3 label_0278: // Incoming jump from 0x0264, if 0x1f < stack[-1] // Inputs[5] // { // @0279 stack[-3] // @027A stack[-1] // @027C stack[-2] // @0284 memory[0x00:0x20] // @0288 storage[keccak256(memory[0x00:0x20])] // } 0278 5B JUMPDEST 0279 82 DUP3 027A 01 ADD 027B 91 SWAP2 027C 90 SWAP1 027D 60 PUSH1 0x00 027F 52 MSTORE 0280 60 PUSH1 0x20 0282 60 PUSH1 0x00 0284 20 SHA3 0285 90 SWAP1 0286 5B JUMPDEST 0287 81 DUP2 0288 54 SLOAD 0289 81 DUP2 028A 52 MSTORE 028B 90 SWAP1 028C 60 PUSH1 0x01 028E 01 ADD 028F 90 SWAP1 0290 60 PUSH1 0x20 0292 01 ADD 0293 80 DUP1 0294 83 DUP4 0295 11 GT 0296 61 PUSH2 0x0286 0299 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @027B stack[-3] = stack[-3] + stack[-1] // @027F memory[0x00:0x20] = stack[-2] // @028A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @028F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0292 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0286, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_029A: // Incoming jump from 0x0299, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0299, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @029A stack[-3] // @029B stack[-1] // } 029A 82 DUP3 029B 90 SWAP1 029C 03 SUB 029D 60 PUSH1 0x1f 029F 16 AND 02A0 82 DUP3 02A1 01 ADD 02A2 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @02A2 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @02A2 stack[-1] = stack[-3] // } // Block continues label_02A3: // Incoming jump from 0x02A2 // Incoming jump from 0x025C, if !((storage[stack[-2] + keccak256(memory[0x00:0x20])] & !(storage[stack[-2] + keccak256(memory[0x00:0x20])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0277 // Inputs[3] // { // @02A9 stack[-7] // @02AA stack[-6] // @02AE stack[-8] // } 02A3 5B JUMPDEST 02A4 50 POP 02A5 50 POP 02A6 50 POP 02A7 50 POP 02A8 50 POP 02A9 81 DUP2 02AA 52 MSTORE 02AB 60 PUSH1 0x20 02AD 01 ADD 02AE 90 SWAP1 02AF 60 PUSH1 0x01 02B1 01 ADD 02B2 90 SWAP1 02B3 61 PUSH2 0x020c 02B6 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @02AA memory[stack[-7]:stack[-7] + 0x20] = stack[-6] // @02B2 stack[-7] = 0x20 + stack[-7] // @02B2 stack[-8] = 0x01 + stack[-8] // } // Block ends with unconditional jump to 0x020c label_02B7: // Incoming jump from 0x0214, if !(0x00 < storage[0x06]) // Incoming jump from 0x0214, if !(stack[-2] < stack[-3]) // Inputs[3] // { // @02BC stack[-6] // @02BC stack[-5] // @02BF stack[-7] // } 02B7 5B JUMPDEST 02B8 50 POP 02B9 50 POP 02BA 50 POP 02BB 50 POP 02BC 90 SWAP1 02BD 50 POP 02BE 5B JUMPDEST 02BF 90 SWAP1 02C0 56 *JUMP // Stack delta = -6 // Outputs[1] { @02BF stack[-7] = stack[-5] } // Block ends with unconditional jump to stack[-7] label_02C1: // Incoming jump from 0x00E7 // Inputs[2] // { // @02C4 storage[0x00] // @02CE msg.sender // } 02C1 5B JUMPDEST 02C2 60 PUSH1 0x00 02C4 54 SLOAD 02C5 60 PUSH1 0x01 02C7 60 PUSH1 0xa0 02C9 60 PUSH1 0x02 02CB 0A EXP 02CC 03 SUB 02CD 16 AND 02CE 33 CALLER 02CF 14 EQ 02D0 61 PUSH2 0x02d8 02D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d8, if msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x00] label_02D4: // Incoming jump from 0x02D3, if not msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x00] // Inputs[1] { @02D7 memory[0x00:0x00] } 02D4 60 PUSH1 0x00 02D6 80 DUP1 02D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D7 revert(memory[0x00:0x00]); } // Block terminates label_02D8: // Incoming jump from 0x02D3, if msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x00] // Inputs[8] // { // @02DC memory[0x40:0x60] // @02E3 stack[-2] // @02EB stack[-1] // @02FE stack[-3] // @030C memory[0x00:0x40] // @030E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0312 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0314 memory[memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]:memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] + 0x20] // } 02D8 5B JUMPDEST 02D9 60 PUSH1 0x40 02DB 80 DUP1 02DC 51 MLOAD 02DD 60 PUSH1 0x60 02DF 81 DUP2 02E0 01 ADD 02E1 82 DUP3 02E2 52 MSTORE 02E3 83 DUP4 02E4 81 DUP2 02E5 52 MSTORE 02E6 60 PUSH1 0x20 02E8 80 DUP1 02E9 82 DUP3 02EA 01 ADD 02EB 84 DUP5 02EC 81 DUP2 02ED 52 MSTORE 02EE 60 PUSH1 0x01 02F0 83 DUP4 02F1 85 DUP6 02F2 01 ADD 02F3 81 DUP2 02F4 90 SWAP1 02F5 52 MSTORE 02F6 60 PUSH1 0x01 02F8 60 PUSH1 0xa0 02FA 60 PUSH1 0x02 02FC 0A EXP 02FD 03 SUB 02FE 88 DUP9 02FF 16 AND 0300 60 PUSH1 0x00 0302 90 SWAP1 0303 81 DUP2 0304 52 MSTORE 0305 60 PUSH1 0x07 0307 84 DUP5 0308 52 MSTORE 0309 94 SWAP5 030A 90 SWAP1 030B 94 SWAP5 030C 20 SHA3 030D 83 DUP4 030E 51 MLOAD 030F 81 DUP2 0310 55 SSTORE 0311 90 SWAP1 0312 51 MLOAD 0313 80 DUP1 0314 51 MLOAD 0315 93 SWAP4 0316 94 SWAP5 0317 91 SWAP2 0318 93 SWAP4 0319 61 PUSH2 0x032a 031C 93 SWAP4 031D 92 SWAP3 031E 85 DUP6 031F 01 ADD 0320 92 SWAP3 0321 91 SWAP2 0322 90 SWAP1 0323 91 SWAP2 0324 01 ADD 0325 90 SWAP1 0326 61 PUSH2 0x0981 0329 56 *JUMP // Stack delta = +6 // Outputs[13] // { // @02E2 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @02E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @02ED memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @02F5 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = 0x01 // @0304 memory[0x00:0x20] = stack[-3] & 0x02 ** 0xa0 - 0x01 // @0308 memory[0x20:0x40] = 0x07 // @0310 storage[keccak256(memory[0x00:0x40])] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0316 stack[0] = memory[0x40:0x60] // @0318 stack[1] = keccak256(memory[0x00:0x40]) // @031C stack[2] = 0x032a // @0320 stack[3] = keccak256(memory[0x00:0x40]) + 0x01 // @0325 stack[4] = 0x20 + memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0325 stack[5] = memory[memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]:memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] + 0x20] // } // Block ends with unconditional jump to 0x0981 032A 5B JUMPDEST 032B 50 POP 032C 60 PUSH1 0x40 032E 91 SWAP2 032F 90 SWAP1 0330 91 SWAP2 0331 01 ADD 0332 51 MLOAD 0333 60 PUSH1 0x02 0335 90 SWAP1 0336 91 SWAP2 0337 01 ADD 0338 80 DUP1 0339 54 SLOAD 033A 60 PUSH1 0xff 033C 19 NOT 033D 16 AND 033E 91 SWAP2 033F 15 ISZERO 0340 15 ISZERO 0341 91 SWAP2 0342 90 SWAP1 0343 91 SWAP2 0344 17 OR 0345 90 SWAP1 0346 55 SSTORE 0347 50 POP 0348 50 POP 0349 50 POP 034A 56 *JUMP label_034B: // Incoming jump from 0x0109 // Inputs[2] // { // @034E storage[0x03] // @0362 msg.sender // } 034B 5B JUMPDEST 034C 60 PUSH1 0x03 034E 54 SLOAD 034F 60 PUSH1 0x60 0351 90 SWAP1 0352 60 PUSH1 0x00 0354 90 SWAP1 0355 81 DUP2 0356 90 SWAP1 0357 83 DUP4 0358 90 SWAP1 0359 60 PUSH1 0x01 035B 60 PUSH1 0xa0 035D 60 PUSH1 0x02 035F 0A EXP 0360 03 SUB 0361 16 AND 0362 33 CALLER 0363 14 EQ 0364 61 PUSH2 0x036c 0367 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0351 stack[0] = 0x60 // @0354 stack[1] = 0x00 // @0356 stack[2] = 0x00 // @0358 stack[3] = 0x60 // } // Block ends with conditional jump to 0x036c, if msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x03] label_0368: // Incoming jump from 0x0367, if not msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x03] // Inputs[1] { @036B memory[0x00:0x00] } 0368 60 PUSH1 0x00 036A 80 DUP1 036B FD *REVERT // Stack delta = +0 // Outputs[1] { @036B revert(memory[0x00:0x00]); } // Block terminates label_036C: // Incoming jump from 0x0367, if msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x03] // Inputs[2] // { // @036F stack[-5] // @0370 memory[stack[-5]:stack[-5] + 0x20] // } 036C 5B JUMPDEST 036D 60 PUSH1 0x40 036F 85 DUP6 0370 51 MLOAD 0371 10 LT 0372 15 ISZERO 0373 61 PUSH2 0x03b1 0376 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b1, if !(memory[stack[-5]:stack[-5] + 0x20] < 0x40) label_0377: // Incoming jump from 0x0376, if not !(memory[stack[-5]:stack[-5] + 0x20] < 0x40) // Inputs[1] { @0379 memory[0x40:0x60] } 0377 60 PUSH1 0x40 0379 51 MLOAD 037A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 039B 81 DUP2 039C 52 MSTORE 039D 60 PUSH1 0x04 039F 01 ADD 03A0 61 PUSH2 0x03a8 03A3 90 SWAP1 03A4 61 PUSH2 0x0d23 03A7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @039C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @03A3 stack[0] = 0x03a8 // @03A3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0d23 03A8 5B JUMPDEST 03A9 60 PUSH1 0x40 03AB 51 MLOAD 03AC 80 DUP1 03AD 91 SWAP2 03AE 03 SUB 03AF 90 SWAP1 03B0 FD *REVERT label_03B1: // Incoming jump from 0x0376, if !(memory[stack[-5]:stack[-5] + 0x20] < 0x40) // Inputs[2] // { // @03B2 stack[-5] // @03B3 memory[stack[-5]:stack[-5] + 0x20] // } 03B1 5B JUMPDEST 03B2 84 DUP5 03B3 51 MLOAD 03B4 60 PUSH1 0x40 03B6 11 GT 03B7 15 ISZERO 03B8 61 PUSH2 0x03c0 03BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c0, if !(0x40 > memory[stack[-5]:stack[-5] + 0x20]) label_03BC: // Incoming jump from 0x03BB, if not !(0x40 > memory[stack[-5]:stack[-5] + 0x20]) // Inputs[1] { @03BF memory[0x00:0x00] } 03BC 60 PUSH1 0x00 03BE 80 DUP1 03BF FD *REVERT // Stack delta = +0 // Outputs[1] { @03BF revert(memory[0x00:0x00]); } // Block terminates label_03C0: // Incoming jump from 0x03BB, if !(0x40 > memory[stack[-5]:stack[-5] + 0x20]) // Inputs[1] { @03C4 stack[-5] } 03C0 5B JUMPDEST 03C1 61 PUSH2 0x03cd 03C4 85 DUP6 03C5 60 PUSH1 0x20 03C7 60 PUSH1 0x40 03C9 61 PUSH2 0x0802 03CC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C1 stack[0] = 0x03cd // @03C4 stack[1] = stack[-5] // @03C5 stack[2] = 0x20 // @03C7 stack[3] = 0x40 // } // Block ends with call to 0x0802, returns to 0x03CD label_03CD: // Incoming return from call to 0x0802 at 0x03CC // Inputs[7] // { // @03D0 storage[0x01] // @03D1 stack[-1] // @03D2 stack[-5] // @03DC stack[-8] // @03DF stack[-4] // @03E3 stack[-3] // @03E7 memory[stack[-1]:stack[-1] + 0x20] // } 03CD 5B JUMPDEST 03CE 60 PUSH1 0x01 03D0 54 SLOAD 03D1 90 SWAP1 03D2 94 SWAP5 03D3 50 POP 03D4 60 PUSH1 0x01 03D6 60 PUSH1 0xa0 03D8 60 PUSH1 0x02 03DA 0A EXP 03DB 03 SUB 03DC 88 DUP9 03DD 16 AND 03DE 18 XOR 03DF 92 SWAP3 03E0 50 POP 03E1 60 PUSH1 0x00 03E3 91 SWAP2 03E4 50 POP 03E5 5B JUMPDEST 03E6 83 DUP4 03E7 51 MLOAD 03E8 82 DUP3 03E9 63 PUSH4 0xffffffff 03EE 16 AND 03EF 10 LT 03F0 15 ISZERO 03F1 61 PUSH2 0x0475 03F4 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @03D2 stack[-5] = stack[-1] // @03DF stack[-4] = (stack[-8] & 0x02 ** 0xa0 - 0x01) ~ storage[0x01] // @03E3 stack[-3] = 0x00 // } // Block ends with conditional jump to 0x0475, if !(0xffffffff & 0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_03F5: // Incoming jump from 0x03F4, if not !(0xffffffff & 0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x03F4, if not !(0xffffffff & stack[-2] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[2] // { // @03F5 stack[-3] // @03F8 stack[-2] // } 03F5 82 DUP3 03F6 60 PUSH1 0x1f 03F8 83 DUP4 03F9 16 AND 03FA 60 PUSH1 0x20 03FC 81 DUP2 03FD 10 LT 03FE 61 PUSH2 0x0403 0401 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @03F5 stack[0] = stack[-3] // @03F9 stack[1] = stack[-2] & 0x1f // } // Block ends with conditional jump to 0x0403, if stack[-2] & 0x1f < 0x20 label_0402: // Incoming jump from 0x0401, if not stack[-2] & 0x1f < 0x20 0402 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0402 assert(); } // Block terminates label_0403: // Incoming jump from 0x0401, if stack[-2] & 0x1f < 0x20 // Inputs[5] // { // @0404 stack[-1] // @0404 stack[-2] // @0414 stack[-6] // @0415 stack[-4] // @041D memory[stack[-6]:stack[-6] + 0x20] // } 0403 5B JUMPDEST 0404 1A BYTE 0405 60 PUSH1 0xf8 0407 60 PUSH1 0x02 0409 0A EXP 040A 02 MUL 040B 60 PUSH1 0x42 040D 60 PUSH1 0xf8 040F 60 PUSH1 0x02 0411 0A EXP 0412 02 MUL 0413 18 XOR 0414 84 DUP5 0415 83 DUP4 0416 63 PUSH4 0xffffffff 041B 16 AND 041C 81 DUP2 041D 51 MLOAD 041E 81 DUP2 041F 10 LT 0420 15 ISZERO 0421 15 ISZERO 0422 61 PUSH2 0x0427 0425 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0413 stack[-2] = 0x02 ** 0xf8 * 0x42 ~ 0x02 ** 0xf8 * byte(stack[-2], stack[-1]) // @0414 stack[-1] = stack[-6] // @041B stack[0] = 0xffffffff & stack[-4] // } // Block ends with conditional jump to 0x0427, if !!(0xffffffff & stack[-4] < memory[stack[-6]:stack[-6] + 0x20]) label_0426: // Incoming jump from 0x0425, if not !!(0xffffffff & stack[-4] < memory[stack[-6]:stack[-6] + 0x20]) 0426 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0426 assert(); } // Block terminates label_0427: // Incoming jump from 0x0425, if !!(0xffffffff & stack[-4] < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[6] // { // @0428 stack[-2] // @0428 stack[-1] // @042D stack[-3] // @042F memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @046D stack[-4] // @046E stack[-5] // } 0427 5B JUMPDEST 0428 90 SWAP1 0429 60 PUSH1 0x20 042B 01 ADD 042C 01 ADD 042D 81 DUP2 042E 81 DUP2 042F 51 MLOAD 0430 60 PUSH1 0xf8 0432 60 PUSH1 0x02 0434 0A EXP 0435 90 SWAP1 0436 04 DIV 0437 60 PUSH1 0xf8 0439 60 PUSH1 0x02 043B 0A EXP 043C 02 MUL 043D 18 XOR 043E 91 SWAP2 043F 50 POP 0440 90 SWAP1 0441 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0461 19 NOT 0462 16 AND 0463 90 SWAP1 0464 81 DUP2 0465 60 PUSH1 0x00 0467 1A BYTE 0468 90 SWAP1 0469 53 MSTORE8 046A 50 POP 046B 60 PUSH1 0x01 046D 90 SWAP1 046E 91 SWAP2 046F 01 ADD 0470 90 SWAP1 0471 61 PUSH2 0x03e5 0474 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0469 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x02 ** 0xf8 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x02 ** 0xf8) ~ stack[-3]), 0x00) // @0470 stack[-4] = stack[-4] // @0470 stack[-5] = stack[-5] + 0x01 // } // Block ends with unconditional jump to 0x03e5 label_0475: // Incoming jump from 0x03F4, if !(0xffffffff & 0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x03F4, if !(0xffffffff & stack[-2] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @0479 storage[0x02] // @047D memory[0x40:0x60] // @04AA stack[-4] // } 0475 5B JUMPDEST 0476 60 PUSH1 0x02 0478 80 DUP1 0479 54 SLOAD 047A 60 PUSH1 0x40 047C 80 DUP1 047D 51 MLOAD 047E 60 PUSH1 0x20 0480 60 PUSH1 0x01 0482 84 DUP5 0483 16 AND 0484 15 ISZERO 0485 61 PUSH2 0x0100 0488 02 MUL 0489 60 PUSH1 0x00 048B 19 NOT 048C 01 ADD 048D 90 SWAP1 048E 93 SWAP4 048F 16 AND 0490 84 DUP5 0491 90 SWAP1 0492 04 DIV 0493 60 PUSH1 0x1f 0495 81 DUP2 0496 01 ADD 0497 84 DUP5 0498 90 SWAP1 0499 04 DIV 049A 84 DUP5 049B 02 MUL 049C 82 DUP3 049D 01 ADD 049E 84 DUP5 049F 01 ADD 04A0 90 SWAP1 04A1 92 SWAP3 04A2 52 MSTORE 04A3 81 DUP2 04A4 81 DUP2 04A5 52 MSTORE 04A6 61 PUSH2 0x050a 04A9 93 SWAP4 04AA 88 DUP9 04AB 93 SWAP4 04AC 91 SWAP2 04AD 92 SWAP3 04AE 90 SWAP1 04AF 91 SWAP2 04B0 83 DUP4 04B1 01 ADD 04B2 82 DUP3 04B3 82 DUP3 04B4 80 DUP1 04B5 15 ISZERO 04B6 61 PUSH2 0x0500 04B9 57 *JUMPI // Stack delta = +8 // Outputs[10] // { // @04A2 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 + 0x1f) / 0x20) // @04A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 // @04A9 stack[0] = 0x050a // @04AB stack[1] = stack[-4] // @04AD stack[2] = memory[0x40:0x60] // @04AE stack[4] = (storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 // @04AF stack[3] = 0x02 // @04B1 stack[5] = memory[0x40:0x60] + 0x20 // @04B2 stack[6] = 0x02 // @04B3 stack[7] = (storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x0500, if !((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02) label_04BA: // Incoming call from 0x04B9, returns to 0x050A, if not !((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02) // Inputs[1] { @04BA stack[-1] } 04BA 80 DUP1 04BB 60 PUSH1 0x1f 04BD 10 LT 04BE 61 PUSH2 0x04d5 04C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d5, if 0x1f < stack[-1] label_04C2: // Incoming jump from 0x04C1, if not 0x1f < stack[-1] // Inputs[4] // { // @04C6 stack[-2] // @04C7 storage[stack[-2]] // @04CA stack[-3] // @04CC stack[-1] // } 04C2 61 PUSH2 0x0100 04C5 80 DUP1 04C6 83 DUP4 04C7 54 SLOAD 04C8 04 DIV 04C9 02 MUL 04CA 83 DUP4 04CB 52 MSTORE 04CC 91 SWAP2 04CD 60 PUSH1 0x20 04CF 01 ADD 04D0 91 SWAP2 04D1 61 PUSH2 0x0500 04D4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04CB memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04D0 stack[-1] = stack[-1] // @04D0 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0500 label_04D5: // Incoming jump from 0x04C1, if 0x1f < stack[-1] // Inputs[5] // { // @04D6 stack[-3] // @04D7 stack[-1] // @04D9 stack[-2] // @04E1 memory[0x00:0x20] // @04E5 storage[keccak256(memory[0x00:0x20])] // } 04D5 5B JUMPDEST 04D6 82 DUP3 04D7 01 ADD 04D8 91 SWAP2 04D9 90 SWAP1 04DA 60 PUSH1 0x00 04DC 52 MSTORE 04DD 60 PUSH1 0x20 04DF 60 PUSH1 0x00 04E1 20 SHA3 04E2 90 SWAP1 04E3 5B JUMPDEST 04E4 81 DUP2 04E5 54 SLOAD 04E6 81 DUP2 04E7 52 MSTORE 04E8 90 SWAP1 04E9 60 PUSH1 0x01 04EB 01 ADD 04EC 90 SWAP1 04ED 60 PUSH1 0x20 04EF 01 ADD 04F0 80 DUP1 04F1 83 DUP4 04F2 11 GT 04F3 61 PUSH2 0x04e3 04F6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04D8 stack[-3] = stack[-3] + stack[-1] // @04DC memory[0x00:0x20] = stack[-2] // @04E7 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04EC stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04EF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04e3, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04F7: // Incoming jump from 0x04F6, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04F6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04F7 stack[-3] // @04F8 stack[-1] // } 04F7 82 DUP3 04F8 90 SWAP1 04F9 03 SUB 04FA 60 PUSH1 0x1f 04FC 16 AND 04FD 82 DUP3 04FE 01 ADD 04FF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04FF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04FF stack[-1] = stack[-3] // } // Block continues label_0500: // Incoming jump from 0x04FF // Incoming jump from 0x04D4 // Incoming jump from 0x04B9, if !((storage[0x02] & ~0x00 + 0x0100 * !(storage[0x02] & 0x01)) / 0x02) 0500 5B JUMPDEST 0501 50 POP 0502 50 POP 0503 50 POP 0504 50 POP 0505 50 POP 0506 61 PUSH2 0x08b8 0509 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x08b8 label_050A: // Incoming return from call to 0x04BA at 0x04B9 // Inputs[1] { @050B stack[-1] } 050A 5B JUMPDEST 050B 15 ISZERO 050C 61 PUSH2 0x0623 050F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0623, if !stack[-1] label_0510: // Incoming jump from 0x050F, if not !stack[-1] // Inputs[4] // { // @0518 stack[-7] // @0529 memory[0x00:0x40] // @052B storage[keccak256(memory[0x00:0x40])] // @0539 stack[-5] // } 0510 60 PUSH1 0x01 0512 60 PUSH1 0xa0 0514 60 PUSH1 0x02 0516 0A EXP 0517 03 SUB 0518 87 DUP8 0519 16 AND 051A 60 PUSH1 0x00 051C 90 SWAP1 051D 81 DUP2 051E 52 MSTORE 051F 60 PUSH1 0x04 0521 60 PUSH1 0x20 0523 90 SWAP1 0524 81 DUP2 0525 52 MSTORE 0526 60 PUSH1 0x40 0528 82 DUP3 0529 20 SHA3 052A 80 DUP1 052B 54 SLOAD 052C 60 PUSH1 0xff 052E 19 NOT 052F 16 AND 0530 60 PUSH1 0x01 0532 17 OR 0533 90 SWAP1 0534 55 SSTORE 0535 61 PUSH2 0x053f 0538 91 SWAP2 0539 87 DUP8 053A 91 SWAP2 053B 61 PUSH2 0x0802 053E 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @051E memory[0x00:0x20] = stack[-7] & 0x02 ** 0xa0 - 0x01 // @0525 memory[0x20:0x40] = 0x04 // @0534 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0538 stack[2] = 0x00 // @0538 stack[0] = 0x053f // @053A stack[1] = stack[-5] // @053A stack[3] = 0x20 // } // Block ends with call to 0x0802, returns to 0x053F label_053F: // Incoming return from call to 0x0802 at 0x053E // Inputs[4] // { // @0543 storage[0x06] // @0551 stack[-1] // @0552 memory[stack[-1]:stack[-1] + 0x20] // @0554 stack[-2] // } 053F 5B JUMPDEST 0540 60 PUSH1 0x06 0542 80 DUP1 0543 54 SLOAD 0544 60 PUSH1 0x01 0546 81 DUP2 0547 01 ADD 0548 80 DUP1 0549 83 DUP4 054A 55 SSTORE 054B 60 PUSH1 0x00 054D 92 SWAP3 054E 90 SWAP1 054F 92 SWAP3 0550 52 MSTORE 0551 82 DUP3 0552 51 MLOAD 0553 92 SWAP3 0554 93 SWAP4 0555 50 POP 0556 90 SWAP1 0557 91 SWAP2 0558 61 PUSH2 0x0588 055B 91 SWAP2 055C 7F PUSH32 0xf652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f 057D 01 ADD 057E 90 SWAP1 057F 60 PUSH1 0x20 0581 85 DUP6 0582 01 ADD 0583 90 SWAP1 0584 61 PUSH2 0x0981 0587 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @054A storage[0x06] = storage[0x06] + 0x01 // @0550 memory[0x00:0x20] = 0x06 // @0554 stack[-2] = stack[-1] // @0557 stack[-1] = storage[0x06] + 0x01 // @055B stack[0] = 0x0588 // @057E stack[1] = 0xf652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f + storage[0x06] // @0583 stack[2] = stack[-1] + 0x20 // @0583 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x0981 0588 5B JUMPDEST 0589 50 POP 058A 50 POP 058B 60 PUSH1 0x05 058D 80 DUP1 058E 54 SLOAD 058F 60 PUSH1 0x01 0591 81 DUP2 0592 01 ADD 0593 82 DUP3 0594 55 SSTORE 0595 60 PUSH1 0x00 0597 91 SWAP2 0598 90 SWAP1 0599 91 SWAP2 059A 52 MSTORE 059B 7F PUSH32 0x036b6384b5eca791c62761152d0c79bb0604c104a5fb6f4eb0703f3154bb3db0 05BC 01 ADD 05BD 80 DUP1 05BE 54 SLOAD 05BF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05D4 19 NOT 05D5 16 AND 05D6 60 PUSH1 0x01 05D8 60 PUSH1 0xa0 05DA 60 PUSH1 0x02 05DC 0A EXP 05DD 03 SUB 05DE 89 DUP10 05DF 16 AND 05E0 17 OR 05E1 90 SWAP1 05E2 55 SSTORE 05E3 60 PUSH1 0x40 05E5 51 MLOAD 05E6 7F PUSH32 0x7804feab32c9029e450d463575157bebe1cb6700ad1104371721398aaff9aad3 0607 90 SWAP1 0608 61 PUSH2 0x0616 060B 90 SWAP1 060C 89 DUP10 060D 90 SWAP1 060E 84 DUP5 060F 90 SWAP1 0610 8A DUP11 0611 90 SWAP1 0612 61 PUSH2 0x0cb3 0615 56 *JUMP 0616 5B JUMPDEST 0617 60 PUSH1 0x40 0619 51 MLOAD 061A 80 DUP1 061B 91 SWAP2 061C 03 SUB 061D 90 SWAP1 061E A1 LOG1 061F 61 PUSH2 0x0655 0622 56 *JUMP label_0623: // Incoming jump from 0x050F, if !stack[-1] // Inputs[1] { @0626 memory[0x40:0x60] } 0623 5B JUMPDEST 0624 60 PUSH1 0x40 0626 51 MLOAD 0627 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0648 81 DUP2 0649 52 MSTORE 064A 60 PUSH1 0x04 064C 01 ADD 064D 61 PUSH2 0x03a8 0650 90 SWAP1 0651 61 PUSH2 0x0d23 0654 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0649 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0650 stack[0] = 0x03a8 // @0650 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0d23 0655 5B JUMPDEST 0656 50 POP 0657 50 POP 0658 50 POP 0659 50 POP 065A 50 POP 065B 50 POP 065C 50 POP 065D 56 *JUMP label_065E: // Incoming jump from 0x0129 // Inputs[2] // { // @0662 storage[0x05] // @0663 stack[-1] // } 065E 5B JUMPDEST 065F 60 PUSH1 0x05 0661 80 DUP1 0662 54 SLOAD 0663 82 DUP3 0664 90 SWAP1 0665 81 DUP2 0666 10 LT 0667 61 PUSH2 0x066c 066A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @065F stack[0] = 0x05 // @0664 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x066c, if stack[-1] < storage[0x05] label_066B: // Incoming jump from 0x066A, if not stack[-1] < storage[0x05] 066B FE *ASSERT // Stack delta = +0 // Outputs[1] { @066B assert(); } // Block terminates label_066C: // Incoming jump from 0x066A, if stack[-1] < storage[0x05] // Inputs[6] // { // @066F stack[-2] // @0674 stack[-1] // @0676 memory[0x00:0x20] // @0678 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0682 stack[-3] // @0684 stack[-4] // } 066C 5B JUMPDEST 066D 60 PUSH1 0x00 066F 91 SWAP2 0670 82 DUP3 0671 52 MSTORE 0672 60 PUSH1 0x20 0674 90 SWAP1 0675 91 SWAP2 0676 20 SHA3 0677 01 ADD 0678 54 SLOAD 0679 60 PUSH1 0x01 067B 60 PUSH1 0xa0 067D 60 PUSH1 0x02 067F 0A EXP 0680 03 SUB 0681 16 AND 0682 90 SWAP1 0683 50 POP 0684 81 DUP2 0685 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0671 memory[0x00:0x20] = stack[-2] // @0682 stack[-3] = 0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-4] label_0686: // Incoming call from 0x014B, returns to 0x012A // Inputs[2] // { // @0689 storage[0x00] // @0693 stack[-1] // } 0686 5B JUMPDEST 0687 60 PUSH1 0x00 0689 54 SLOAD 068A 60 PUSH1 0x01 068C 60 PUSH1 0xa0 068E 60 PUSH1 0x02 0690 0A EXP 0691 03 SUB 0692 16 AND 0693 81 DUP2 0694 56 *JUMP // Stack delta = +1 // Outputs[1] { @0692 stack[0] = 0x02 ** 0xa0 - 0x01 & storage[0x00] } // Block ends with unconditional jump to stack[-1] label_0695: // Incoming jump from 0x016B // Inputs[4] // { // @069E stack[-1] // @06AC memory[0x00:0x40] // @06AD storage[keccak256(memory[0x00:0x40])] // @06B1 stack[-2] // } 0695 5B JUMPDEST 0696 60 PUSH1 0x01 0698 60 PUSH1 0xa0 069A 60 PUSH1 0x02 069C 0A EXP 069D 03 SUB 069E 16 AND 069F 60 PUSH1 0x00 06A1 90 SWAP1 06A2 81 DUP2 06A3 52 MSTORE 06A4 60 PUSH1 0x04 06A6 60 PUSH1 0x20 06A8 52 MSTORE 06A9 60 PUSH1 0x40 06AB 90 SWAP1 06AC 20 SHA3 06AD 54 SLOAD 06AE 60 PUSH1 0xff 06B0 16 AND 06B1 90 SWAP1 06B2 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @06A3 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @06A8 memory[0x20:0x40] = 0x04 // @06B1 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_06B3: // Incoming jump from 0x0198 // Inputs[2] // { // @06B6 storage[0x00] // @06C0 msg.sender // } 06B3 5B JUMPDEST 06B4 60 PUSH1 0x00 06B6 54 SLOAD 06B7 60 PUSH1 0x01 06B9 60 PUSH1 0xa0 06BB 60 PUSH1 0x02 06BD 0A EXP 06BE 03 SUB 06BF 16 AND 06C0 33 CALLER 06C1 14 EQ 06C2 61 PUSH2 0x06ca 06C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ca, if msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x00] label_06C6: // Incoming jump from 0x06C5, if not msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x00] // Inputs[1] { @06C9 memory[0x00:0x00] } 06C6 60 PUSH1 0x00 06C8 80 DUP1 06C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C9 revert(memory[0x00:0x00]); } // Block terminates label_06CA: // Incoming jump from 0x06C5, if msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x00] // Inputs[3] // { // @06CE storage[0x03] // @06EE stack[-1] // @06F8 stack[-2] // } 06CA 5B JUMPDEST 06CB 60 PUSH1 0x03 06CD 80 DUP1 06CE 54 SLOAD 06CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06E4 19 NOT 06E5 16 AND 06E6 60 PUSH1 0x01 06E8 60 PUSH1 0xa0 06EA 60 PUSH1 0x02 06EC 0A EXP 06ED 03 SUB 06EE 92 SWAP3 06EF 90 SWAP1 06F0 92 SWAP3 06F1 16 AND 06F2 91 SWAP2 06F3 90 SWAP1 06F4 91 SWAP2 06F5 17 OR 06F6 90 SWAP1 06F7 55 SSTORE 06F8 56 *JUMP // Stack delta = -2 // Outputs[1] { @06F7 storage[0x03] = (0x02 ** 0xa0 - 0x01 & stack[-1]) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[0x03]) } // Block ends with unconditional jump to stack[-2] label_06F9: // Incoming call from 0x01AD, returns to 0x01AE // Inputs[3] // { // @06FF storage[0x05] // @0709 memory[0x40:0x60] // @071C storage[0x05] // } 06F9 5B JUMPDEST 06FA 60 PUSH1 0x60 06FC 60 PUSH1 0x05 06FE 80 DUP1 06FF 54 SLOAD 0700 80 DUP1 0701 60 PUSH1 0x20 0703 02 MUL 0704 60 PUSH1 0x20 0706 01 ADD 0707 60 PUSH1 0x40 0709 51 MLOAD 070A 90 SWAP1 070B 81 DUP2 070C 01 ADD 070D 60 PUSH1 0x40 070F 52 MSTORE 0710 80 DUP1 0711 92 SWAP3 0712 91 SWAP2 0713 90 SWAP1 0714 81 DUP2 0715 81 DUP2 0716 52 MSTORE 0717 60 PUSH1 0x20 0719 01 ADD 071A 82 DUP3 071B 80 DUP1 071C 54 SLOAD 071D 80 DUP1 071E 15 ISZERO 071F 61 PUSH2 0x0751 0722 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @06FA stack[0] = 0x60 // @070F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x05] // @0711 stack[1] = memory[0x40:0x60] // @0712 stack[2] = 0x05 // @0713 stack[3] = storage[0x05] // @0716 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x05] // @0719 stack[4] = 0x20 + memory[0x40:0x60] // @071A stack[5] = 0x05 // @071C stack[6] = storage[0x05] // } // Block ends with conditional jump to 0x0751, if !storage[0x05] label_0723: // Incoming jump from 0x0722, if not !storage[0x05] // Inputs[5] // { // @0725 stack[-1] // @0726 stack[-3] // @0729 stack[-2] // @0731 memory[0x00:0x20] // @0735 storage[keccak256(memory[0x00:0x20])] // } 0723 60 PUSH1 0x20 0725 02 MUL 0726 82 DUP3 0727 01 ADD 0728 91 SWAP2 0729 90 SWAP1 072A 60 PUSH1 0x00 072C 52 MSTORE 072D 60 PUSH1 0x20 072F 60 PUSH1 0x00 0731 20 SHA3 0732 90 SWAP1 0733 5B JUMPDEST 0734 81 DUP2 0735 54 SLOAD 0736 60 PUSH1 0x01 0738 60 PUSH1 0xa0 073A 60 PUSH1 0x02 073C 0A EXP 073D 03 SUB 073E 16 AND 073F 81 DUP2 0740 52 MSTORE 0741 60 PUSH1 0x01 0743 90 SWAP1 0744 91 SWAP2 0745 01 ADD 0746 90 SWAP1 0747 60 PUSH1 0x20 0749 01 ADD 074A 80 DUP1 074B 83 DUP4 074C 11 GT 074D 61 PUSH2 0x0733 0750 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0728 stack[-3] = stack[-3] + 0x20 * stack[-1] // @072C memory[0x00:0x20] = stack[-2] // @0740 memory[stack[-3]:stack[-3] + 0x20] = 0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x20])] // @0746 stack[-2] = keccak256(memory[0x00:0x20]) + 0x01 // @0749 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0733, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_0751: // Incoming jump from 0x0722, if !storage[0x05] // Incoming jump from 0x0750, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0750, if not stack[-3] > 0x20 + stack[-1] // Inputs[3] // { // @0757 stack[-7] // @0757 stack[-6] // @0759 stack[-8] // } 0751 5B JUMPDEST 0752 50 POP 0753 50 POP 0754 50 POP 0755 50 POP 0756 50 POP 0757 90 SWAP1 0758 50 POP 0759 90 SWAP1 075A 56 *JUMP // Stack delta = -7 // Outputs[1] { @0759 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_075B: // Incoming jump from 0x01DA // Inputs[2] // { // @075F storage[0x06] // @0760 stack[-1] // } 075B 5B JUMPDEST 075C 60 PUSH1 0x06 075E 80 DUP1 075F 54 SLOAD 0760 82 DUP3 0761 90 SWAP1 0762 81 DUP2 0763 10 LT 0764 61 PUSH2 0x0769 0767 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @075C stack[0] = 0x06 // @0761 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0769, if stack[-1] < storage[0x06] label_0768: // Incoming jump from 0x0767, if not stack[-1] < storage[0x06] 0768 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0768 assert(); } // Block terminates label_0769: // Incoming jump from 0x0767, if stack[-1] < storage[0x06] // Inputs[6] // { // @076C stack[-2] // @0774 memory[0x00:0x20] // @0775 stack[-1] // @0777 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @077B memory[0x40:0x60] // @07A6 stack[-3] // } 0769 5B JUMPDEST 076A 60 PUSH1 0x00 076C 91 SWAP2 076D 82 DUP3 076E 52 MSTORE 076F 60 PUSH1 0x20 0771 91 SWAP2 0772 82 DUP3 0773 90 SWAP1 0774 20 SHA3 0775 01 ADD 0776 80 DUP1 0777 54 SLOAD 0778 60 PUSH1 0x40 077A 80 DUP1 077B 51 MLOAD 077C 60 PUSH1 0x1f 077E 60 PUSH1 0x02 0780 60 PUSH1 0x00 0782 19 NOT 0783 61 PUSH2 0x0100 0786 60 PUSH1 0x01 0788 87 DUP8 0789 16 AND 078A 15 ISZERO 078B 02 MUL 078C 01 ADD 078D 90 SWAP1 078E 94 SWAP5 078F 16 AND 0790 93 SWAP4 0791 90 SWAP1 0792 93 SWAP4 0793 04 DIV 0794 92 SWAP3 0795 83 DUP4 0796 01 ADD 0797 85 DUP6 0798 90 SWAP1 0799 04 DIV 079A 85 DUP6 079B 02 MUL 079C 81 DUP2 079D 01 ADD 079E 85 DUP6 079F 01 ADD 07A0 90 SWAP1 07A1 91 SWAP2 07A2 52 MSTORE 07A3 81 DUP2 07A4 81 DUP2 07A5 52 MSTORE 07A6 93 SWAP4 07A7 50 POP 07A8 90 SWAP1 07A9 91 SWAP2 07AA 83 DUP4 07AB 01 ADD 07AC 82 DUP3 07AD 82 DUP3 07AE 80 DUP1 07AF 15 ISZERO 07B0 61 PUSH2 0x07fa 07B3 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @076E memory[0x00:0x20] = stack[-2] // @07A2 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x20]) + stack[-1]] & !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @07A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x20]) + stack[-1]] & !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] & 0x01) * 0x0100 + ~0x00) / 0x02 // @07A6 stack[-3] = memory[0x40:0x60] // @07A8 stack[-1] = (storage[keccak256(memory[0x00:0x20]) + stack[-1]] & !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] & 0x01) * 0x0100 + ~0x00) / 0x02 // @07A9 stack[-2] = keccak256(memory[0x00:0x20]) + stack[-1] // @07AB stack[0] = memory[0x40:0x60] + 0x20 // @07AC stack[1] = keccak256(memory[0x00:0x20]) + stack[-1] // @07AD stack[2] = (storage[keccak256(memory[0x00:0x20]) + stack[-1]] & !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x07fa, if !((storage[keccak256(memory[0x00:0x20]) + stack[-1]] & !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] & 0x01) * 0x0100 + ~0x00) / 0x02) label_07B4: // Incoming jump from 0x07B3, if not !((storage[keccak256(memory[0x00:0x20]) + stack[-1]] & !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @07B4 stack[-1] } 07B4 80 DUP1 07B5 60 PUSH1 0x1f 07B7 10 LT 07B8 61 PUSH2 0x07cf 07BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07cf, if 0x1f < stack[-1] label_07BC: // Incoming jump from 0x07BB, if not 0x1f < stack[-1] // Inputs[4] // { // @07C0 stack[-2] // @07C1 storage[stack[-2]] // @07C4 stack[-3] // @07C6 stack[-1] // } 07BC 61 PUSH2 0x0100 07BF 80 DUP1 07C0 83 DUP4 07C1 54 SLOAD 07C2 04 DIV 07C3 02 MUL 07C4 83 DUP4 07C5 52 MSTORE 07C6 91 SWAP2 07C7 60 PUSH1 0x20 07C9 01 ADD 07CA 91 SWAP2 07CB 61 PUSH2 0x07fa 07CE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @07C5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @07CA stack[-1] = stack[-1] // @07CA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07fa label_07CF: // Incoming jump from 0x07BB, if 0x1f < stack[-1] // Inputs[5] // { // @07D0 stack[-3] // @07D1 stack[-1] // @07D3 stack[-2] // @07DB memory[0x00:0x20] // @07DF storage[keccak256(memory[0x00:0x20])] // } 07CF 5B JUMPDEST 07D0 82 DUP3 07D1 01 ADD 07D2 91 SWAP2 07D3 90 SWAP1 07D4 60 PUSH1 0x00 07D6 52 MSTORE 07D7 60 PUSH1 0x20 07D9 60 PUSH1 0x00 07DB 20 SHA3 07DC 90 SWAP1 07DD 5B JUMPDEST 07DE 81 DUP2 07DF 54 SLOAD 07E0 81 DUP2 07E1 52 MSTORE 07E2 90 SWAP1 07E3 60 PUSH1 0x01 07E5 01 ADD 07E6 90 SWAP1 07E7 60 PUSH1 0x20 07E9 01 ADD 07EA 80 DUP1 07EB 83 DUP4 07EC 11 GT 07ED 61 PUSH2 0x07dd 07F0 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @07D2 stack[-3] = stack[-3] + stack[-1] // @07D6 memory[0x00:0x20] = stack[-2] // @07E1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07E6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07E9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x07dd, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07F1: // Incoming jump from 0x07F0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x07F0, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @07F1 stack[-3] // @07F2 stack[-1] // } 07F1 82 DUP3 07F2 90 SWAP1 07F3 03 SUB 07F4 60 PUSH1 0x1f 07F6 16 AND 07F7 82 DUP3 07F8 01 ADD 07F9 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07F9 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07F9 stack[-1] = stack[-3] // } // Block continues label_07FA: // Incoming jump from 0x07CE // Incoming jump from 0x07F9 // Incoming jump from 0x07B3, if !((storage[keccak256(memory[0x00:0x20]) + stack[-1]] & !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0800 stack[-7] } 07FA 5B JUMPDEST 07FB 50 POP 07FC 50 POP 07FD 50 POP 07FE 50 POP 07FF 50 POP 0800 81 DUP2 0801 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0802: // Incoming call from 0x03CC, returns to 0x03CD // Incoming call from 0x053E, returns to 0x053F // Inputs[3] // { // @0808 stack[-2] // @0809 stack[-1] // @080D memory[0x40:0x60] // } 0802 5B JUMPDEST 0803 60 PUSH1 0x60 0805 80 DUP1 0806 60 PUSH1 0x00 0808 84 DUP5 0809 84 DUP5 080A 03 SUB 080B 60 PUSH1 0x40 080D 51 MLOAD 080E 90 SWAP1 080F 80 DUP1 0810 82 DUP3 0811 52 MSTORE 0812 80 DUP1 0813 60 PUSH1 0x1f 0815 01 ADD 0816 60 PUSH1 0x1f 0818 19 NOT 0819 16 AND 081A 60 PUSH1 0x20 081C 01 ADD 081D 82 DUP3 081E 01 ADD 081F 60 PUSH1 0x40 0821 52 MSTORE 0822 80 DUP1 0823 15 ISZERO 0824 61 PUSH2 0x0837 0827 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0803 stack[0] = 0x60 // @0805 stack[1] = 0x60 // @0806 stack[2] = 0x00 // @080E stack[3] = memory[0x40:0x60] // @080E stack[4] = stack[-1] - stack[-2] // @0811 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - stack[-2] // @0821 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + (stack[-1] - stack[-2])) // } // Block ends with conditional jump to 0x0837, if !(stack[-1] - stack[-2]) label_0828: // Incoming jump from 0x0827, if not !(stack[-1] - stack[-2]) // Inputs[7] // { // @0828 stack[-2] // @082E stack[-1] // @0831 code.length // @0839 stack[-4] // @083B stack[-7] // @083C stack[-3] // @083F stack[-6] // } 0828 81 DUP2 0829 60 PUSH1 0x20 082B 01 ADD 082C 60 PUSH1 0x20 082E 82 DUP3 082F 02 MUL 0830 80 DUP1 0831 38 CODESIZE 0832 83 DUP4 0833 39 CODECOPY 0834 01 ADD 0835 90 SWAP1 0836 50 POP 0837 5B JUMPDEST 0838 50 POP 0839 91 SWAP2 083A 50 POP 083B 84 DUP5 083C 90 SWAP1 083D 50 POP 083E 5B JUMPDEST 083F 83 DUP4 0840 81 DUP2 0841 10 LT 0842 15 ISZERO 0843 61 PUSH2 0x08af 0846 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @0833 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = code[code.length:code.length + stack[-1] * 0x20] // @0839 stack[-4] = stack[-2] // @083C stack[-3] = stack[-7] // } // Block ends with conditional jump to 0x08af, if !(stack[-7] < stack[-6]) label_0847: // Incoming jump from 0x0846, if not !(stack[-7] < stack[-6]) // Incoming jump from 0x0846, if not !(stack[-7] < stack[-6]) // Incoming jump from 0x0846, if not !(stack[-1] < stack[-4]) // Inputs[3] // { // @0847 stack[-6] // @0848 stack[-1] // @084A memory[stack[-6]:stack[-6] + 0x20] // } 0847 85 DUP6 0848 81 DUP2 0849 81 DUP2 084A 51 MLOAD 084B 81 DUP2 084C 10 LT 084D 15 ISZERO 084E 15 ISZERO 084F 61 PUSH2 0x0854 0852 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0847 stack[0] = stack[-6] // @0848 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0854, if !!(stack[-1] < memory[stack[-6]:stack[-6] + 0x20]) label_0853: // Incoming jump from 0x0852, if not !!(stack[-1] < memory[stack[-6]:stack[-6] + 0x20]) 0853 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0853 assert(); } // Block terminates label_0854: // Incoming jump from 0x0852, if !!(stack[-1] < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[7] // { // @0855 stack[-2] // @0855 stack[-1] // @085A memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0868 stack[-4] // @0869 stack[-7] // @086A stack[-3] // @086D memory[stack[-4]:stack[-4] + 0x20] // } 0854 5B JUMPDEST 0855 90 SWAP1 0856 60 PUSH1 0x20 0858 01 ADD 0859 01 ADD 085A 51 MLOAD 085B 60 PUSH1 0xf8 085D 60 PUSH1 0x02 085F 0A EXP 0860 90 SWAP1 0861 04 DIV 0862 60 PUSH1 0xf8 0864 60 PUSH1 0x02 0866 0A EXP 0867 02 MUL 0868 82 DUP3 0869 86 DUP7 086A 83 DUP4 086B 03 SUB 086C 81 DUP2 086D 51 MLOAD 086E 81 DUP2 086F 10 LT 0870 15 ISZERO 0871 15 ISZERO 0872 61 PUSH2 0x0877 0875 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0867 stack[-2] = 0x02 ** 0xf8 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x02 ** 0xf8) // @0868 stack[-1] = stack[-4] // @086B stack[0] = stack[-3] - stack[-7] // } // Block ends with conditional jump to 0x0877, if !!(stack[-3] - stack[-7] < memory[stack[-4]:stack[-4] + 0x20]) label_0876: // Incoming jump from 0x0875, if not !!(stack[-3] - stack[-7] < memory[stack[-4]:stack[-4] + 0x20]) 0876 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0876 assert(); } // Block terminates label_0877: // Incoming jump from 0x0875, if !!(stack[-3] - stack[-7] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @0878 stack[-1] // @0878 stack[-2] // @087D stack[-3] // @08AA stack[-4] // } 0877 5B JUMPDEST 0878 90 SWAP1 0879 60 PUSH1 0x20 087B 01 ADD 087C 01 ADD 087D 90 SWAP1 087E 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 089E 19 NOT 089F 16 AND 08A0 90 SWAP1 08A1 81 DUP2 08A2 60 PUSH1 0x00 08A4 1A BYTE 08A5 90 SWAP1 08A6 53 MSTORE8 08A7 50 POP 08A8 60 PUSH1 0x01 08AA 01 ADD 08AB 61 PUSH2 0x083e 08AE 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @08A6 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @08AA stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x083e label_08AF: // Incoming jump from 0x0846, if !(stack[-7] < stack[-6]) // Incoming jump from 0x0846, if !(stack[-7] < stack[-6]) // Incoming jump from 0x0846, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @08B1 stack[-2] // @08B1 stack[-7] // @08B2 stack[-6] // } 08AF 5B JUMPDEST 08B0 50 POP 08B1 94 SWAP5 08B2 93 SWAP4 08B3 50 POP 08B4 50 POP 08B5 50 POP 08B6 50 POP 08B7 56 *JUMP // Stack delta = -6 // Outputs[1] { @08B1 stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_08B8: // Incoming jump from 0x0509 // Inputs[4] // { // @08BC stack[-1] // @08BD memory[stack[-1]:stack[-1] + 0x20] // @08BE stack[-2] // @08BF memory[stack[-2]:stack[-2] + 0x20] // } 08B8 5B JUMPDEST 08B9 60 PUSH1 0x00 08BB 80 DUP1 08BC 82 DUP3 08BD 51 MLOAD 08BE 84 DUP5 08BF 51 MLOAD 08C0 14 EQ 08C1 15 ISZERO 08C2 15 ISZERO 08C3 61 PUSH2 0x08cf 08C6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @08B9 stack[0] = 0x00 // @08BB stack[1] = 0x00 // } // Block ends with conditional jump to 0x08cf, if !!(memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20]) label_08C7: // Incoming jump from 0x08C6, if not !!(memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @08C9 stack[-2] } 08C7 60 PUSH1 0x00 08C9 91 SWAP2 08CA 50 POP 08CB 61 PUSH2 0x097a 08CE 56 *JUMP // Stack delta = +0 // Outputs[1] { @08C9 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x097a label_08CF: // Incoming jump from 0x08C6, if !!(memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @08D4 stack[-4] // @08D5 memory[stack[-4]:stack[-4] + 0x20] // } 08CF 5B JUMPDEST 08D0 50 POP 08D1 60 PUSH1 0x00 08D3 5B JUMPDEST 08D4 83 DUP4 08D5 51 MLOAD 08D6 81 DUP2 08D7 10 LT 08D8 15 ISZERO 08D9 61 PUSH2 0x0975 08DC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @08D1 stack[-1] = 0x00 } // Block ends with conditional jump to 0x0975, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_08DD: // Incoming jump from 0x08DC, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x08DC, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @08DD stack[-3] // @08DE stack[-1] // @08E0 memory[stack[-3]:stack[-3] + 0x20] // } 08DD 82 DUP3 08DE 81 DUP2 08DF 81 DUP2 08E0 51 MLOAD 08E1 81 DUP2 08E2 10 LT 08E3 15 ISZERO 08E4 15 ISZERO 08E5 61 PUSH2 0x08ea 08E8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @08DD stack[0] = stack[-3] // @08DE stack[1] = stack[-1] // } // Block ends with conditional jump to 0x08ea, if !!(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) label_08E9: // Incoming jump from 0x08E8, if not !!(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) 08E9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @08E9 assert(); } // Block terminates label_08EA: // Incoming jump from 0x08E8, if !!(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[6] // { // @08EB stack[-1] // @08EB stack[-2] // @08F0 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0920 stack[-6] // @0921 stack[-3] // @0923 memory[stack[-6]:stack[-6] + 0x20] // } 08EA 5B JUMPDEST 08EB 90 SWAP1 08EC 60 PUSH1 0x20 08EE 01 ADD 08EF 01 ADD 08F0 51 MLOAD 08F1 60 PUSH1 0xf8 08F3 60 PUSH1 0x02 08F5 0A EXP 08F6 90 SWAP1 08F7 04 DIV 08F8 60 PUSH1 0xf8 08FA 60 PUSH1 0x02 08FC 0A EXP 08FD 02 MUL 08FE 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 091E 19 NOT 091F 16 AND 0920 84 DUP5 0921 82 DUP3 0922 81 DUP2 0923 51 MLOAD 0924 81 DUP2 0925 10 LT 0926 15 ISZERO 0927 15 ISZERO 0928 61 PUSH2 0x092d 092B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @091F stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x02 ** 0xf8 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x02 ** 0xf8) // @0920 stack[-1] = stack[-6] // @0921 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x092d, if !!(stack[-3] < memory[stack[-6]:stack[-6] + 0x20]) label_092C: // Incoming jump from 0x092B, if not !!(stack[-3] < memory[stack[-6]:stack[-6] + 0x20]) 092C FE *ASSERT // Stack delta = +0 // Outputs[1] { @092C assert(); } // Block terminates label_092D: // Incoming jump from 0x092B, if !!(stack[-3] < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @0930 stack[-2] // @0931 stack[-1] // @0933 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // @0960 stack[-3] // } 092D 5B JUMPDEST 092E 60 PUSH1 0x20 0930 91 SWAP2 0931 01 ADD 0932 01 ADD 0933 51 MLOAD 0934 60 PUSH1 0xf8 0936 60 PUSH1 0x02 0938 0A EXP 0939 90 SWAP1 093A 81 DUP2 093B 90 SWAP1 093C 04 DIV 093D 02 MUL 093E 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 095F 16 AND 0960 14 EQ 0961 61 PUSH2 0x096d 0964 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x096d, if 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] / 0x02 ** 0xf8 * 0x02 ** 0xf8 == stack[-3] label_0965: // Incoming jump from 0x0964, if not 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] / 0x02 ** 0xf8 * 0x02 ** 0xf8 == stack[-3] // Inputs[1] { @0967 stack[-2] } 0965 60 PUSH1 0x00 0967 91 SWAP2 0968 50 POP 0969 61 PUSH2 0x097a 096C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0967 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x097a label_096D: // Incoming jump from 0x0964, if 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] / 0x02 ** 0xf8 * 0x02 ** 0xf8 == stack[-3] // Inputs[1] { @0970 stack[-1] } 096D 5B JUMPDEST 096E 60 PUSH1 0x01 0970 01 ADD 0971 61 PUSH2 0x08d3 0974 56 *JUMP // Stack delta = +0 // Outputs[1] { @0970 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x08d3 label_0975: // Incoming jump from 0x08DC, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x08DC, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @0978 stack[-2] // @097C stack[-5] // @097D stack[-4] // } 0975 5B JUMPDEST 0976 60 PUSH1 0x01 0978 91 SWAP2 0979 50 POP 097A 5B JUMPDEST 097B 50 POP 097C 92 SWAP3 097D 91 SWAP2 097E 50 POP 097F 50 POP 0980 56 *JUMP // Stack delta = -4 // Outputs[1] { @097C stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0981: // Incoming jump from 0x0329 // Incoming jump from 0x0587 // Inputs[5] // { // @0982 stack[-3] // @0984 storage[stack[-3]] // @099E memory[0x00:0x20] // @09A9 stack[-2] // @09AA stack[-1] // } 0981 5B JUMPDEST 0982 82 DUP3 0983 80 DUP1 0984 54 SLOAD 0985 60 PUSH1 0x01 0987 81 DUP2 0988 60 PUSH1 0x01 098A 16 AND 098B 15 ISZERO 098C 61 PUSH2 0x0100 098F 02 MUL 0990 03 SUB 0991 16 AND 0992 60 PUSH1 0x02 0994 90 SWAP1 0995 04 DIV 0996 90 SWAP1 0997 60 PUSH1 0x00 0999 52 MSTORE 099A 60 PUSH1 0x20 099C 60 PUSH1 0x00 099E 20 SHA3 099F 90 SWAP1 09A0 60 PUSH1 0x1f 09A2 01 ADD 09A3 60 PUSH1 0x20 09A5 90 SWAP1 09A6 04 DIV 09A7 81 DUP2 09A8 01 ADD 09A9 92 SWAP3 09AA 82 DUP3 09AB 60 PUSH1 0x1f 09AD 10 LT 09AE 61 PUSH2 0x09c2 09B1 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0999 memory[0x00:0x20] = stack[-3] // @099F stack[0] = keccak256(memory[0x00:0x20]) // @09A9 stack[1] = stack[-2] // @09A9 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x09c2, if 0x1f < stack[-1] label_09B2: // Incoming jump from 0x09B1, if not 0x1f < stack[-1] // Inputs[4] // { // @09B2 stack[-1] // @09B3 memory[stack[-1]:stack[-1] + 0x20] // @09B8 stack[-3] // @09BC stack[-5] // } 09B2 80 DUP1 09B3 51 MLOAD 09B4 60 PUSH1 0xff 09B6 19 NOT 09B7 16 AND 09B8 83 DUP4 09B9 80 DUP1 09BA 01 ADD 09BB 17 OR 09BC 85 DUP6 09BD 55 SSTORE 09BE 61 PUSH2 0x09ef 09C1 56 *JUMP // Stack delta = +0 // Outputs[1] { @09BD storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x09ef label_09C2: // Incoming jump from 0x09B1, if 0x1f < stack[-1] // Inputs[2] // { // @09C3 stack[-3] // @09C9 stack[-5] // } 09C2 5B JUMPDEST 09C3 82 DUP3 09C4 80 DUP1 09C5 01 ADD 09C6 60 PUSH1 0x01 09C8 01 ADD 09C9 85 DUP6 09CA 55 SSTORE 09CB 82 DUP3 09CC 15 ISZERO 09CD 61 PUSH2 0x09ef 09D0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @09CA storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x09ef, if !stack[-3] label_09D1: // Incoming jump from 0x09D0, if not !stack[-3] // Inputs[2] // { // @09D1 stack[-3] // @09D1 stack[-1] // } 09D1 91 SWAP2 09D2 82 DUP3 09D3 01 ADD 09D4 5B JUMPDEST 09D5 82 DUP3 09D6 81 DUP2 09D7 11 GT 09D8 15 ISZERO 09D9 61 PUSH2 0x09ef 09DC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @09D1 stack[-3] = stack[-1] // @09D3 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x09ef, if !(stack[-1] + stack[-3] > stack[-1]) label_09DD: // Incoming jump from 0x09DC, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x09DC, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @09DD stack[-3] // @09DE memory[stack[-3]:stack[-3] + 0x20] // @09DF stack[-2] // @09E1 stack[-1] // } 09DD 82 DUP3 09DE 51 MLOAD 09DF 82 DUP3 09E0 55 SSTORE 09E1 91 SWAP2 09E2 60 PUSH1 0x20 09E4 01 ADD 09E5 91 SWAP2 09E6 90 SWAP1 09E7 60 PUSH1 0x01 09E9 01 ADD 09EA 90 SWAP1 09EB 61 PUSH2 0x09d4 09EE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @09E0 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @09E5 stack[-3] = 0x20 + stack[-3] // @09EA stack[-2] = 0x01 + stack[-2] // @09EA stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x09d4 label_09EF: // Incoming jump from 0x09DC, if !(stack[-1] > stack[-3]) // Incoming jump from 0x09C1 // Incoming jump from 0x09DC, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x09D0, if !stack[-3] // Inputs[2] // { // @09F4 stack[-4] // @09F5 stack[-3] // } 09EF 5B JUMPDEST 09F0 50 POP 09F1 61 PUSH2 0x09fb 09F4 92 SWAP3 09F5 91 SWAP2 09F6 50 POP 09F7 61 PUSH2 0x09ff 09FA 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @09F4 stack[-4] = 0x09fb // @09F5 stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0x09ff label_09FB: // Incoming jump from 0x0A0D, if !(stack[-2] > stack[-1]) // Incoming call from 0x0A0D, returns to 0x02BE, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @09FD stack[-3] // @09FD stack[-2] // } 09FB 5B JUMPDEST 09FC 50 POP 09FD 90 SWAP1 09FE 56 *JUMP // Stack delta = -2 // Outputs[1] { @09FD stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_09FF: // Incoming jump from 0x09FA // Inputs[2] // { // @0A03 stack[-2] // @0A04 stack[-1] // } 09FF 5B JUMPDEST 0A00 61 PUSH2 0x02be 0A03 91 SWAP2 0A04 90 SWAP1 0A05 5B JUMPDEST 0A06 80 DUP1 0A07 82 DUP3 0A08 11 GT 0A09 15 ISZERO 0A0A 61 PUSH2 0x09fb 0A0D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A03 stack[-2] = 0x02be // @0A04 stack[-1] = stack[-2] // @0A04 stack[0] = stack[-1] // } // Block ends with conditional call to 0x09fb, returns to 0x02BE, if !(stack[-2] > stack[-1]) label_0A0E: // Incoming jump from 0x0A0D, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x0A0D, if not !(stack[-2] > stack[-1]) // Inputs[1] { @0A10 stack[-1] } 0A0E 60 PUSH1 0x00 0A10 81 DUP2 0A11 55 SSTORE 0A12 60 PUSH1 0x01 0A14 01 ADD 0A15 61 PUSH2 0x0a05 0A18 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0A11 storage[stack[-1]] = 0x00 // @0A14 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x0a05 label_0A19: // Incoming call from 0x0AD2, returns to 0x0AD3 // Incoming call from 0x0AA9, returns to 0x0AAA // Inputs[2] // { // @0A1F stack[-1] // @0A20 msg.data[stack[-1]:stack[-1] + 0x20] // } 0A19 5B JUMPDEST 0A1A 60 PUSH1 0x00 0A1C 61 PUSH2 0x0a25 0A1F 82 DUP3 0A20 35 CALLDATALOAD 0A21 61 PUSH2 0x0d8c 0A24 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A1A stack[0] = 0x00 // @0A1C stack[1] = 0x0a25 // @0A20 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0d8c, returns to 0x0A25 label_0A25: // Incoming return from call to 0x0B44 at 0x0CF2 // Incoming return from call to 0x0C0B at 0x0D22 // Incoming return from call to 0x0D8C at 0x0A24 // Incoming return from call to 0x0B9B at 0x0D03 // Incoming return from call to 0x02BE at 0x0A8B // Inputs[3] // { // @0A26 stack[-5] // @0A26 stack[-1] // @0A27 stack[-4] // } 0A25 5B JUMPDEST 0A26 93 SWAP4 0A27 92 SWAP3 0A28 50 POP 0A29 50 POP 0A2A 50 POP 0A2B 56 *JUMP // Stack delta = -4 // Outputs[1] { @0A26 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0A2C: // Incoming call from 0x0B0C, returns to 0x0B0D // Inputs[2] // { // @0A31 stack[-1] // @0A33 stack[-2] // } 0A2C 5B JUMPDEST 0A2D 60 PUSH1 0x00 0A2F 60 PUSH1 0x1f 0A31 82 DUP3 0A32 01 ADD 0A33 83 DUP4 0A34 13 SGT 0A35 61 PUSH2 0x0a3d 0A38 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A2D stack[0] = 0x00 } // Block ends with conditional jump to 0x0a3d, if stack[-2] i> stack[-1] + 0x1f label_0A39: // Incoming jump from 0x0A38, if not stack[-2] i> stack[-1] + 0x1f // Inputs[1] { @0A3C memory[0x00:0x00] } 0A39 60 PUSH1 0x00 0A3B 80 DUP1 0A3C FD *REVERT // Stack delta = +0 // Outputs[1] { @0A3C revert(memory[0x00:0x00]); } // Block terminates label_0A3D: // Incoming jump from 0x0A38, if stack[-2] i> stack[-1] + 0x1f // Inputs[2] // { // @0A3E stack[-2] // @0A3F msg.data[stack[-2]:stack[-2] + 0x20] // } 0A3D 5B JUMPDEST 0A3E 81 DUP2 0A3F 35 CALLDATALOAD 0A40 61 PUSH2 0x0a50 0A43 61 PUSH2 0x0a4b 0A46 82 DUP3 0A47 61 PUSH2 0x0d5a 0A4A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A3F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @0A40 stack[1] = 0x0a50 // @0A43 stack[2] = 0x0a4b // @0A46 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x0d5a, returns to 0x0A4B label_0A4B: // Incoming return from call to 0x0D5A at 0x0A4A 0A4B 5B JUMPDEST 0A4C 61 PUSH2 0x0d33 0A4F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d33 label_0A50: // Incoming return from call to 0x0A4B at 0x0A4A // Inputs[5] // { // @0A51 stack[-1] // @0A51 stack[-3] // @0A53 stack[-2] // @0A58 stack[-4] // @0A5E stack[-5] // } 0A50 5B JUMPDEST 0A51 91 SWAP2 0A52 50 POP 0A53 80 DUP1 0A54 82 DUP3 0A55 52 MSTORE 0A56 60 PUSH1 0x20 0A58 83 DUP4 0A59 01 ADD 0A5A 60 PUSH1 0x20 0A5C 83 DUP4 0A5D 01 ADD 0A5E 85 DUP6 0A5F 83 DUP4 0A60 83 DUP4 0A61 01 ADD 0A62 11 GT 0A63 15 ISZERO 0A64 61 PUSH2 0x0a6c 0A67 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0A51 stack[-3] = stack[-1] // @0A55 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @0A59 stack[-1] = stack[-4] + 0x20 // @0A5D stack[0] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x0a6c, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) label_0A68: // Incoming jump from 0x0A67, if not !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[1] { @0A6B memory[0x00:0x00] } 0A68 60 PUSH1 0x00 0A6A 80 DUP1 0A6B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A6B revert(memory[0x00:0x00]); } // Block terminates label_0A6C: // Incoming jump from 0x0A67, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[3] // { // @0A70 stack[-3] // @0A71 stack[-1] // @0A72 stack[-2] // } 0A6C 5B JUMPDEST 0A6D 61 PUSH2 0x0a77 0A70 83 DUP4 0A71 82 DUP3 0A72 84 DUP5 0A73 61 PUSH2 0x0d9d 0A76 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A6D stack[0] = 0x0a77 // @0A70 stack[1] = stack[-3] // @0A71 stack[2] = stack[-1] // @0A72 stack[3] = stack[-2] // } // Block ends with call to 0x0d9d, returns to 0x0A77 label_0A77: // Incoming return from call to 0x0D9D at 0x0A76 // Inputs[3] // { // @0A7B stack[-7] // @0A7B stack[-4] // @0A7C stack[-6] // } 0A77 5B JUMPDEST 0A78 50 POP 0A79 50 POP 0A7A 50 POP 0A7B 92 SWAP3 0A7C 91 SWAP2 0A7D 50 POP 0A7E 50 POP 0A7F 56 *JUMP // Stack delta = -6 // Outputs[1] { @0A7B stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] label_0A80: // Incoming call from 0x0AE3, returns to 0x0AE4 // Incoming call from 0x0B34, returns to 0x0AAA // Inputs[2] // { // @0A86 stack[-1] // @0A87 msg.data[stack[-1]:stack[-1] + 0x20] // } 0A80 5B JUMPDEST 0A81 60 PUSH1 0x00 0A83 61 PUSH2 0x0a25 0A86 82 DUP3 0A87 35 CALLDATALOAD 0A88 61 PUSH2 0x02be 0A8B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A81 stack[0] = 0x00 // @0A83 stack[1] = 0x0a25 // @0A87 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x02be, returns to 0x0A25 label_0A8C: // Incoming call from 0x0166, returns to 0x0167 // Incoming call from 0x0193, returns to 0x0194 // Inputs[2] // { // @0A91 stack[-1] // @0A92 stack[-2] // } 0A8C 5B JUMPDEST 0A8D 60 PUSH1 0x00 0A8F 60 PUSH1 0x20 0A91 82 DUP3 0A92 84 DUP5 0A93 03 SUB 0A94 12 SLT 0A95 15 ISZERO 0A96 61 PUSH2 0x0a9e 0A99 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A8D stack[0] = 0x00 } // Block ends with conditional jump to 0x0a9e, if !(stack[-2] - stack[-1] i< 0x20) label_0A9A: // Incoming jump from 0x0A99, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0A9D memory[0x00:0x00] } 0A9A 60 PUSH1 0x00 0A9C 80 DUP1 0A9D FD *REVERT // Stack delta = +0 // Outputs[1] { @0A9D revert(memory[0x00:0x00]); } // Block terminates label_0A9E: // Incoming jump from 0x0A99, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0AA4 stack[-3] // @0AA5 stack[-2] // } 0A9E 5B JUMPDEST 0A9F 60 PUSH1 0x00 0AA1 61 PUSH2 0x0aaa 0AA4 84 DUP5 0AA5 84 DUP5 0AA6 61 PUSH2 0x0a19 0AA9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A9F stack[0] = 0x00 // @0AA1 stack[1] = 0x0aaa // @0AA4 stack[2] = stack[-3] // @0AA5 stack[3] = stack[-2] // } // Block ends with call to 0x0a19, returns to 0x0AAA label_0AAA: // Incoming return from call to 0x0A19 at 0x0AA9 // Incoming return from call to 0x0A80 at 0x0B34 // Inputs[3] // { // @0AAB stack[-1] // @0AAB stack[-6] // @0AAC stack[-5] // } 0AAA 5B JUMPDEST 0AAB 94 SWAP5 0AAC 93 SWAP4 0AAD 50 POP 0AAE 50 POP 0AAF 50 POP 0AB0 50 POP 0AB1 56 *JUMP // Stack delta = -5 // Outputs[1] { @0AAB stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0AB2: // Incoming call from 0x0104, returns to 0x0105 // Incoming call from 0x00E2, returns to 0x00E3 // Inputs[2] // { // @0ABA stack[-1] // @0ABB stack[-2] // } 0AB2 5B JUMPDEST 0AB3 60 PUSH1 0x00 0AB5 80 DUP1 0AB6 60 PUSH1 0x00 0AB8 60 PUSH1 0x60 0ABA 84 DUP5 0ABB 86 DUP7 0ABC 03 SUB 0ABD 12 SLT 0ABE 15 ISZERO 0ABF 61 PUSH2 0x0ac7 0AC2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0AB3 stack[0] = 0x00 // @0AB5 stack[1] = 0x00 // @0AB6 stack[2] = 0x00 // } // Block ends with conditional jump to 0x0ac7, if !(stack[-2] - stack[-1] i< 0x60) label_0AC3: // Incoming jump from 0x0AC2, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @0AC6 memory[0x00:0x00] } 0AC3 60 PUSH1 0x00 0AC5 80 DUP1 0AC6 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AC6 revert(memory[0x00:0x00]); } // Block terminates label_0AC7: // Incoming jump from 0x0AC2, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @0ACD stack[-5] // @0ACE stack[-4] // } 0AC7 5B JUMPDEST 0AC8 60 PUSH1 0x00 0ACA 61 PUSH2 0x0ad3 0ACD 86 DUP7 0ACE 86 DUP7 0ACF 61 PUSH2 0x0a19 0AD2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AC8 stack[0] = 0x00 // @0ACA stack[1] = 0x0ad3 // @0ACD stack[2] = stack[-5] // @0ACE stack[3] = stack[-4] // } // Block ends with call to 0x0a19, returns to 0x0AD3 label_0AD3: // Incoming return from call to 0x0A19 at 0x0AD2 // Inputs[4] // { // @0AD4 stack[-1] // @0AD4 stack[-5] // @0ADC stack[-7] // @0ADE stack[-6] // } 0AD3 5B JUMPDEST 0AD4 93 SWAP4 0AD5 50 POP 0AD6 50 POP 0AD7 60 PUSH1 0x20 0AD9 61 PUSH2 0x0ae4 0ADC 86 DUP7 0ADD 82 DUP3 0ADE 87 DUP8 0ADF 01 ADD 0AE0 61 PUSH2 0x0a80 0AE3 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0AD4 stack[-5] = stack[-1] // @0AD7 stack[-2] = 0x20 // @0AD9 stack[-1] = 0x0ae4 // @0ADC stack[0] = stack[-7] // @0ADF stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x0a80, returns to 0x0AE4 label_0AE4: // Incoming return from call to 0x0A80 at 0x0AE3 // Inputs[4] // { // @0AE5 stack[-4] // @0AE5 stack[-1] // @0AEA stack[-6] // @0AEC msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // } 0AE4 5B JUMPDEST 0AE5 92 SWAP3 0AE6 50 POP 0AE7 50 POP 0AE8 60 PUSH1 0x40 0AEA 84 DUP5 0AEB 01 ADD 0AEC 35 CALLDATALOAD 0AED 67 PUSH8 0xffffffffffffffff 0AF6 81 DUP2 0AF7 11 GT 0AF8 15 ISZERO 0AF9 61 PUSH2 0x0b01 0AFC 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0AE5 stack[-4] = stack[-1] // @0AEC stack[-2] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x0b01, if !(msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] > 0xffffffffffffffff) label_0AFD: // Incoming jump from 0x0AFC, if not !(msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0B00 memory[0x00:0x00] } 0AFD 60 PUSH1 0x00 0AFF 80 DUP1 0B00 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B00 revert(memory[0x00:0x00]); } // Block terminates label_0B01: // Incoming jump from 0x0AFC, if !(msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0B05 stack[-6] // @0B06 stack[-1] // @0B07 stack[-5] // } 0B01 5B JUMPDEST 0B02 61 PUSH2 0x0b0d 0B05 86 DUP7 0B06 82 DUP3 0B07 87 DUP8 0B08 01 ADD 0B09 61 PUSH2 0x0a2c 0B0C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B02 stack[0] = 0x0b0d // @0B05 stack[1] = stack[-6] // @0B08 stack[2] = stack[-5] + stack[-1] // } // Block ends with call to 0x0a2c, returns to 0x0B0D label_0B0D: // Incoming return from call to 0x0A2C at 0x0B0C // Inputs[7] // { // @0B0E stack[-1] // @0B0E stack[-3] // @0B11 stack[-6] // @0B13 stack[-4] // @0B13 stack[-7] // @0B15 stack[-5] // @0B15 stack[-8] // } 0B0D 5B JUMPDEST 0B0E 91 SWAP2 0B0F 50 POP 0B10 50 POP 0B11 92 SWAP3 0B12 50 POP 0B13 92 SWAP3 0B14 50 POP 0B15 92 SWAP3 0B16 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @0B11 stack[-6] = stack[-1] // @0B13 stack[-7] = stack[-4] // @0B15 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_0B17: // Incoming call from 0x01D5, returns to 0x01D6 // Incoming call from 0x0124, returns to 0x0125 // Inputs[2] // { // @0B1C stack[-1] // @0B1D stack[-2] // } 0B17 5B JUMPDEST 0B18 60 PUSH1 0x00 0B1A 60 PUSH1 0x20 0B1C 82 DUP3 0B1D 84 DUP5 0B1E 03 SUB 0B1F 12 SLT 0B20 15 ISZERO 0B21 61 PUSH2 0x0b29 0B24 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B18 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b29, if !(stack[-2] - stack[-1] i< 0x20) label_0B25: // Incoming jump from 0x0B24, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0B28 memory[0x00:0x00] } 0B25 60 PUSH1 0x00 0B27 80 DUP1 0B28 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B28 revert(memory[0x00:0x00]); } // Block terminates label_0B29: // Incoming jump from 0x0B24, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0B2F stack[-3] // @0B30 stack[-2] // } 0B29 5B JUMPDEST 0B2A 60 PUSH1 0x00 0B2C 61 PUSH2 0x0aaa 0B2F 84 DUP5 0B30 84 DUP5 0B31 61 PUSH2 0x0a80 0B34 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B2A stack[0] = 0x00 // @0B2C stack[1] = 0x0aaa // @0B2F stack[2] = stack[-3] // @0B30 stack[3] = stack[-2] // } // Block ends with call to 0x0a80, returns to 0x0AAA label_0B35: // Incoming call from 0x0CAC, returns to 0x0CAD // Incoming call from 0x0B76, returns to 0x0B77 // Inputs[1] { @0B39 stack[-1] } 0B35 5B JUMPDEST 0B36 61 PUSH2 0x0b3e 0B39 81 DUP2 0B3A 61 PUSH2 0x0d8c 0B3D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B36 stack[0] = 0x0b3e // @0B39 stack[1] = stack[-1] // } // Block ends with call to 0x0d8c, returns to 0x0B3E label_0B3E: // Incoming return from call to 0x0D98 at 0x0C0A // Incoming return from call to 0x0D8C at 0x0B3D // Inputs[3] // { // @0B3F stack[-3] // @0B40 stack[-1] // @0B43 stack[-4] // } 0B3E 5B JUMPDEST 0B3F 82 DUP3 0B40 52 MSTORE 0B41 50 POP 0B42 50 POP 0B43 56 *JUMP // Stack delta = -4 // Outputs[1] { @0B40 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0B44: // Incoming call from 0x0CF2, returns to 0x0A25 // Inputs[1] { @0B4A stack[-1] } 0B44 5B JUMPDEST 0B45 60 PUSH1 0x00 0B47 61 PUSH2 0x0b4f 0B4A 82 DUP3 0B4B 61 PUSH2 0x0d88 0B4E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B45 stack[0] = 0x00 // @0B47 stack[1] = 0x0b4f // @0B4A stack[2] = stack[-1] // } // Block ends with call to 0x0d88, returns to 0x0B4F label_0B4F: // Incoming return from call to 0x0D88 at 0x0B4E // Inputs[3] // { // @0B50 stack[-1] // @0B51 stack[-4] // @0B5C stack[-3] // } 0B4F 5B JUMPDEST 0B50 80 DUP1 0B51 84 DUP5 0B52 52 MSTORE 0B53 60 PUSH1 0x20 0B55 84 DUP5 0B56 01 ADD 0B57 93 SWAP4 0B58 50 POP 0B59 61 PUSH2 0x0b61 0B5C 83 DUP4 0B5D 61 PUSH2 0x0d82 0B60 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0B52 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @0B57 stack[-4] = stack[-4] + 0x20 // @0B59 stack[0] = 0x0b61 // @0B5C stack[1] = stack[-3] // } // Block ends with call to 0x0d82, returns to 0x0B61 label_0B61: // Incoming return from call to 0x0D82 at 0x0B60 // Inputs[1] { @0B65 stack[-2] } 0B61 5B JUMPDEST 0B62 60 PUSH1 0x00 0B64 5B JUMPDEST 0B65 82 DUP3 0B66 81 DUP2 0B67 10 LT 0B68 15 ISZERO 0B69 61 PUSH2 0x0b91 0B6C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B62 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b91, if !(0x00 < stack[-2]) label_0B6D: // Incoming jump from 0x0B6C, if not !(0x00 < stack[-2]) // Incoming jump from 0x0B6C, if not !(stack[-1] < stack[-3]) // Inputs[3] // { // @0B70 stack[-6] // @0B71 stack[-2] // @0B72 memory[stack[-2]:stack[-2] + 0x20] // } 0B6D 61 PUSH2 0x0b77 0B70 86 DUP7 0B71 83 DUP4 0B72 51 MLOAD 0B73 61 PUSH2 0x0b35 0B76 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B6D stack[0] = 0x0b77 // @0B70 stack[1] = stack[-6] // @0B72 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x0b35, returns to 0x0B77 label_0B77: // Incoming return from call to 0x0B35 at 0x0B76 // Inputs[1] { @0B7B stack[-2] } 0B77 5B JUMPDEST 0B78 61 PUSH2 0x0b80 0B7B 82 DUP3 0B7C 61 PUSH2 0x0d82 0B7F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B78 stack[0] = 0x0b80 // @0B7B stack[1] = stack[-2] // } // Block ends with call to 0x0d82, returns to 0x0B80 label_0B80: // Incoming return from call to 0x0D82 at 0x0B7F // Inputs[4] // { // @0B83 stack[-7] // @0B84 stack[-1] // @0B88 stack[-3] // @0B8C stack[-2] // } 0B80 5B JUMPDEST 0B81 60 PUSH1 0x20 0B83 96 SWAP7 0B84 90 SWAP1 0B85 96 SWAP7 0B86 01 ADD 0B87 95 SWAP6 0B88 91 SWAP2 0B89 50 POP 0B8A 60 PUSH1 0x01 0B8C 01 ADD 0B8D 61 PUSH2 0x0b64 0B90 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0B87 stack[-7] = 0x20 + stack[-7] // @0B88 stack[-3] = stack[-1] // @0B8C stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x0b64 label_0B91: // Incoming jump from 0x0B6C, if !(0x00 < stack[-2]) // Incoming jump from 0x0B6C, if !(stack[-1] < stack[-3]) // Inputs[3] // { // @0B93 stack[-6] // @0B93 stack[-2] // @0B94 stack[-7] // } 0B91 5B JUMPDEST 0B92 50 POP 0B93 93 SWAP4 0B94 94 SWAP5 0B95 93 SWAP4 0B96 50 POP 0B97 50 POP 0B98 50 POP 0B99 50 POP 0B9A 56 *JUMP // Stack delta = -6 // Outputs[1] { @0B94 stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_0B9B: // Incoming call from 0x0D03, returns to 0x0A25 // Inputs[1] { @0BA1 stack[-1] } 0B9B 5B JUMPDEST 0B9C 60 PUSH1 0x00 0B9E 61 PUSH2 0x0ba6 0BA1 82 DUP3 0BA2 61 PUSH2 0x0d88 0BA5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B9C stack[0] = 0x00 // @0B9E stack[1] = 0x0ba6 // @0BA1 stack[2] = stack[-1] // } // Block ends with call to 0x0d88, returns to 0x0BA6 label_0BA6: // Incoming return from call to 0x0D88 at 0x0BA5 // Inputs[3] // { // @0BA7 stack[-1] // @0BA8 stack[-4] // @0BBA stack[-3] // } 0BA6 5B JUMPDEST 0BA7 80 DUP1 0BA8 84 DUP5 0BA9 52 MSTORE 0BAA 60 PUSH1 0x20 0BAC 84 DUP5 0BAD 01 ADD 0BAE 93 SWAP4 0BAF 50 POP 0BB0 83 DUP4 0BB1 60 PUSH1 0x20 0BB3 82 DUP3 0BB4 02 MUL 0BB5 85 DUP6 0BB6 01 ADD 0BB7 61 PUSH2 0x0bbf 0BBA 85 DUP6 0BBB 61 PUSH2 0x0d82 0BBE 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0BA9 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @0BAE stack[-4] = stack[-4] + 0x20 // @0BB0 stack[0] = stack[-4] + 0x20 // @0BB6 stack[1] = stack[-4] + 0x20 + stack[-1] * 0x20 // @0BB7 stack[2] = 0x0bbf // @0BBA stack[3] = stack[-3] // } // Block ends with call to 0x0d82, returns to 0x0BBF label_0BBF: // Incoming return from call to 0x0D82 at 0x0BBE // Inputs[1] { @0BC3 stack[-4] } 0BBF 5B JUMPDEST 0BC0 60 PUSH1 0x00 0BC2 5B JUMPDEST 0BC3 84 DUP5 0BC4 81 DUP2 0BC5 10 LT 0BC6 15 ISZERO 0BC7 61 PUSH2 0x0bf6 0BCA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BC0 stack[0] = 0x00 } // Block ends with conditional jump to 0x0bf6, if !(0x00 < stack[-4]) label_0BCB: // Incoming jump from 0x0BCA, if not !(stack[-1] < stack[-5]) // Incoming jump from 0x0BCA, if not !(0x00 < stack[-4]) // Inputs[5] // { // @0BCB stack[-4] // @0BCC stack[-3] // @0BCE stack[-8] // @0BD4 stack[-2] // @0BD5 memory[stack[-2]:stack[-2] + 0x20] // } 0BCB 83 DUP4 0BCC 83 DUP4 0BCD 03 SUB 0BCE 88 DUP9 0BCF 52 MSTORE 0BD0 61 PUSH2 0x0bda 0BD3 83 DUP4 0BD4 83 DUP4 0BD5 51 MLOAD 0BD6 61 PUSH2 0x0c0b 0BD9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0BCF memory[stack[-8]:stack[-8] + 0x20] = stack[-3] - stack[-4] // @0BD0 stack[0] = 0x0bda // @0BD3 stack[1] = stack[-3] // @0BD5 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x0c0b, returns to 0x0BDA label_0BDA: // Incoming return from call to 0x0C0B at 0x0BD9 // Inputs[3] // { // @0BDB stack[-1] // @0BDB stack[-4] // @0BE0 stack[-3] // } 0BDA 5B JUMPDEST 0BDB 92 SWAP3 0BDC 50 POP 0BDD 61 PUSH2 0x0be5 0BE0 82 DUP3 0BE1 61 PUSH2 0x0d82 0BE4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0BDB stack[-4] = stack[-1] // @0BDD stack[-1] = 0x0be5 // @0BE0 stack[0] = stack[-3] // } // Block ends with call to 0x0d82, returns to 0x0BE5 label_0BE5: // Incoming return from call to 0x0D82 at 0x0BE4 // Inputs[4] // { // @0BE8 stack[-9] // @0BE9 stack[-1] // @0BED stack[-3] // @0BF1 stack[-2] // } 0BE5 5B JUMPDEST 0BE6 60 PUSH1 0x20 0BE8 98 SWAP9 0BE9 90 SWAP1 0BEA 98 SWAP9 0BEB 01 ADD 0BEC 97 SWAP8 0BED 91 SWAP2 0BEE 50 POP 0BEF 60 PUSH1 0x01 0BF1 01 ADD 0BF2 61 PUSH2 0x0bc2 0BF5 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0BEC stack[-9] = 0x20 + stack[-9] // @0BED stack[-3] = stack[-1] // @0BF1 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x0bc2 label_0BF6: // Incoming jump from 0x0BCA, if !(stack[-1] < stack[-5]) // Incoming jump from 0x0BCA, if !(0x00 < stack[-4]) // Inputs[4] // { // @0BF8 stack[-2] // @0BF8 stack[-3] // @0BF9 stack[-9] // @0BFA stack[-8] // } 0BF6 5B JUMPDEST 0BF7 50 POP 0BF8 90 SWAP1 0BF9 96 SWAP7 0BFA 95 SWAP6 0BFB 50 POP 0BFC 50 POP 0BFD 50 POP 0BFE 50 POP 0BFF 50 POP 0C00 50 POP 0C01 56 *JUMP // Stack delta = -8 // Outputs[1] { @0BF9 stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_0C02: // Incoming jump from 0x0D11 // Inputs[1] { @0C06 stack[-1] } 0C02 5B JUMPDEST 0C03 61 PUSH2 0x0b3e 0C06 81 DUP2 0C07 61 PUSH2 0x0d98 0C0A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C03 stack[0] = 0x0b3e // @0C06 stack[1] = stack[-1] // } // Block ends with call to 0x0d98, returns to 0x0B3E label_0C0B: // Incoming call from 0x0BD9, returns to 0x0BDA // Incoming call from 0x0D22, returns to 0x0A25 // Inputs[1] { @0C11 stack[-1] } 0C0B 5B JUMPDEST 0C0C 60 PUSH1 0x00 0C0E 61 PUSH2 0x0c16 0C11 82 DUP3 0C12 61 PUSH2 0x0d88 0C15 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C0C stack[0] = 0x00 // @0C0E stack[1] = 0x0c16 // @0C11 stack[2] = stack[-1] // } // Block ends with call to 0x0d88, returns to 0x0C16 label_0C16: // Incoming return from call to 0x0D88 at 0x0C15 // Inputs[3] // { // @0C17 stack[-1] // @0C18 stack[-4] // @0C24 stack[-3] // } 0C16 5B JUMPDEST 0C17 80 DUP1 0C18 84 DUP5 0C19 52 MSTORE 0C1A 61 PUSH2 0x0c2a 0C1D 81 DUP2 0C1E 60 PUSH1 0x20 0C20 86 DUP7 0C21 01 ADD 0C22 60 PUSH1 0x20 0C24 86 DUP7 0C25 01 ADD 0C26 61 PUSH2 0x0da9 0C29 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0C19 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @0C1A stack[0] = 0x0c2a // @0C1D stack[1] = stack[-1] // @0C21 stack[2] = stack[-4] + 0x20 // @0C25 stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x0da9, returns to 0x0C2A label_0C2A: // Incoming return from call to 0x0DA9 at 0x0C29 // Inputs[1] { @0C2E stack[-1] } 0C2A 5B JUMPDEST 0C2B 61 PUSH2 0x0c33 0C2E 81 DUP2 0C2F 61 PUSH2 0x0dd9 0C32 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C2B stack[0] = 0x0c33 // @0C2E stack[1] = stack[-1] // } // Block ends with call to 0x0dd9, returns to 0x0C33 label_0C33: // Incoming return from call to 0x0DD9 at 0x0C32 // Inputs[4] // { // @0C34 stack[-1] // @0C34 stack[-2] // @0C35 stack[-5] // @0C3A stack[-6] // } 0C33 5B JUMPDEST 0C34 90 SWAP1 0C35 93 SWAP4 0C36 01 ADD 0C37 60 PUSH1 0x20 0C39 01 ADD 0C3A 93 SWAP4 0C3B 92 SWAP3 0C3C 50 POP 0C3D 50 POP 0C3E 50 POP 0C3F 56 *JUMP // Stack delta = -5 // Outputs[1] { @0C3A stack[-6] = 0x20 + stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_0C40: // Incoming call from 0x0D32, returns to 0x0CAD // Inputs[2] // { // @0C43 stack[-1] // @0C94 stack[-2] // } 0C40 5B JUMPDEST 0C41 60 PUSH1 0x22 0C43 81 DUP2 0C44 52 MSTORE 0C45 7F PUSH32 0x74686174207761736e277420766572792063617368206d6f6e6579206f662079 0C66 60 PUSH1 0x20 0C68 82 DUP3 0C69 01 ADD 0C6A 52 MSTORE 0C6B 7F PUSH32 0x6f75000000000000000000000000000000000000000000000000000000000000 0C8C 60 PUSH1 0x40 0C8E 82 DUP3 0C8F 01 ADD 0C90 52 MSTORE 0C91 60 PUSH1 0x60 0C93 01 ADD 0C94 90 SWAP1 0C95 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0C44 memory[stack[-1]:stack[-1] + 0x20] = 0x22 // @0C6A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x74686174207761736e277420766572792063617368206d6f6e6579206f662079 // @0C90 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x6f75000000000000000000000000000000000000000000000000000000000000 // @0C94 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 0C96 5B JUMPDEST 0C97 61 PUSH2 0x0b3e 0C9A 81 DUP2 0C9B 61 PUSH2 0x02be 0C9E 56 *JUMP label_0C9F: // Incoming call from 0x0136, returns to 0x00BF // Inputs[2] // { // @0CA2 stack[-1] // @0CA8 stack[-2] // } 0C9F 5B JUMPDEST 0CA0 60 PUSH1 0x20 0CA2 81 DUP2 0CA3 01 ADD 0CA4 61 PUSH2 0x0cad 0CA7 82 DUP3 0CA8 84 DUP5 0CA9 61 PUSH2 0x0b35 0CAC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CA3 stack[0] = stack[-1] + 0x20 // @0CA4 stack[1] = 0x0cad // @0CA7 stack[2] = stack[-1] // @0CA8 stack[3] = stack[-2] // } // Block ends with call to 0x0b35, returns to 0x0CAD label_0CAD: // Incoming return from call to 0x0B35 at 0x0CAC // Incoming return from call to 0x0C40 at 0x0D32 // Inputs[3] // { // @0CAE stack[-4] // @0CAE stack[-1] // @0CAF stack[-3] // } 0CAD 5B JUMPDEST 0CAE 92 SWAP3 0CAF 91 SWAP2 0CB0 50 POP 0CB1 50 POP 0CB2 56 *JUMP // Stack delta = -3 // Outputs[1] { @0CAE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 0CB3 5B JUMPDEST 0CB4 60 PUSH1 0x60 0CB6 81 DUP2 0CB7 01 ADD 0CB8 61 PUSH2 0x0cc1 0CBB 82 DUP3 0CBC 86 DUP7 0CBD 61 PUSH2 0x0b35 0CC0 56 *JUMP 0CC1 5B JUMPDEST 0CC2 81 DUP2 0CC3 81 DUP2 0CC4 03 SUB 0CC5 60 PUSH1 0x20 0CC7 83 DUP4 0CC8 01 ADD 0CC9 52 MSTORE 0CCA 61 PUSH2 0x0cd3 0CCD 81 DUP2 0CCE 85 DUP6 0CCF 61 PUSH2 0x0c0b 0CD2 56 *JUMP 0CD3 5B JUMPDEST 0CD4 90 SWAP1 0CD5 50 POP 0CD6 61 PUSH2 0x0aaa 0CD9 60 PUSH1 0x40 0CDB 83 DUP4 0CDC 01 ADD 0CDD 84 DUP5 0CDE 61 PUSH2 0x0c96 0CE1 56 *JUMP label_0CE2: // Incoming jump from 0x01BA // Inputs[2] // { // @0CE6 stack[-1] // @0CEE stack[-2] // } 0CE2 5B JUMPDEST 0CE3 60 PUSH1 0x20 0CE5 80 DUP1 0CE6 82 DUP3 0CE7 52 MSTORE 0CE8 81 DUP2 0CE9 01 ADD 0CEA 61 PUSH2 0x0a25 0CED 81 DUP2 0CEE 84 DUP5 0CEF 61 PUSH2 0x0b44 0CF2 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0CE7 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0CE9 stack[0] = stack[-1] + 0x20 // @0CEA stack[1] = 0x0a25 // @0CED stack[2] = stack[-1] + 0x20 // @0CEE stack[3] = stack[-2] // } // Block ends with call to 0x0b44, returns to 0x0A25 label_0CF3: // Incoming jump from 0x00BE // Inputs[2] // { // @0CF7 stack[-1] // @0CFF stack[-2] // } 0CF3 5B JUMPDEST 0CF4 60 PUSH1 0x20 0CF6 80 DUP1 0CF7 82 DUP3 0CF8 52 MSTORE 0CF9 81 DUP2 0CFA 01 ADD 0CFB 61 PUSH2 0x0a25 0CFE 81 DUP2 0CFF 84 DUP5 0D00 61 PUSH2 0x0b9b 0D03 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0CF8 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0CFA stack[0] = stack[-1] + 0x20 // @0CFB stack[1] = 0x0a25 // @0CFE stack[2] = stack[-1] + 0x20 // @0CFF stack[3] = stack[-2] // } // Block ends with call to 0x0b9b, returns to 0x0A25 label_0D04: // Incoming jump from 0x0178 // Inputs[2] // { // @0D07 stack[-1] // @0D0D stack[-2] // } 0D04 5B JUMPDEST 0D05 60 PUSH1 0x20 0D07 81 DUP2 0D08 01 ADD 0D09 61 PUSH2 0x0cad 0D0C 82 DUP3 0D0D 84 DUP5 0D0E 61 PUSH2 0x0c02 0D11 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D08 stack[0] = stack[-1] + 0x20 // @0D09 stack[1] = 0x0cad // @0D0C stack[2] = stack[-1] // @0D0D stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0c02 label_0D12: // Incoming jump from 0x01E7 // Inputs[2] // { // @0D16 stack[-1] // @0D1E stack[-2] // } 0D12 5B JUMPDEST 0D13 60 PUSH1 0x20 0D15 80 DUP1 0D16 82 DUP3 0D17 52 MSTORE 0D18 81 DUP2 0D19 01 ADD 0D1A 61 PUSH2 0x0a25 0D1D 81 DUP2 0D1E 84 DUP5 0D1F 61 PUSH2 0x0c0b 0D22 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0D17 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0D19 stack[0] = stack[-1] + 0x20 // @0D1A stack[1] = 0x0a25 // @0D1D stack[2] = stack[-1] + 0x20 // @0D1E stack[3] = stack[-2] // } // Block ends with call to 0x0c0b, returns to 0x0A25 label_0D23: // Incoming jump from 0x0654 // Incoming jump from 0x03A7 // Inputs[1] { @0D27 stack[-1] } 0D23 5B JUMPDEST 0D24 60 PUSH1 0x20 0D26 80 DUP1 0D27 82 DUP3 0D28 52 MSTORE 0D29 81 DUP2 0D2A 01 ADD 0D2B 61 PUSH2 0x0cad 0D2E 81 DUP2 0D2F 61 PUSH2 0x0c40 0D32 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0D28 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0D2A stack[0] = stack[-1] + 0x20 // @0D2B stack[1] = 0x0cad // @0D2E stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x0c40, returns to 0x0CAD label_0D33: // Incoming jump from 0x0A4F // Inputs[2] // { // @0D36 memory[0x40:0x60] // @0D37 stack[-1] // } 0D33 5B JUMPDEST 0D34 60 PUSH1 0x40 0D36 51 MLOAD 0D37 81 DUP2 0D38 81 DUP2 0D39 01 ADD 0D3A 67 PUSH8 0xffffffffffffffff 0D43 81 DUP2 0D44 11 GT 0D45 82 DUP3 0D46 82 DUP3 0D47 10 LT 0D48 17 OR 0D49 15 ISZERO 0D4A 61 PUSH2 0x0d52 0D4D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D36 stack[0] = memory[0x40:0x60] // @0D39 stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x0d52, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) label_0D4E: // Incoming jump from 0x0D4D, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[1] { @0D51 memory[0x00:0x00] } 0D4E 60 PUSH1 0x00 0D50 80 DUP1 0D51 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D51 revert(memory[0x00:0x00]); } // Block terminates label_0D52: // Incoming jump from 0x0D4D, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[4] // { // @0D55 stack[-1] // @0D56 stack[-2] // @0D56 stack[-4] // @0D57 stack[-3] // } 0D52 5B JUMPDEST 0D53 60 PUSH1 0x40 0D55 52 MSTORE 0D56 91 SWAP2 0D57 90 SWAP1 0D58 50 POP 0D59 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0D55 memory[0x40:0x60] = stack[-1] // @0D56 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_0D5A: // Incoming call from 0x0A4A, returns to 0x0A4B // Inputs[1] { @0D66 stack[-1] } 0D5A 5B JUMPDEST 0D5B 60 PUSH1 0x00 0D5D 67 PUSH8 0xffffffffffffffff 0D66 82 DUP3 0D67 11 GT 0D68 15 ISZERO 0D69 61 PUSH2 0x0d71 0D6C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D5B stack[0] = 0x00 } // Block ends with conditional jump to 0x0d71, if !(stack[-1] > 0xffffffffffffffff) label_0D6D: // Incoming jump from 0x0D6C, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @0D70 memory[0x00:0x00] } 0D6D 60 PUSH1 0x00 0D6F 80 DUP1 0D70 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D70 revert(memory[0x00:0x00]); } // Block terminates label_0D71: // Incoming jump from 0x0D6C, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0D77 stack[-2] // @0D80 stack[-3] // } 0D71 5B JUMPDEST 0D72 50 POP 0D73 60 PUSH1 0x20 0D75 60 PUSH1 0x1f 0D77 91 SWAP2 0D78 90 SWAP1 0D79 91 SWAP2 0D7A 01 ADD 0D7B 60 PUSH1 0x1f 0D7D 19 NOT 0D7E 16 AND 0D7F 01 ADD 0D80 90 SWAP1 0D81 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D80 stack[-3] = (~0x1f & 0x1f + stack[-2]) + 0x20 } // Block ends with unconditional jump to stack[-3] label_0D82: // Incoming call from 0x0BBE, returns to 0x0BBF // Incoming call from 0x0B60, returns to 0x0B61 // Incoming call from 0x0B7F, returns to 0x0B80 // Incoming call from 0x0BE4, returns to 0x0BE5 // Inputs[2] // { // @0D85 stack[-1] // @0D86 stack[-2] // } 0D82 5B JUMPDEST 0D83 60 PUSH1 0x20 0D85 01 ADD 0D86 90 SWAP1 0D87 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D86 stack[-2] = 0x20 + stack[-1] } // Block ends with unconditional jump to stack[-2] label_0D88: // Incoming call from 0x0B4E, returns to 0x0B4F // Incoming call from 0x0BA5, returns to 0x0BA6 // Incoming call from 0x0C15, returns to 0x0C16 // Inputs[3] // { // @0D89 stack[-1] // @0D89 memory[stack[-1]:stack[-1] + 0x20] // @0D8A stack[-2] // } 0D88 5B JUMPDEST 0D89 51 MLOAD 0D8A 90 SWAP1 0D8B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D8A stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_0D8C: // Incoming call from 0x0B3D, returns to 0x0B3E // Incoming call from 0x0A24, returns to 0x0A25 // Inputs[2] // { // @0D95 stack[-1] // @0D96 stack[-2] // } 0D8C 5B JUMPDEST 0D8D 60 PUSH1 0x01 0D8F 60 PUSH1 0xa0 0D91 60 PUSH1 0x02 0D93 0A EXP 0D94 03 SUB 0D95 16 AND 0D96 90 SWAP1 0D97 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D96 stack[-2] = 0x02 ** 0xa0 - 0x01 & stack[-1] } // Block ends with unconditional jump to stack[-2] label_0D98: // Incoming call from 0x0C0A, returns to 0x0B3E // Inputs[2] // { // @0D99 stack[-1] // @0D9B stack[-2] // } 0D98 5B JUMPDEST 0D99 15 ISZERO 0D9A 15 ISZERO 0D9B 90 SWAP1 0D9C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D9B stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0D9D: // Incoming call from 0x0A76, returns to 0x0A77 // Inputs[5] // { // @0D9E stack[-3] // @0D9F stack[-1] // @0DA0 stack[-2] // @0DA1 msg.data[stack[-1]:stack[-1] + stack[-3]] // @0DA8 stack[-4] // } 0D9D 5B JUMPDEST 0D9E 82 DUP3 0D9F 81 DUP2 0DA0 83 DUP4 0DA1 37 CALLDATACOPY 0DA2 50 POP 0DA3 60 PUSH1 0x00 0DA5 91 SWAP2 0DA6 01 ADD 0DA7 52 MSTORE 0DA8 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0DA1 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @0DA7 memory[stack[-3] + stack[-2]:stack[-3] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_0DA9: // Incoming call from 0x0C29, returns to 0x0C2A // Inputs[1] { @0DAD stack[-3] } 0DA9 5B JUMPDEST 0DAA 60 PUSH1 0x00 0DAC 5B JUMPDEST 0DAD 83 DUP4 0DAE 81 DUP2 0DAF 10 LT 0DB0 15 ISZERO 0DB1 61 PUSH2 0x0dc4 0DB4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DAA stack[0] = 0x00 } // Block ends with conditional jump to 0x0dc4, if !(0x00 < stack[-3]) label_0DB5: // Incoming jump from 0x0DB4, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0DB4, if not !(0x00 < stack[-3]) // Inputs[4] // { // @0DB5 stack[-2] // @0DB6 stack[-1] // @0DB8 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0DB9 stack[-3] // } 0DB5 81 DUP2 0DB6 81 DUP2 0DB7 01 ADD 0DB8 51 MLOAD 0DB9 83 DUP4 0DBA 82 DUP3 0DBB 01 ADD 0DBC 52 MSTORE 0DBD 60 PUSH1 0x20 0DBF 01 ADD 0DC0 61 PUSH2 0x0dac 0DC3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0DBC memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0DBF stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0dac label_0DC4: // Incoming jump from 0x0DB4, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0DB4, if !(0x00 < stack[-3]) // Inputs[2] // { // @0DC5 stack[-4] // @0DC6 stack[-1] // } 0DC4 5B JUMPDEST 0DC5 83 DUP4 0DC6 81 DUP2 0DC7 11 GT 0DC8 15 ISZERO 0DC9 61 PUSH2 0x0dd3 0DCC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dd3, if !(stack[-1] > stack[-4]) label_0DCD: // Incoming jump from 0x0DCC, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @0DCF stack[-4] // @0DD0 stack[-3] // @0DD8 stack[-5] // } 0DCD 60 PUSH1 0x00 0DCF 84 DUP5 0DD0 84 DUP5 0DD1 01 ADD 0DD2 52 MSTORE 0DD3 5B JUMPDEST 0DD4 50 POP 0DD5 50 POP 0DD6 50 POP 0DD7 50 POP 0DD8 56 *JUMP // Stack delta = -5 // Outputs[1] { @0DD2 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0DD9: // Incoming call from 0x0C32, returns to 0x0C33 // Inputs[2] // { // @0DDC stack[-1] // @0DE1 stack[-2] // } 0DD9 5B JUMPDEST 0DDA 60 PUSH1 0x1f 0DDC 01 ADD 0DDD 60 PUSH1 0x1f 0DDF 19 NOT 0DE0 16 AND 0DE1 90 SWAP1 0DE2 56 *JUMP // Stack delta = -1 // Outputs[1] { @0DE1 stack[-2] = ~0x1f & 0x1f + stack[-1] } // Block ends with unconditional jump to stack[-2] 0DE3 00 *STOP 0DE4 A2 LOG2 0DE5 65 PUSH6 0x627a7a723058 0DEC 20 SHA3 0DED 7D PUSH30 0xac21b23e9c3edeeacc729a73196e5c52acead4a7d0462ebf35a8fb0406a2 0E0C 8B DUP12 0E0D 6C PUSH13 0x6578706572696d656e74616cf5 0E1B 00 *STOP 0E1C 37 CALLDATACOPY