Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0154 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0154, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 003B 90 SWAP1 003C 04 DIV 003D 80 DUP1 003E 63 PUSH4 0x4f6ccce7 0043 11 GT 0044 61 PUSH2 0x00d5 0047 57 *JUMPI // Stack delta = +1 // Outputs[1] { @003C stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x00d5, if 0x4f6ccce7 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0048: // Incoming jump from 0x0047, if not 0x4f6ccce7 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0048 stack[-1] } 0048 80 DUP1 0049 63 PUSH4 0x98650275 004E 11 GT 004F 61 PUSH2 0x0099 0052 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0099, if 0x98650275 > stack[-1] label_0053: // Incoming jump from 0x0052, if not 0x98650275 > stack[-1] // Inputs[1] { @0053 stack[-1] } 0053 80 DUP1 0054 63 PUSH4 0x98650275 0059 14 EQ 005A 61 PUSH2 0x0749 005D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0749, if 0x98650275 == stack[-1] label_005E: // Incoming jump from 0x005D, if not 0x98650275 == stack[-1] // Inputs[1] { @005E stack[-1] } 005E 80 DUP1 005F 63 PUSH4 0xa22cb465 0064 14 EQ 0065 61 PUSH2 0x0753 0068 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0753, if 0xa22cb465 == stack[-1] label_0069: // Incoming jump from 0x0068, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0069 stack[-1] } 0069 80 DUP1 006A 63 PUSH4 0xaa271e1a 006F 14 EQ 0070 61 PUSH2 0x07a3 0073 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a3, if 0xaa271e1a == stack[-1] label_0074: // Incoming jump from 0x0073, if not 0xaa271e1a == stack[-1] // Inputs[1] { @0074 stack[-1] } 0074 80 DUP1 0075 63 PUSH4 0xb88d4fde 007A 14 EQ 007B 61 PUSH2 0x07ff 007E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ff, if 0xb88d4fde == stack[-1] label_007F: // Incoming jump from 0x007E, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007F stack[-1] } 007F 80 DUP1 0080 63 PUSH4 0xc87b56dd 0085 14 EQ 0086 61 PUSH2 0x0904 0089 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0904, if 0xc87b56dd == stack[-1] label_008A: // Incoming jump from 0x0089, if not 0xc87b56dd == stack[-1] // Inputs[1] { @008A stack[-1] } 008A 80 DUP1 008B 63 PUSH4 0xe985e9c5 0090 14 EQ 0091 61 PUSH2 0x09ab 0094 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ab, if 0xe985e9c5 == stack[-1] label_0095: // Incoming jump from 0x0094, if not 0xe985e9c5 == stack[-1] 0095 61 PUSH2 0x0154 0098 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0154 label_0099: // Incoming jump from 0x0052, if 0x98650275 > stack[-1] // Inputs[1] { @009A stack[-1] } 0099 5B JUMPDEST 009A 80 DUP1 009B 63 PUSH4 0x4f6ccce7 00A0 14 EQ 00A1 61 PUSH2 0x057a 00A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x057a, if 0x4f6ccce7 == stack[-1] label_00A5: // Incoming jump from 0x00A4, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @00A5 stack[-1] } 00A5 80 DUP1 00A6 63 PUSH4 0x6352211e 00AB 14 EQ 00AC 61 PUSH2 0x05bc 00AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bc, if 0x6352211e == stack[-1] label_00B0: // Incoming jump from 0x00AF, if not 0x6352211e == stack[-1] // Inputs[1] { @00B0 stack[-1] } 00B0 80 DUP1 00B1 63 PUSH4 0x70a08231 00B6 14 EQ 00B7 61 PUSH2 0x062a 00BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062a, if 0x70a08231 == stack[-1] label_00BB: // Incoming jump from 0x00BA, if not 0x70a08231 == stack[-1] // Inputs[1] { @00BB stack[-1] } 00BB 80 DUP1 00BC 63 PUSH4 0x95d89b41 00C1 14 EQ 00C2 61 PUSH2 0x0682 00C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0682, if 0x95d89b41 == stack[-1] label_00C6: // Incoming jump from 0x00C5, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C6 stack[-1] } 00C6 80 DUP1 00C7 63 PUSH4 0x983b2d56 00CC 14 EQ 00CD 61 PUSH2 0x0705 00D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0705, if 0x983b2d56 == stack[-1] label_00D1: // Incoming jump from 0x00D0, if not 0x983b2d56 == stack[-1] 00D1 61 PUSH2 0x0154 00D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0154 label_00D5: // Incoming jump from 0x0047, if 0x4f6ccce7 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @00D6 stack[-1] } 00D5 5B JUMPDEST 00D6 80 DUP1 00D7 63 PUSH4 0x23b872dd 00DC 11 GT 00DD 61 PUSH2 0x011c 00E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011c, if 0x23b872dd > stack[-1] label_00E1: // Incoming jump from 0x00E0, if not 0x23b872dd > stack[-1] // Inputs[1] { @00E1 stack[-1] } 00E1 80 DUP1 00E2 63 PUSH4 0x23b872dd 00E7 14 EQ 00E8 61 PUSH2 0x031b 00EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031b, if 0x23b872dd == stack[-1] label_00EC: // Incoming jump from 0x00EB, if not 0x23b872dd == stack[-1] // Inputs[1] { @00EC stack[-1] } 00EC 80 DUP1 00ED 63 PUSH4 0x2f745c59 00F2 14 EQ 00F3 61 PUSH2 0x0389 00F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0389, if 0x2f745c59 == stack[-1] label_00F7: // Incoming jump from 0x00F6, if not 0x2f745c59 == stack[-1] // Inputs[1] { @00F7 stack[-1] } 00F7 80 DUP1 00F8 63 PUSH4 0x42842e0e 00FD 14 EQ 00FE 61 PUSH2 0x03eb 0101 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03eb, if 0x42842e0e == stack[-1] label_0102: // Incoming jump from 0x0101, if not 0x42842e0e == stack[-1] // Inputs[1] { @0102 stack[-1] } 0102 80 DUP1 0103 63 PUSH4 0x42966c68 0108 14 EQ 0109 61 PUSH2 0x0459 010C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0459, if 0x42966c68 == stack[-1] label_010D: // Incoming jump from 0x010C, if not 0x42966c68 == stack[-1] // Inputs[1] { @010D stack[-1] } 010D 80 DUP1 010E 63 PUSH4 0x45c17782 0113 14 EQ 0114 61 PUSH2 0x0487 0117 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0487, if 0x45c17782 == stack[-1] label_0118: // Incoming jump from 0x0117, if not 0x45c17782 == stack[-1] 0118 61 PUSH2 0x0154 011B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0154 label_011C: // Incoming jump from 0x00E0, if 0x23b872dd > stack[-1] // Inputs[1] { @011D stack[-1] } 011C 5B JUMPDEST 011D 80 DUP1 011E 63 PUSH4 0x01ffc9a7 0123 14 EQ 0124 61 PUSH2 0x0159 0127 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0159, if 0x01ffc9a7 == stack[-1] label_0128: // Incoming jump from 0x0127, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0128 stack[-1] } 0128 80 DUP1 0129 63 PUSH4 0x06fdde03 012E 14 EQ 012F 61 PUSH2 0x01be 0132 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01be, if 0x06fdde03 == stack[-1] label_0133: // Incoming jump from 0x0132, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0133 stack[-1] } 0133 80 DUP1 0134 63 PUSH4 0x081812fc 0139 14 EQ 013A 61 PUSH2 0x0241 013D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0241, if 0x081812fc == stack[-1] label_013E: // Incoming jump from 0x013D, if not 0x081812fc == stack[-1] // Inputs[1] { @013E stack[-1] } 013E 80 DUP1 013F 63 PUSH4 0x095ea7b3 0144 14 EQ 0145 61 PUSH2 0x02af 0148 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02af, if 0x095ea7b3 == stack[-1] label_0149: // Incoming jump from 0x0148, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0149 stack[-1] } 0149 80 DUP1 014A 63 PUSH4 0x18160ddd 014F 14 EQ 0150 61 PUSH2 0x02fd 0153 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fd, if 0x18160ddd == stack[-1] label_0154: // Incoming jump from 0x0098 // Incoming jump from 0x00D4 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x011B // Incoming jump from 0x0153, if not 0x18160ddd == stack[-1] // Inputs[1] { @0158 memory[0x00:0x00] } 0154 5B JUMPDEST 0155 60 PUSH1 0x00 0157 80 DUP1 0158 FD *REVERT // Stack delta = +0 // Outputs[1] { @0158 revert(memory[0x00:0x00]); } // Block terminates label_0159: // Incoming jump from 0x0127, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0160 msg.data.length } 0159 5B JUMPDEST 015A 61 PUSH2 0x01a4 015D 60 PUSH1 0x04 015F 80 DUP1 0160 36 CALLDATASIZE 0161 03 SUB 0162 60 PUSH1 0x20 0164 81 DUP2 0165 10 LT 0166 15 ISZERO 0167 61 PUSH2 0x016f 016A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @015A stack[0] = 0x01a4 // @015D stack[1] = 0x04 // @0161 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x016f, returns to 0x01A4, if !(msg.data.length - 0x04 < 0x20) label_016B: // Incoming jump from 0x016A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @016E memory[0x00:0x00] } 016B 60 PUSH1 0x00 016D 80 DUP1 016E FD *REVERT // Stack delta = +0 // Outputs[1] { @016E revert(memory[0x00:0x00]); } // Block terminates label_016F: // Incoming call from 0x016A, returns to 0x01A4, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0170 stack[-2] // @0171 stack[-1] // @0175 msg.data[stack[-2]:stack[-2] + 0x20] // } 016F 5B JUMPDEST 0170 81 DUP2 0171 01 ADD 0172 90 SWAP1 0173 80 DUP1 0174 80 DUP1 0175 35 CALLDATALOAD 0176 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0193 19 NOT 0194 16 AND 0195 90 SWAP1 0196 60 PUSH1 0x20 0198 01 ADD 0199 90 SWAP1 019A 92 SWAP3 019B 91 SWAP2 019C 90 SWAP1 019D 50 POP 019E 50 POP 019F 50 POP 01A0 61 PUSH2 0x0a27 01A3 56 *JUMP // Stack delta = -1 // Outputs[1] { @019A stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0a27 label_01A4: // Incoming return from call to 0x016F at 0x016A // Inputs[4] // { // @01A7 memory[0x40:0x60] // @01A9 stack[-1] // @01B8 memory[0x40:0x60] // @01BD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01A4 5B JUMPDEST 01A5 60 PUSH1 0x40 01A7 51 MLOAD 01A8 80 DUP1 01A9 82 DUP3 01AA 15 ISZERO 01AB 15 ISZERO 01AC 15 ISZERO 01AD 15 ISZERO 01AE 81 DUP2 01AF 52 MSTORE 01B0 60 PUSH1 0x20 01B2 01 ADD 01B3 91 SWAP2 01B4 50 POP 01B5 50 POP 01B6 60 PUSH1 0x40 01B8 51 MLOAD 01B9 80 DUP1 01BA 91 SWAP2 01BB 03 SUB 01BC 90 SWAP1 01BD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @01BD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01BE: // Incoming jump from 0x0132, if 0x06fdde03 == stack[-1] 01BE 5B JUMPDEST 01BF 61 PUSH2 0x01c6 01C2 61 PUSH2 0x0a8e 01C5 56 *JUMP // Stack delta = +1 // Outputs[1] { @01BF stack[0] = 0x01c6 } // Block ends with call to 0x0a8e, returns to 0x01C6 label_01C6: // Incoming return from call to 0x0A8E at 0x01C5 // Inputs[4] // { // @01C9 memory[0x40:0x60] // @01D4 stack[-1] // @01D7 memory[stack[-1]:stack[-1] + 0x20] // @01E0 memory[stack[-1]:stack[-1] + 0x20] // } 01C6 5B JUMPDEST 01C7 60 PUSH1 0x40 01C9 51 MLOAD 01CA 80 DUP1 01CB 80 DUP1 01CC 60 PUSH1 0x20 01CE 01 ADD 01CF 82 DUP3 01D0 81 DUP2 01D1 03 SUB 01D2 82 DUP3 01D3 52 MSTORE 01D4 83 DUP4 01D5 81 DUP2 01D6 81 DUP2 01D7 51 MLOAD 01D8 81 DUP2 01D9 52 MSTORE 01DA 60 PUSH1 0x20 01DC 01 ADD 01DD 91 SWAP2 01DE 50 POP 01DF 80 DUP1 01E0 51 MLOAD 01E1 90 SWAP1 01E2 60 PUSH1 0x20 01E4 01 ADD 01E5 90 SWAP1 01E6 80 DUP1 01E7 83 DUP4 01E8 83 DUP4 01E9 60 PUSH1 0x00 01EB 5B JUMPDEST 01EC 83 DUP4 01ED 81 DUP2 01EE 10 LT 01EF 15 ISZERO 01F0 61 PUSH2 0x0206 01F3 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01C9 stack[0] = memory[0x40:0x60] // @01CA stack[1] = memory[0x40:0x60] // @01D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @01D9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @01DD stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @01E5 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @01E5 stack[3] = 0x20 + stack[-1] // @01E6 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @01E7 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @01E8 stack[7] = 0x20 + stack[-1] // @01E9 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0206, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_01F4: // Incoming jump from 0x01F3, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x01F3, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @01F4 stack[-1] // @01F5 stack[-2] // @01F7 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01F9 stack[-3] // } 01F4 80 DUP1 01F5 82 DUP3 01F6 01 ADD 01F7 51 MLOAD 01F8 81 DUP2 01F9 84 DUP5 01FA 01 ADD 01FB 52 MSTORE 01FC 60 PUSH1 0x20 01FE 81 DUP2 01FF 01 ADD 0200 90 SWAP1 0201 50 POP 0202 61 PUSH2 0x01eb 0205 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01FB memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0200 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x01eb label_0206: // Incoming jump from 0x01F3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x01F3, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @020B stack[-6] // @020B stack[-5] // @020D stack[-7] // } 0206 5B JUMPDEST 0207 50 POP 0208 50 POP 0209 50 POP 020A 50 POP 020B 90 SWAP1 020C 50 POP 020D 90 SWAP1 020E 81 DUP2 020F 01 ADD 0210 90 SWAP1 0211 60 PUSH1 0x1f 0213 16 AND 0214 80 DUP1 0215 15 ISZERO 0216 61 PUSH2 0x0233 0219 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0210 stack[-7] = stack[-5] + stack[-7] // @0213 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0233, if !(0x1f & stack[-5]) label_021A: // Incoming jump from 0x0219, if not !(0x1f & stack[-5]) // Inputs[6] // { // @021A stack[-1] // @021B stack[-2] // @021E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0235 stack[-5] // @023B memory[0x40:0x60] // @0240 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 021A 80 DUP1 021B 82 DUP3 021C 03 SUB 021D 80 DUP1 021E 51 MLOAD 021F 60 PUSH1 0x01 0221 83 DUP4 0222 60 PUSH1 0x20 0224 03 SUB 0225 61 PUSH2 0x0100 0228 0A EXP 0229 03 SUB 022A 19 NOT 022B 16 AND 022C 81 DUP2 022D 52 MSTORE 022E 60 PUSH1 0x20 0230 01 ADD 0231 91 SWAP2 0232 50 POP 0233 5B JUMPDEST 0234 50 POP 0235 92 SWAP3 0236 50 POP 0237 50 POP 0238 50 POP 0239 60 PUSH1 0x40 023B 51 MLOAD 023C 80 DUP1 023D 91 SWAP2 023E 03 SUB 023F 90 SWAP1 0240 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @022D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0240 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0241: // Incoming jump from 0x013D, if 0x081812fc == stack[-1] // Inputs[1] { @0248 msg.data.length } 0241 5B JUMPDEST 0242 61 PUSH2 0x026d 0245 60 PUSH1 0x04 0247 80 DUP1 0248 36 CALLDATASIZE 0249 03 SUB 024A 60 PUSH1 0x20 024C 81 DUP2 024D 10 LT 024E 15 ISZERO 024F 61 PUSH2 0x0257 0252 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0242 stack[0] = 0x026d // @0245 stack[1] = 0x04 // @0249 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0257, returns to 0x026D, if !(msg.data.length - 0x04 < 0x20) label_0253: // Incoming jump from 0x0252, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0256 memory[0x00:0x00] } 0253 60 PUSH1 0x00 0255 80 DUP1 0256 FD *REVERT // Stack delta = +0 // Outputs[1] { @0256 revert(memory[0x00:0x00]); } // Block terminates label_0257: // Incoming call from 0x0252, returns to 0x026D, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0258 stack[-2] // @0259 stack[-1] // @025D msg.data[stack[-2]:stack[-2] + 0x20] // } 0257 5B JUMPDEST 0258 81 DUP2 0259 01 ADD 025A 90 SWAP1 025B 80 DUP1 025C 80 DUP1 025D 35 CALLDATALOAD 025E 90 SWAP1 025F 60 PUSH1 0x20 0261 01 ADD 0262 90 SWAP1 0263 92 SWAP3 0264 91 SWAP2 0265 90 SWAP1 0266 50 POP 0267 50 POP 0268 50 POP 0269 61 PUSH2 0x0b30 026C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0263 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0b30 label_026D: // Incoming return from call to 0x0257 at 0x0252 // Inputs[4] // { // @0270 memory[0x40:0x60] // @0272 stack[-1] // @02A9 memory[0x40:0x60] // @02AE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 026D 5B JUMPDEST 026E 60 PUSH1 0x40 0270 51 MLOAD 0271 80 DUP1 0272 82 DUP3 0273 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0288 16 AND 0289 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 029E 16 AND 029F 81 DUP2 02A0 52 MSTORE 02A1 60 PUSH1 0x20 02A3 01 ADD 02A4 91 SWAP2 02A5 50 POP 02A6 50 POP 02A7 60 PUSH1 0x40 02A9 51 MLOAD 02AA 80 DUP1 02AB 91 SWAP2 02AC 03 SUB 02AD 90 SWAP1 02AE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @02AE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02AF: // Incoming jump from 0x0148, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02B6 msg.data.length } 02AF 5B JUMPDEST 02B0 61 PUSH2 0x02fb 02B3 60 PUSH1 0x04 02B5 80 DUP1 02B6 36 CALLDATASIZE 02B7 03 SUB 02B8 60 PUSH1 0x40 02BA 81 DUP2 02BB 10 LT 02BC 15 ISZERO 02BD 61 PUSH2 0x02c5 02C0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02B0 stack[0] = 0x02fb // @02B3 stack[1] = 0x04 // @02B7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02c5, returns to 0x02FB, if !(msg.data.length - 0x04 < 0x40) label_02C1: // Incoming jump from 0x02C0, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @02C4 memory[0x00:0x00] } 02C1 60 PUSH1 0x00 02C3 80 DUP1 02C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C4 revert(memory[0x00:0x00]); } // Block terminates label_02C5: // Incoming call from 0x02C0, returns to 0x02FB, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @02C6 stack[-2] // @02C7 stack[-1] // @02CB msg.data[stack[-2]:stack[-2] + 0x20] // @02EB msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 02C5 5B JUMPDEST 02C6 81 DUP2 02C7 01 ADD 02C8 90 SWAP1 02C9 80 DUP1 02CA 80 DUP1 02CB 35 CALLDATALOAD 02CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02E1 16 AND 02E2 90 SWAP1 02E3 60 PUSH1 0x20 02E5 01 ADD 02E6 90 SWAP1 02E7 92 SWAP3 02E8 91 SWAP2 02E9 90 SWAP1 02EA 80 DUP1 02EB 35 CALLDATALOAD 02EC 90 SWAP1 02ED 60 PUSH1 0x20 02EF 01 ADD 02F0 90 SWAP1 02F1 92 SWAP3 02F2 91 SWAP2 02F3 90 SWAP1 02F4 50 POP 02F5 50 POP 02F6 50 POP 02F7 61 PUSH2 0x0b81 02FA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02E7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @02F1 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b81 label_02FB: // Incoming return from call to 0x02C5 at 0x02C0 02FB 5B JUMPDEST 02FC 00 *STOP // Stack delta = +0 // Outputs[1] { @02FC stop(); } // Block terminates label_02FD: // Incoming jump from 0x0153, if 0x18160ddd == stack[-1] 02FD 5B JUMPDEST 02FE 61 PUSH2 0x0305 0301 61 PUSH2 0x0cc6 0304 56 *JUMP // Stack delta = +1 // Outputs[1] { @02FE stack[0] = 0x0305 } // Block ends with call to 0x0cc6, returns to 0x0305 label_0305: // Incoming return from call to 0x0CC6 at 0x0304 // Inputs[4] // { // @0308 memory[0x40:0x60] // @030A stack[-1] // @0315 memory[0x40:0x60] // @031A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0305 5B JUMPDEST 0306 60 PUSH1 0x40 0308 51 MLOAD 0309 80 DUP1 030A 82 DUP3 030B 81 DUP2 030C 52 MSTORE 030D 60 PUSH1 0x20 030F 01 ADD 0310 91 SWAP2 0311 50 POP 0312 50 POP 0313 60 PUSH1 0x40 0315 51 MLOAD 0316 80 DUP1 0317 91 SWAP2 0318 03 SUB 0319 90 SWAP1 031A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @030C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @031A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_031B: // Incoming jump from 0x00EB, if 0x23b872dd == stack[-1] // Inputs[1] { @0322 msg.data.length } 031B 5B JUMPDEST 031C 61 PUSH2 0x0387 031F 60 PUSH1 0x04 0321 80 DUP1 0322 36 CALLDATASIZE 0323 03 SUB 0324 60 PUSH1 0x60 0326 81 DUP2 0327 10 LT 0328 15 ISZERO 0329 61 PUSH2 0x0331 032C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @031C stack[0] = 0x0387 // @031F stack[1] = 0x04 // @0323 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0331, returns to 0x0387, if !(msg.data.length - 0x04 < 0x60) label_032D: // Incoming jump from 0x032C, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0330 memory[0x00:0x00] } 032D 60 PUSH1 0x00 032F 80 DUP1 0330 FD *REVERT // Stack delta = +0 // Outputs[1] { @0330 revert(memory[0x00:0x00]); } // Block terminates label_0331: // Incoming call from 0x032C, returns to 0x0387, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0332 stack[-2] // @0333 stack[-1] // @0337 msg.data[stack[-2]:stack[-2] + 0x20] // @0357 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0377 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0331 5B JUMPDEST 0332 81 DUP2 0333 01 ADD 0334 90 SWAP1 0335 80 DUP1 0336 80 DUP1 0337 35 CALLDATALOAD 0338 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 034D 16 AND 034E 90 SWAP1 034F 60 PUSH1 0x20 0351 01 ADD 0352 90 SWAP1 0353 92 SWAP3 0354 91 SWAP2 0355 90 SWAP1 0356 80 DUP1 0357 35 CALLDATALOAD 0358 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 036D 16 AND 036E 90 SWAP1 036F 60 PUSH1 0x20 0371 01 ADD 0372 90 SWAP1 0373 92 SWAP3 0374 91 SWAP2 0375 90 SWAP1 0376 80 DUP1 0377 35 CALLDATALOAD 0378 90 SWAP1 0379 60 PUSH1 0x20 037B 01 ADD 037C 90 SWAP1 037D 92 SWAP3 037E 91 SWAP2 037F 90 SWAP1 0380 50 POP 0381 50 POP 0382 50 POP 0383 61 PUSH2 0x0cd3 0386 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0353 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0373 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @037D stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0cd3 label_0387: // Incoming return from call to 0x0331 at 0x032C 0387 5B JUMPDEST 0388 00 *STOP // Stack delta = +0 // Outputs[1] { @0388 stop(); } // Block terminates label_0389: // Incoming jump from 0x00F6, if 0x2f745c59 == stack[-1] // Inputs[1] { @0390 msg.data.length } 0389 5B JUMPDEST 038A 61 PUSH2 0x03d5 038D 60 PUSH1 0x04 038F 80 DUP1 0390 36 CALLDATASIZE 0391 03 SUB 0392 60 PUSH1 0x40 0394 81 DUP2 0395 10 LT 0396 15 ISZERO 0397 61 PUSH2 0x039f 039A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @038A stack[0] = 0x03d5 // @038D stack[1] = 0x04 // @0391 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x039f, returns to 0x03D5, if !(msg.data.length - 0x04 < 0x40) label_039B: // Incoming jump from 0x039A, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @039E memory[0x00:0x00] } 039B 60 PUSH1 0x00 039D 80 DUP1 039E FD *REVERT // Stack delta = +0 // Outputs[1] { @039E revert(memory[0x00:0x00]); } // Block terminates label_039F: // Incoming call from 0x039A, returns to 0x03D5, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @03A0 stack[-2] // @03A1 stack[-1] // @03A5 msg.data[stack[-2]:stack[-2] + 0x20] // @03C5 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 039F 5B JUMPDEST 03A0 81 DUP2 03A1 01 ADD 03A2 90 SWAP1 03A3 80 DUP1 03A4 80 DUP1 03A5 35 CALLDATALOAD 03A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03BB 16 AND 03BC 90 SWAP1 03BD 60 PUSH1 0x20 03BF 01 ADD 03C0 90 SWAP1 03C1 92 SWAP3 03C2 91 SWAP2 03C3 90 SWAP1 03C4 80 DUP1 03C5 35 CALLDATALOAD 03C6 90 SWAP1 03C7 60 PUSH1 0x20 03C9 01 ADD 03CA 90 SWAP1 03CB 92 SWAP3 03CC 91 SWAP2 03CD 90 SWAP1 03CE 50 POP 03CF 50 POP 03D0 50 POP 03D1 61 PUSH2 0x0cf8 03D4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03C1 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @03CB stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0cf8 label_03D5: // Incoming return from call to 0x039F at 0x039A // Inputs[4] // { // @03D8 memory[0x40:0x60] // @03DA stack[-1] // @03E5 memory[0x40:0x60] // @03EA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03D5 5B JUMPDEST 03D6 60 PUSH1 0x40 03D8 51 MLOAD 03D9 80 DUP1 03DA 82 DUP3 03DB 81 DUP2 03DC 52 MSTORE 03DD 60 PUSH1 0x20 03DF 01 ADD 03E0 91 SWAP2 03E1 50 POP 03E2 50 POP 03E3 60 PUSH1 0x40 03E5 51 MLOAD 03E6 80 DUP1 03E7 91 SWAP2 03E8 03 SUB 03E9 90 SWAP1 03EA F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03EA return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03EB: // Incoming jump from 0x0101, if 0x42842e0e == stack[-1] // Inputs[1] { @03F2 msg.data.length } 03EB 5B JUMPDEST 03EC 61 PUSH2 0x0457 03EF 60 PUSH1 0x04 03F1 80 DUP1 03F2 36 CALLDATASIZE 03F3 03 SUB 03F4 60 PUSH1 0x60 03F6 81 DUP2 03F7 10 LT 03F8 15 ISZERO 03F9 61 PUSH2 0x0401 03FC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03EC stack[0] = 0x0457 // @03EF stack[1] = 0x04 // @03F3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0401, returns to 0x0457, if !(msg.data.length - 0x04 < 0x60) label_03FD: // Incoming jump from 0x03FC, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0400 memory[0x00:0x00] } 03FD 60 PUSH1 0x00 03FF 80 DUP1 0400 FD *REVERT // Stack delta = +0 // Outputs[1] { @0400 revert(memory[0x00:0x00]); } // Block terminates label_0401: // Incoming call from 0x03FC, returns to 0x0457, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0402 stack[-2] // @0403 stack[-1] // @0407 msg.data[stack[-2]:stack[-2] + 0x20] // @0427 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0447 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0401 5B JUMPDEST 0402 81 DUP2 0403 01 ADD 0404 90 SWAP1 0405 80 DUP1 0406 80 DUP1 0407 35 CALLDATALOAD 0408 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 041D 16 AND 041E 90 SWAP1 041F 60 PUSH1 0x20 0421 01 ADD 0422 90 SWAP1 0423 92 SWAP3 0424 91 SWAP2 0425 90 SWAP1 0426 80 DUP1 0427 35 CALLDATALOAD 0428 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 043D 16 AND 043E 90 SWAP1 043F 60 PUSH1 0x20 0441 01 ADD 0442 90 SWAP1 0443 92 SWAP3 0444 91 SWAP2 0445 90 SWAP1 0446 80 DUP1 0447 35 CALLDATALOAD 0448 90 SWAP1 0449 60 PUSH1 0x20 044B 01 ADD 044C 90 SWAP1 044D 92 SWAP3 044E 91 SWAP2 044F 90 SWAP1 0450 50 POP 0451 50 POP 0452 50 POP 0453 61 PUSH2 0x0d6f 0456 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0423 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0443 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @044D stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0d6f label_0457: // Incoming return from call to 0x0401 at 0x03FC 0457 5B JUMPDEST 0458 00 *STOP // Stack delta = +0 // Outputs[1] { @0458 stop(); } // Block terminates label_0459: // Incoming jump from 0x010C, if 0x42966c68 == stack[-1] // Inputs[1] { @0460 msg.data.length } 0459 5B JUMPDEST 045A 61 PUSH2 0x0485 045D 60 PUSH1 0x04 045F 80 DUP1 0460 36 CALLDATASIZE 0461 03 SUB 0462 60 PUSH1 0x20 0464 81 DUP2 0465 10 LT 0466 15 ISZERO 0467 61 PUSH2 0x046f 046A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @045A stack[0] = 0x0485 // @045D stack[1] = 0x04 // @0461 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x046f, returns to 0x0485, if !(msg.data.length - 0x04 < 0x20) label_046B: // Incoming jump from 0x046A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @046E memory[0x00:0x00] } 046B 60 PUSH1 0x00 046D 80 DUP1 046E FD *REVERT // Stack delta = +0 // Outputs[1] { @046E revert(memory[0x00:0x00]); } // Block terminates label_046F: // Incoming call from 0x046A, returns to 0x0485, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0470 stack[-2] // @0471 stack[-1] // @0475 msg.data[stack[-2]:stack[-2] + 0x20] // } 046F 5B JUMPDEST 0470 81 DUP2 0471 01 ADD 0472 90 SWAP1 0473 80 DUP1 0474 80 DUP1 0475 35 CALLDATALOAD 0476 90 SWAP1 0477 60 PUSH1 0x20 0479 01 ADD 047A 90 SWAP1 047B 92 SWAP3 047C 91 SWAP2 047D 90 SWAP1 047E 50 POP 047F 50 POP 0480 50 POP 0481 61 PUSH2 0x0d90 0484 56 *JUMP // Stack delta = -1 // Outputs[1] { @047B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0d90 label_0485: // Incoming return from call to 0x046F at 0x046A 0485 5B JUMPDEST 0486 00 *STOP // Stack delta = +0 // Outputs[1] { @0486 stop(); } // Block terminates label_0487: // Incoming jump from 0x0117, if 0x45c17782 == stack[-1] // Inputs[1] { @048E msg.data.length } 0487 5B JUMPDEST 0488 61 PUSH2 0x0560 048B 60 PUSH1 0x04 048D 80 DUP1 048E 36 CALLDATASIZE 048F 03 SUB 0490 60 PUSH1 0x40 0492 81 DUP2 0493 10 LT 0494 15 ISZERO 0495 61 PUSH2 0x049d 0498 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0488 stack[0] = 0x0560 // @048B stack[1] = 0x04 // @048F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x049d, returns to 0x0560, if !(msg.data.length - 0x04 < 0x40) label_0499: // Incoming jump from 0x0498, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @049C memory[0x00:0x00] } 0499 60 PUSH1 0x00 049B 80 DUP1 049C FD *REVERT // Stack delta = +0 // Outputs[1] { @049C revert(memory[0x00:0x00]); } // Block terminates label_049D: // Incoming call from 0x0498, returns to 0x0560, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @049E stack[-2] // @049F stack[-1] // @04A3 msg.data[stack[-2]:stack[-2] + 0x20] // @04C3 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 049D 5B JUMPDEST 049E 81 DUP2 049F 01 ADD 04A0 90 SWAP1 04A1 80 DUP1 04A2 80 DUP1 04A3 35 CALLDATALOAD 04A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04B9 16 AND 04BA 90 SWAP1 04BB 60 PUSH1 0x20 04BD 01 ADD 04BE 90 SWAP1 04BF 92 SWAP3 04C0 91 SWAP2 04C1 90 SWAP1 04C2 80 DUP1 04C3 35 CALLDATALOAD 04C4 90 SWAP1 04C5 60 PUSH1 0x20 04C7 01 ADD 04C8 90 SWAP1 04C9 64 PUSH5 0x0100000000 04CF 81 DUP2 04D0 11 GT 04D1 15 ISZERO 04D2 61 PUSH2 0x04da 04D5 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @04BF stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @04C0 stack[-1] = stack[-2] + stack[-1] // @04C1 stack[0] = stack[-2] // @04C8 stack[1] = 0x20 + 0x20 + stack[-2] // @04C8 stack[2] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x04da, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) label_04D6: // Incoming jump from 0x04D5, if not !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @04D9 memory[0x00:0x00] } 04D6 60 PUSH1 0x00 04D8 80 DUP1 04D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D9 revert(memory[0x00:0x00]); } // Block terminates label_04DA: // Incoming jump from 0x04D5, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @04DB stack[-3] // @04DC stack[-1] // @04DD stack[-4] // } 04DA 5B JUMPDEST 04DB 82 DUP3 04DC 01 ADD 04DD 83 DUP4 04DE 60 PUSH1 0x20 04E0 82 DUP3 04E1 01 ADD 04E2 11 GT 04E3 15 ISZERO 04E4 61 PUSH2 0x04ec 04E7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04DC stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x04ec, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_04E8: // Incoming jump from 0x04E7, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @04EB memory[0x00:0x00] } 04E8 60 PUSH1 0x00 04EA 80 DUP1 04EB FD *REVERT // Stack delta = +0 // Outputs[1] { @04EB revert(memory[0x00:0x00]); } // Block terminates label_04EC: // Incoming jump from 0x04E7, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @04ED stack[-1] // @04EE msg.data[stack[-1]:stack[-1] + 0x20] // @04F3 stack[-2] // @04F4 stack[-4] // } 04EC 5B JUMPDEST 04ED 80 DUP1 04EE 35 CALLDATALOAD 04EF 90 SWAP1 04F0 60 PUSH1 0x20 04F2 01 ADD 04F3 91 SWAP2 04F4 84 DUP5 04F5 60 PUSH1 0x01 04F7 83 DUP4 04F8 02 MUL 04F9 84 DUP5 04FA 01 ADD 04FB 11 GT 04FC 64 PUSH5 0x0100000000 0502 83 DUP4 0503 11 GT 0504 17 OR 0505 15 ISZERO 0506 61 PUSH2 0x050e 0509 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @04EF stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @04F3 stack[0] = stack[-2] // @04F3 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x050e, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_050A: // Incoming jump from 0x0509, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @050D memory[0x00:0x00] } 050A 60 PUSH1 0x00 050C 80 DUP1 050D FD *REVERT // Stack delta = +0 // Outputs[1] { @050D revert(memory[0x00:0x00]); } // Block terminates label_050E: // Incoming jump from 0x0509, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @050F stack[-1] // @050F stack[-3] // @0510 stack[-2] // @0521 memory[0x40:0x60] // @0538 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0554 stack[-4] // @0555 stack[-5] // } 050E 5B JUMPDEST 050F 91 SWAP2 0510 90 SWAP1 0511 80 DUP1 0512 80 DUP1 0513 60 PUSH1 0x1f 0515 01 ADD 0516 60 PUSH1 0x20 0518 80 DUP1 0519 91 SWAP2 051A 04 DIV 051B 02 MUL 051C 60 PUSH1 0x20 051E 01 ADD 051F 60 PUSH1 0x40 0521 51 MLOAD 0522 90 SWAP1 0523 81 DUP2 0524 01 ADD 0525 60 PUSH1 0x40 0527 52 MSTORE 0528 80 DUP1 0529 93 SWAP4 052A 92 SWAP3 052B 91 SWAP2 052C 90 SWAP1 052D 81 DUP2 052E 81 DUP2 052F 52 MSTORE 0530 60 PUSH1 0x20 0532 01 ADD 0533 83 DUP4 0534 83 DUP4 0535 80 DUP1 0536 82 DUP3 0537 84 DUP5 0538 37 CALLDATACOPY 0539 60 PUSH1 0x00 053B 81 DUP2 053C 84 DUP5 053D 01 ADD 053E 52 MSTORE 053F 60 PUSH1 0x1f 0541 19 NOT 0542 60 PUSH1 0x1f 0544 82 DUP3 0545 01 ADD 0546 16 AND 0547 90 SWAP1 0548 50 POP 0549 80 DUP1 054A 83 DUP4 054B 01 ADD 054C 92 SWAP3 054D 50 POP 054E 50 POP 054F 50 POP 0550 50 POP 0551 50 POP 0552 50 POP 0553 50 POP 0554 91 SWAP2 0555 92 SWAP3 0556 91 SWAP2 0557 92 SWAP3 0558 90 SWAP1 0559 50 POP 055A 50 POP 055B 50 POP 055C 61 PUSH2 0x0db1 055F 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0527 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @052F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0538 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @053E memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0557 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0db1 label_0560: // Incoming return from call to 0x049D at 0x0498 // Inputs[4] // { // @0563 memory[0x40:0x60] // @0565 stack[-1] // @0574 memory[0x40:0x60] // @0579 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0560 5B JUMPDEST 0561 60 PUSH1 0x40 0563 51 MLOAD 0564 80 DUP1 0565 82 DUP3 0566 15 ISZERO 0567 15 ISZERO 0568 15 ISZERO 0569 15 ISZERO 056A 81 DUP2 056B 52 MSTORE 056C 60 PUSH1 0x20 056E 01 ADD 056F 91 SWAP2 0570 50 POP 0571 50 POP 0572 60 PUSH1 0x40 0574 51 MLOAD 0575 80 DUP1 0576 91 SWAP2 0577 03 SUB 0578 90 SWAP1 0579 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @056B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0579 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_057A: // Incoming jump from 0x00A4, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0581 msg.data.length } 057A 5B JUMPDEST 057B 61 PUSH2 0x05a6 057E 60 PUSH1 0x04 0580 80 DUP1 0581 36 CALLDATASIZE 0582 03 SUB 0583 60 PUSH1 0x20 0585 81 DUP2 0586 10 LT 0587 15 ISZERO 0588 61 PUSH2 0x0590 058B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @057B stack[0] = 0x05a6 // @057E stack[1] = 0x04 // @0582 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0590, returns to 0x05A6, if !(msg.data.length - 0x04 < 0x20) label_058C: // Incoming jump from 0x058B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @058F memory[0x00:0x00] } 058C 60 PUSH1 0x00 058E 80 DUP1 058F FD *REVERT // Stack delta = +0 // Outputs[1] { @058F revert(memory[0x00:0x00]); } // Block terminates label_0590: // Incoming call from 0x058B, returns to 0x05A6, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0591 stack[-2] // @0592 stack[-1] // @0596 msg.data[stack[-2]:stack[-2] + 0x20] // } 0590 5B JUMPDEST 0591 81 DUP2 0592 01 ADD 0593 90 SWAP1 0594 80 DUP1 0595 80 DUP1 0596 35 CALLDATALOAD 0597 90 SWAP1 0598 60 PUSH1 0x20 059A 01 ADD 059B 90 SWAP1 059C 92 SWAP3 059D 91 SWAP2 059E 90 SWAP1 059F 50 POP 05A0 50 POP 05A1 50 POP 05A2 61 PUSH2 0x0fc1 05A5 56 *JUMP // Stack delta = -1 // Outputs[1] { @059C stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0fc1 label_05A6: // Incoming return from call to 0x0590 at 0x058B // Inputs[4] // { // @05A9 memory[0x40:0x60] // @05AB stack[-1] // @05B6 memory[0x40:0x60] // @05BB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05A6 5B JUMPDEST 05A7 60 PUSH1 0x40 05A9 51 MLOAD 05AA 80 DUP1 05AB 82 DUP3 05AC 81 DUP2 05AD 52 MSTORE 05AE 60 PUSH1 0x20 05B0 01 ADD 05B1 91 SWAP2 05B2 50 POP 05B3 50 POP 05B4 60 PUSH1 0x40 05B6 51 MLOAD 05B7 80 DUP1 05B8 91 SWAP2 05B9 03 SUB 05BA 90 SWAP1 05BB F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05BB return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05BC: // Incoming jump from 0x00AF, if 0x6352211e == stack[-1] // Inputs[1] { @05C3 msg.data.length } 05BC 5B JUMPDEST 05BD 61 PUSH2 0x05e8 05C0 60 PUSH1 0x04 05C2 80 DUP1 05C3 36 CALLDATASIZE 05C4 03 SUB 05C5 60 PUSH1 0x20 05C7 81 DUP2 05C8 10 LT 05C9 15 ISZERO 05CA 61 PUSH2 0x05d2 05CD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05BD stack[0] = 0x05e8 // @05C0 stack[1] = 0x04 // @05C4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05d2, returns to 0x05E8, if !(msg.data.length - 0x04 < 0x20) label_05CE: // Incoming jump from 0x05CD, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05D1 memory[0x00:0x00] } 05CE 60 PUSH1 0x00 05D0 80 DUP1 05D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D1 revert(memory[0x00:0x00]); } // Block terminates label_05D2: // Incoming call from 0x05CD, returns to 0x05E8, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @05D3 stack[-2] // @05D4 stack[-1] // @05D8 msg.data[stack[-2]:stack[-2] + 0x20] // } 05D2 5B JUMPDEST 05D3 81 DUP2 05D4 01 ADD 05D5 90 SWAP1 05D6 80 DUP1 05D7 80 DUP1 05D8 35 CALLDATALOAD 05D9 90 SWAP1 05DA 60 PUSH1 0x20 05DC 01 ADD 05DD 90 SWAP1 05DE 92 SWAP3 05DF 91 SWAP2 05E0 90 SWAP1 05E1 50 POP 05E2 50 POP 05E3 50 POP 05E4 61 PUSH2 0x0ff9 05E7 56 *JUMP // Stack delta = -1 // Outputs[1] { @05DE stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0ff9 label_05E8: // Incoming return from call to 0x05D2 at 0x05CD // Inputs[4] // { // @05EB memory[0x40:0x60] // @05ED stack[-1] // @0624 memory[0x40:0x60] // @0629 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05E8 5B JUMPDEST 05E9 60 PUSH1 0x40 05EB 51 MLOAD 05EC 80 DUP1 05ED 82 DUP3 05EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0603 16 AND 0604 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0619 16 AND 061A 81 DUP2 061B 52 MSTORE 061C 60 PUSH1 0x20 061E 01 ADD 061F 91 SWAP2 0620 50 POP 0621 50 POP 0622 60 PUSH1 0x40 0624 51 MLOAD 0625 80 DUP1 0626 91 SWAP2 0627 03 SUB 0628 90 SWAP1 0629 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @061B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0629 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_062A: // Incoming jump from 0x00BA, if 0x70a08231 == stack[-1] // Inputs[1] { @0631 msg.data.length } 062A 5B JUMPDEST 062B 61 PUSH2 0x066c 062E 60 PUSH1 0x04 0630 80 DUP1 0631 36 CALLDATASIZE 0632 03 SUB 0633 60 PUSH1 0x20 0635 81 DUP2 0636 10 LT 0637 15 ISZERO 0638 61 PUSH2 0x0640 063B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @062B stack[0] = 0x066c // @062E stack[1] = 0x04 // @0632 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0640, returns to 0x066C, if !(msg.data.length - 0x04 < 0x20) label_063C: // Incoming jump from 0x063B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @063F memory[0x00:0x00] } 063C 60 PUSH1 0x00 063E 80 DUP1 063F FD *REVERT // Stack delta = +0 // Outputs[1] { @063F revert(memory[0x00:0x00]); } // Block terminates label_0640: // Incoming call from 0x063B, returns to 0x066C, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0641 stack[-2] // @0642 stack[-1] // @0646 msg.data[stack[-2]:stack[-2] + 0x20] // } 0640 5B JUMPDEST 0641 81 DUP2 0642 01 ADD 0643 90 SWAP1 0644 80 DUP1 0645 80 DUP1 0646 35 CALLDATALOAD 0647 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 065C 16 AND 065D 90 SWAP1 065E 60 PUSH1 0x20 0660 01 ADD 0661 90 SWAP1 0662 92 SWAP3 0663 91 SWAP2 0664 90 SWAP1 0665 50 POP 0666 50 POP 0667 50 POP 0668 61 PUSH2 0x1077 066B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0662 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1077 label_066C: // Incoming return from call to 0x0640 at 0x063B // Inputs[4] // { // @066F memory[0x40:0x60] // @0671 stack[-1] // @067C memory[0x40:0x60] // @0681 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 066C 5B JUMPDEST 066D 60 PUSH1 0x40 066F 51 MLOAD 0670 80 DUP1 0671 82 DUP3 0672 81 DUP2 0673 52 MSTORE 0674 60 PUSH1 0x20 0676 01 ADD 0677 91 SWAP2 0678 50 POP 0679 50 POP 067A 60 PUSH1 0x40 067C 51 MLOAD 067D 80 DUP1 067E 91 SWAP2 067F 03 SUB 0680 90 SWAP1 0681 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0673 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0681 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0682: // Incoming jump from 0x00C5, if 0x95d89b41 == stack[-1] 0682 5B JUMPDEST 0683 61 PUSH2 0x068a 0686 61 PUSH2 0x1102 0689 56 *JUMP // Stack delta = +1 // Outputs[1] { @0683 stack[0] = 0x068a } // Block ends with call to 0x1102, returns to 0x068A label_068A: // Incoming return from call to 0x1102 at 0x0689 // Inputs[4] // { // @068D memory[0x40:0x60] // @0698 stack[-1] // @069B memory[stack[-1]:stack[-1] + 0x20] // @06A4 memory[stack[-1]:stack[-1] + 0x20] // } 068A 5B JUMPDEST 068B 60 PUSH1 0x40 068D 51 MLOAD 068E 80 DUP1 068F 80 DUP1 0690 60 PUSH1 0x20 0692 01 ADD 0693 82 DUP3 0694 81 DUP2 0695 03 SUB 0696 82 DUP3 0697 52 MSTORE 0698 83 DUP4 0699 81 DUP2 069A 81 DUP2 069B 51 MLOAD 069C 81 DUP2 069D 52 MSTORE 069E 60 PUSH1 0x20 06A0 01 ADD 06A1 91 SWAP2 06A2 50 POP 06A3 80 DUP1 06A4 51 MLOAD 06A5 90 SWAP1 06A6 60 PUSH1 0x20 06A8 01 ADD 06A9 90 SWAP1 06AA 80 DUP1 06AB 83 DUP4 06AC 83 DUP4 06AD 60 PUSH1 0x00 06AF 5B JUMPDEST 06B0 83 DUP4 06B1 81 DUP2 06B2 10 LT 06B3 15 ISZERO 06B4 61 PUSH2 0x06ca 06B7 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @068D stack[0] = memory[0x40:0x60] // @068E stack[1] = memory[0x40:0x60] // @0697 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @069D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @06A1 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @06A9 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @06A9 stack[3] = 0x20 + stack[-1] // @06AA stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @06AB stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @06AC stack[7] = 0x20 + stack[-1] // @06AD stack[8] = 0x00 // } // Block ends with conditional jump to 0x06ca, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_06B8: // Incoming jump from 0x06B7, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x06B7, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @06B8 stack[-1] // @06B9 stack[-2] // @06BB memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @06BD stack[-3] // } 06B8 80 DUP1 06B9 82 DUP3 06BA 01 ADD 06BB 51 MLOAD 06BC 81 DUP2 06BD 84 DUP5 06BE 01 ADD 06BF 52 MSTORE 06C0 60 PUSH1 0x20 06C2 81 DUP2 06C3 01 ADD 06C4 90 SWAP1 06C5 50 POP 06C6 61 PUSH2 0x06af 06C9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06BF memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @06C4 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x06af label_06CA: // Incoming jump from 0x06B7, if !(stack[-1] < stack[-4]) // Incoming jump from 0x06B7, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @06CF stack[-6] // @06CF stack[-5] // @06D1 stack[-7] // } 06CA 5B JUMPDEST 06CB 50 POP 06CC 50 POP 06CD 50 POP 06CE 50 POP 06CF 90 SWAP1 06D0 50 POP 06D1 90 SWAP1 06D2 81 DUP2 06D3 01 ADD 06D4 90 SWAP1 06D5 60 PUSH1 0x1f 06D7 16 AND 06D8 80 DUP1 06D9 15 ISZERO 06DA 61 PUSH2 0x06f7 06DD 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @06D4 stack[-7] = stack[-5] + stack[-7] // @06D7 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x06f7, if !(0x1f & stack[-5]) label_06DE: // Incoming jump from 0x06DD, if not !(0x1f & stack[-5]) // Inputs[6] // { // @06DE stack[-1] // @06DF stack[-2] // @06E2 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @06F9 stack[-5] // @06FF memory[0x40:0x60] // @0704 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 06DE 80 DUP1 06DF 82 DUP3 06E0 03 SUB 06E1 80 DUP1 06E2 51 MLOAD 06E3 60 PUSH1 0x01 06E5 83 DUP4 06E6 60 PUSH1 0x20 06E8 03 SUB 06E9 61 PUSH2 0x0100 06EC 0A EXP 06ED 03 SUB 06EE 19 NOT 06EF 16 AND 06F0 81 DUP2 06F1 52 MSTORE 06F2 60 PUSH1 0x20 06F4 01 ADD 06F5 91 SWAP2 06F6 50 POP 06F7 5B JUMPDEST 06F8 50 POP 06F9 92 SWAP3 06FA 50 POP 06FB 50 POP 06FC 50 POP 06FD 60 PUSH1 0x40 06FF 51 MLOAD 0700 80 DUP1 0701 91 SWAP2 0702 03 SUB 0703 90 SWAP1 0704 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @06F1 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0704 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0705: // Incoming jump from 0x00D0, if 0x983b2d56 == stack[-1] // Inputs[1] { @070C msg.data.length } 0705 5B JUMPDEST 0706 61 PUSH2 0x0747 0709 60 PUSH1 0x04 070B 80 DUP1 070C 36 CALLDATASIZE 070D 03 SUB 070E 60 PUSH1 0x20 0710 81 DUP2 0711 10 LT 0712 15 ISZERO 0713 61 PUSH2 0x071b 0716 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0706 stack[0] = 0x0747 // @0709 stack[1] = 0x04 // @070D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x071b, returns to 0x0747, if !(msg.data.length - 0x04 < 0x20) label_0717: // Incoming jump from 0x0716, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @071A memory[0x00:0x00] } 0717 60 PUSH1 0x00 0719 80 DUP1 071A FD *REVERT // Stack delta = +0 // Outputs[1] { @071A revert(memory[0x00:0x00]); } // Block terminates label_071B: // Incoming call from 0x0716, returns to 0x0747, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @071C stack[-2] // @071D stack[-1] // @0721 msg.data[stack[-2]:stack[-2] + 0x20] // } 071B 5B JUMPDEST 071C 81 DUP2 071D 01 ADD 071E 90 SWAP1 071F 80 DUP1 0720 80 DUP1 0721 35 CALLDATALOAD 0722 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0737 16 AND 0738 90 SWAP1 0739 60 PUSH1 0x20 073B 01 ADD 073C 90 SWAP1 073D 92 SWAP3 073E 91 SWAP2 073F 90 SWAP1 0740 50 POP 0741 50 POP 0742 50 POP 0743 61 PUSH2 0x11a4 0746 56 *JUMP // Stack delta = -1 // Outputs[1] { @073D stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x11a4 label_0747: // Incoming return from call to 0x071B at 0x0716 0747 5B JUMPDEST 0748 00 *STOP // Stack delta = +0 // Outputs[1] { @0748 stop(); } // Block terminates label_0749: // Incoming jump from 0x005D, if 0x98650275 == stack[-1] 0749 5B JUMPDEST 074A 61 PUSH2 0x0751 074D 61 PUSH2 0x11c4 0750 56 *JUMP // Stack delta = +1 // Outputs[1] { @074A stack[0] = 0x0751 } // Block ends with call to 0x11c4, returns to 0x0751 label_0751: // Incoming return from call to 0x11C4 at 0x0750 0751 5B JUMPDEST 0752 00 *STOP // Stack delta = +0 // Outputs[1] { @0752 stop(); } // Block terminates label_0753: // Incoming jump from 0x0068, if 0xa22cb465 == stack[-1] // Inputs[1] { @075A msg.data.length } 0753 5B JUMPDEST 0754 61 PUSH2 0x07a1 0757 60 PUSH1 0x04 0759 80 DUP1 075A 36 CALLDATASIZE 075B 03 SUB 075C 60 PUSH1 0x40 075E 81 DUP2 075F 10 LT 0760 15 ISZERO 0761 61 PUSH2 0x0769 0764 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0754 stack[0] = 0x07a1 // @0757 stack[1] = 0x04 // @075B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0769, returns to 0x07A1, if !(msg.data.length - 0x04 < 0x40) label_0765: // Incoming jump from 0x0764, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0768 memory[0x00:0x00] } 0765 60 PUSH1 0x00 0767 80 DUP1 0768 FD *REVERT // Stack delta = +0 // Outputs[1] { @0768 revert(memory[0x00:0x00]); } // Block terminates label_0769: // Incoming call from 0x0764, returns to 0x07A1, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @076A stack[-2] // @076B stack[-1] // @076F msg.data[stack[-2]:stack[-2] + 0x20] // @078F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0769 5B JUMPDEST 076A 81 DUP2 076B 01 ADD 076C 90 SWAP1 076D 80 DUP1 076E 80 DUP1 076F 35 CALLDATALOAD 0770 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0785 16 AND 0786 90 SWAP1 0787 60 PUSH1 0x20 0789 01 ADD 078A 90 SWAP1 078B 92 SWAP3 078C 91 SWAP2 078D 90 SWAP1 078E 80 DUP1 078F 35 CALLDATALOAD 0790 15 ISZERO 0791 15 ISZERO 0792 90 SWAP1 0793 60 PUSH1 0x20 0795 01 ADD 0796 90 SWAP1 0797 92 SWAP3 0798 91 SWAP2 0799 90 SWAP1 079A 50 POP 079B 50 POP 079C 50 POP 079D 61 PUSH2 0x11cf 07A0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @078B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0797 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x11cf label_07A1: // Incoming return from call to 0x0769 at 0x0764 07A1 5B JUMPDEST 07A2 00 *STOP // Stack delta = +0 // Outputs[1] { @07A2 stop(); } // Block terminates label_07A3: // Incoming jump from 0x0073, if 0xaa271e1a == stack[-1] // Inputs[1] { @07AA msg.data.length } 07A3 5B JUMPDEST 07A4 61 PUSH2 0x07e5 07A7 60 PUSH1 0x04 07A9 80 DUP1 07AA 36 CALLDATASIZE 07AB 03 SUB 07AC 60 PUSH1 0x20 07AE 81 DUP2 07AF 10 LT 07B0 15 ISZERO 07B1 61 PUSH2 0x07b9 07B4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07A4 stack[0] = 0x07e5 // @07A7 stack[1] = 0x04 // @07AB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x07b9, returns to 0x07E5, if !(msg.data.length - 0x04 < 0x20) label_07B5: // Incoming jump from 0x07B4, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @07B8 memory[0x00:0x00] } 07B5 60 PUSH1 0x00 07B7 80 DUP1 07B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B8 revert(memory[0x00:0x00]); } // Block terminates label_07B9: // Incoming call from 0x07B4, returns to 0x07E5, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @07BA stack[-2] // @07BB stack[-1] // @07BF msg.data[stack[-2]:stack[-2] + 0x20] // } 07B9 5B JUMPDEST 07BA 81 DUP2 07BB 01 ADD 07BC 90 SWAP1 07BD 80 DUP1 07BE 80 DUP1 07BF 35 CALLDATALOAD 07C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07D5 16 AND 07D6 90 SWAP1 07D7 60 PUSH1 0x20 07D9 01 ADD 07DA 90 SWAP1 07DB 92 SWAP3 07DC 91 SWAP2 07DD 90 SWAP1 07DE 50 POP 07DF 50 POP 07E0 50 POP 07E1 61 PUSH2 0x130b 07E4 56 *JUMP // Stack delta = -1 // Outputs[1] { @07DB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x130b label_07E5: // Incoming return from call to 0x07B9 at 0x07B4 // Inputs[4] // { // @07E8 memory[0x40:0x60] // @07EA stack[-1] // @07F9 memory[0x40:0x60] // @07FE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07E5 5B JUMPDEST 07E6 60 PUSH1 0x40 07E8 51 MLOAD 07E9 80 DUP1 07EA 82 DUP3 07EB 15 ISZERO 07EC 15 ISZERO 07ED 15 ISZERO 07EE 15 ISZERO 07EF 81 DUP2 07F0 52 MSTORE 07F1 60 PUSH1 0x20 07F3 01 ADD 07F4 91 SWAP2 07F5 50 POP 07F6 50 POP 07F7 60 PUSH1 0x40 07F9 51 MLOAD 07FA 80 DUP1 07FB 91 SWAP2 07FC 03 SUB 07FD 90 SWAP1 07FE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @07F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @07FE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_07FF: // Incoming jump from 0x007E, if 0xb88d4fde == stack[-1] // Inputs[1] { @0806 msg.data.length } 07FF 5B JUMPDEST 0800 61 PUSH2 0x0902 0803 60 PUSH1 0x04 0805 80 DUP1 0806 36 CALLDATASIZE 0807 03 SUB 0808 60 PUSH1 0x80 080A 81 DUP2 080B 10 LT 080C 15 ISZERO 080D 61 PUSH2 0x0815 0810 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0800 stack[0] = 0x0902 // @0803 stack[1] = 0x04 // @0807 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0815, returns to 0x0902, if !(msg.data.length - 0x04 < 0x80) label_0811: // Incoming jump from 0x0810, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0814 memory[0x00:0x00] } 0811 60 PUSH1 0x00 0813 80 DUP1 0814 FD *REVERT // Stack delta = +0 // Outputs[1] { @0814 revert(memory[0x00:0x00]); } // Block terminates label_0815: // Incoming call from 0x0810, returns to 0x0902, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @0816 stack[-2] // @0817 stack[-1] // @081B msg.data[stack[-2]:stack[-2] + 0x20] // @083B msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @085B msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0865 msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } 0815 5B JUMPDEST 0816 81 DUP2 0817 01 ADD 0818 90 SWAP1 0819 80 DUP1 081A 80 DUP1 081B 35 CALLDATALOAD 081C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0831 16 AND 0832 90 SWAP1 0833 60 PUSH1 0x20 0835 01 ADD 0836 90 SWAP1 0837 92 SWAP3 0838 91 SWAP2 0839 90 SWAP1 083A 80 DUP1 083B 35 CALLDATALOAD 083C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0851 16 AND 0852 90 SWAP1 0853 60 PUSH1 0x20 0855 01 ADD 0856 90 SWAP1 0857 92 SWAP3 0858 91 SWAP2 0859 90 SWAP1 085A 80 DUP1 085B 35 CALLDATALOAD 085C 90 SWAP1 085D 60 PUSH1 0x20 085F 01 ADD 0860 90 SWAP1 0861 92 SWAP3 0862 91 SWAP2 0863 90 SWAP1 0864 80 DUP1 0865 35 CALLDATALOAD 0866 90 SWAP1 0867 60 PUSH1 0x20 0869 01 ADD 086A 90 SWAP1 086B 64 PUSH5 0x0100000000 0871 81 DUP2 0872 11 GT 0873 15 ISZERO 0874 61 PUSH2 0x087c 0877 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0837 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0857 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0861 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0862 stack[1] = stack[-2] + stack[-1] // @0863 stack[2] = stack[-2] // @086A stack[4] = msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @086A stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x087c, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_0878: // Incoming jump from 0x0877, if not !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @087B memory[0x00:0x00] } 0878 60 PUSH1 0x00 087A 80 DUP1 087B FD *REVERT // Stack delta = +0 // Outputs[1] { @087B revert(memory[0x00:0x00]); } // Block terminates label_087C: // Incoming jump from 0x0877, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @087D stack[-3] // @087E stack[-1] // @087F stack[-4] // } 087C 5B JUMPDEST 087D 82 DUP3 087E 01 ADD 087F 83 DUP4 0880 60 PUSH1 0x20 0882 82 DUP3 0883 01 ADD 0884 11 GT 0885 15 ISZERO 0886 61 PUSH2 0x088e 0889 57 *JUMPI // Stack delta = +0 // Outputs[1] { @087E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x088e, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_088A: // Incoming jump from 0x0889, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @088D memory[0x00:0x00] } 088A 60 PUSH1 0x00 088C 80 DUP1 088D FD *REVERT // Stack delta = +0 // Outputs[1] { @088D revert(memory[0x00:0x00]); } // Block terminates label_088E: // Incoming jump from 0x0889, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @088F stack[-1] // @0890 msg.data[stack[-1]:stack[-1] + 0x20] // @0895 stack[-2] // @0896 stack[-4] // } 088E 5B JUMPDEST 088F 80 DUP1 0890 35 CALLDATALOAD 0891 90 SWAP1 0892 60 PUSH1 0x20 0894 01 ADD 0895 91 SWAP2 0896 84 DUP5 0897 60 PUSH1 0x01 0899 83 DUP4 089A 02 MUL 089B 84 DUP5 089C 01 ADD 089D 11 GT 089E 64 PUSH5 0x0100000000 08A4 83 DUP4 08A5 11 GT 08A6 17 OR 08A7 15 ISZERO 08A8 61 PUSH2 0x08b0 08AB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0891 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0895 stack[0] = stack[-2] // @0895 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x08b0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_08AC: // Incoming jump from 0x08AB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @08AF memory[0x00:0x00] } 08AC 60 PUSH1 0x00 08AE 80 DUP1 08AF FD *REVERT // Stack delta = +0 // Outputs[1] { @08AF revert(memory[0x00:0x00]); } // Block terminates label_08B0: // Incoming jump from 0x08AB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @08B1 stack[-1] // @08B1 stack[-3] // @08B2 stack[-2] // @08C3 memory[0x40:0x60] // @08DA msg.data[stack[-3]:stack[-3] + stack[-2]] // @08F6 stack[-4] // @08F7 stack[-5] // } 08B0 5B JUMPDEST 08B1 91 SWAP2 08B2 90 SWAP1 08B3 80 DUP1 08B4 80 DUP1 08B5 60 PUSH1 0x1f 08B7 01 ADD 08B8 60 PUSH1 0x20 08BA 80 DUP1 08BB 91 SWAP2 08BC 04 DIV 08BD 02 MUL 08BE 60 PUSH1 0x20 08C0 01 ADD 08C1 60 PUSH1 0x40 08C3 51 MLOAD 08C4 90 SWAP1 08C5 81 DUP2 08C6 01 ADD 08C7 60 PUSH1 0x40 08C9 52 MSTORE 08CA 80 DUP1 08CB 93 SWAP4 08CC 92 SWAP3 08CD 91 SWAP2 08CE 90 SWAP1 08CF 81 DUP2 08D0 81 DUP2 08D1 52 MSTORE 08D2 60 PUSH1 0x20 08D4 01 ADD 08D5 83 DUP4 08D6 83 DUP4 08D7 80 DUP1 08D8 82 DUP3 08D9 84 DUP5 08DA 37 CALLDATACOPY 08DB 60 PUSH1 0x00 08DD 81 DUP2 08DE 84 DUP5 08DF 01 ADD 08E0 52 MSTORE 08E1 60 PUSH1 0x1f 08E3 19 NOT 08E4 60 PUSH1 0x1f 08E6 82 DUP3 08E7 01 ADD 08E8 16 AND 08E9 90 SWAP1 08EA 50 POP 08EB 80 DUP1 08EC 83 DUP4 08ED 01 ADD 08EE 92 SWAP3 08EF 50 POP 08F0 50 POP 08F1 50 POP 08F2 50 POP 08F3 50 POP 08F4 50 POP 08F5 50 POP 08F6 91 SWAP2 08F7 92 SWAP3 08F8 91 SWAP2 08F9 92 SWAP3 08FA 90 SWAP1 08FB 50 POP 08FC 50 POP 08FD 50 POP 08FE 61 PUSH2 0x1328 0901 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @08C9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @08D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @08DA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @08E0 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @08F9 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1328 label_0902: // Incoming return from call to 0x0815 at 0x0810 0902 5B JUMPDEST 0903 00 *STOP // Stack delta = +0 // Outputs[1] { @0903 stop(); } // Block terminates label_0904: // Incoming jump from 0x0089, if 0xc87b56dd == stack[-1] // Inputs[1] { @090B msg.data.length } 0904 5B JUMPDEST 0905 61 PUSH2 0x0930 0908 60 PUSH1 0x04 090A 80 DUP1 090B 36 CALLDATASIZE 090C 03 SUB 090D 60 PUSH1 0x20 090F 81 DUP2 0910 10 LT 0911 15 ISZERO 0912 61 PUSH2 0x091a 0915 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0905 stack[0] = 0x0930 // @0908 stack[1] = 0x04 // @090C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x091a, returns to 0x0930, if !(msg.data.length - 0x04 < 0x20) label_0916: // Incoming jump from 0x0915, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0919 memory[0x00:0x00] } 0916 60 PUSH1 0x00 0918 80 DUP1 0919 FD *REVERT // Stack delta = +0 // Outputs[1] { @0919 revert(memory[0x00:0x00]); } // Block terminates label_091A: // Incoming call from 0x0915, returns to 0x0930, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @091B stack[-2] // @091C stack[-1] // @0920 msg.data[stack[-2]:stack[-2] + 0x20] // } 091A 5B JUMPDEST 091B 81 DUP2 091C 01 ADD 091D 90 SWAP1 091E 80 DUP1 091F 80 DUP1 0920 35 CALLDATALOAD 0921 90 SWAP1 0922 60 PUSH1 0x20 0924 01 ADD 0925 90 SWAP1 0926 92 SWAP3 0927 91 SWAP2 0928 90 SWAP1 0929 50 POP 092A 50 POP 092B 50 POP 092C 61 PUSH2 0x1350 092F 56 *JUMP // Stack delta = -1 // Outputs[1] { @0926 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1350 label_0930: // Incoming return from call to 0x091A at 0x0915 // Inputs[4] // { // @0933 memory[0x40:0x60] // @093E stack[-1] // @0941 memory[stack[-1]:stack[-1] + 0x20] // @094A memory[stack[-1]:stack[-1] + 0x20] // } 0930 5B JUMPDEST 0931 60 PUSH1 0x40 0933 51 MLOAD 0934 80 DUP1 0935 80 DUP1 0936 60 PUSH1 0x20 0938 01 ADD 0939 82 DUP3 093A 81 DUP2 093B 03 SUB 093C 82 DUP3 093D 52 MSTORE 093E 83 DUP4 093F 81 DUP2 0940 81 DUP2 0941 51 MLOAD 0942 81 DUP2 0943 52 MSTORE 0944 60 PUSH1 0x20 0946 01 ADD 0947 91 SWAP2 0948 50 POP 0949 80 DUP1 094A 51 MLOAD 094B 90 SWAP1 094C 60 PUSH1 0x20 094E 01 ADD 094F 90 SWAP1 0950 80 DUP1 0951 83 DUP4 0952 83 DUP4 0953 60 PUSH1 0x00 0955 5B JUMPDEST 0956 83 DUP4 0957 81 DUP2 0958 10 LT 0959 15 ISZERO 095A 61 PUSH2 0x0970 095D 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0933 stack[0] = memory[0x40:0x60] // @0934 stack[1] = memory[0x40:0x60] // @093D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0943 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0947 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @094F stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @094F stack[3] = 0x20 + stack[-1] // @0950 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0951 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0952 stack[7] = 0x20 + stack[-1] // @0953 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0970, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_095E: // Incoming jump from 0x095D, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x095D, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @095E stack[-1] // @095F stack[-2] // @0961 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0963 stack[-3] // } 095E 80 DUP1 095F 82 DUP3 0960 01 ADD 0961 51 MLOAD 0962 81 DUP2 0963 84 DUP5 0964 01 ADD 0965 52 MSTORE 0966 60 PUSH1 0x20 0968 81 DUP2 0969 01 ADD 096A 90 SWAP1 096B 50 POP 096C 61 PUSH2 0x0955 096F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0965 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @096A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0955 label_0970: // Incoming jump from 0x095D, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x095D, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0975 stack[-6] // @0975 stack[-5] // @0977 stack[-7] // } 0970 5B JUMPDEST 0971 50 POP 0972 50 POP 0973 50 POP 0974 50 POP 0975 90 SWAP1 0976 50 POP 0977 90 SWAP1 0978 81 DUP2 0979 01 ADD 097A 90 SWAP1 097B 60 PUSH1 0x1f 097D 16 AND 097E 80 DUP1 097F 15 ISZERO 0980 61 PUSH2 0x099d 0983 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @097A stack[-7] = stack[-5] + stack[-7] // @097D stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x099d, if !(0x1f & stack[-5]) label_0984: // Incoming jump from 0x0983, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0984 stack[-1] // @0985 stack[-2] // @0988 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @099F stack[-5] // @09A5 memory[0x40:0x60] // @09AA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0984 80 DUP1 0985 82 DUP3 0986 03 SUB 0987 80 DUP1 0988 51 MLOAD 0989 60 PUSH1 0x01 098B 83 DUP4 098C 60 PUSH1 0x20 098E 03 SUB 098F 61 PUSH2 0x0100 0992 0A EXP 0993 03 SUB 0994 19 NOT 0995 16 AND 0996 81 DUP2 0997 52 MSTORE 0998 60 PUSH1 0x20 099A 01 ADD 099B 91 SWAP2 099C 50 POP 099D 5B JUMPDEST 099E 50 POP 099F 92 SWAP3 09A0 50 POP 09A1 50 POP 09A2 50 POP 09A3 60 PUSH1 0x40 09A5 51 MLOAD 09A6 80 DUP1 09A7 91 SWAP2 09A8 03 SUB 09A9 90 SWAP1 09AA F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0997 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @09AA return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_09AB: // Incoming jump from 0x0094, if 0xe985e9c5 == stack[-1] // Inputs[1] { @09B2 msg.data.length } 09AB 5B JUMPDEST 09AC 61 PUSH2 0x0a0d 09AF 60 PUSH1 0x04 09B1 80 DUP1 09B2 36 CALLDATASIZE 09B3 03 SUB 09B4 60 PUSH1 0x40 09B6 81 DUP2 09B7 10 LT 09B8 15 ISZERO 09B9 61 PUSH2 0x09c1 09BC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09AC stack[0] = 0x0a0d // @09AF stack[1] = 0x04 // @09B3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09c1, returns to 0x0A0D, if !(msg.data.length - 0x04 < 0x40) label_09BD: // Incoming jump from 0x09BC, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @09C0 memory[0x00:0x00] } 09BD 60 PUSH1 0x00 09BF 80 DUP1 09C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @09C0 revert(memory[0x00:0x00]); } // Block terminates label_09C1: // Incoming call from 0x09BC, returns to 0x0A0D, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @09C2 stack[-2] // @09C3 stack[-1] // @09C7 msg.data[stack[-2]:stack[-2] + 0x20] // @09E7 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 09C1 5B JUMPDEST 09C2 81 DUP2 09C3 01 ADD 09C4 90 SWAP1 09C5 80 DUP1 09C6 80 DUP1 09C7 35 CALLDATALOAD 09C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09DD 16 AND 09DE 90 SWAP1 09DF 60 PUSH1 0x20 09E1 01 ADD 09E2 90 SWAP1 09E3 92 SWAP3 09E4 91 SWAP2 09E5 90 SWAP1 09E6 80 DUP1 09E7 35 CALLDATALOAD 09E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09FD 16 AND 09FE 90 SWAP1 09FF 60 PUSH1 0x20 0A01 01 ADD 0A02 90 SWAP1 0A03 92 SWAP3 0A04 91 SWAP2 0A05 90 SWAP1 0A06 50 POP 0A07 50 POP 0A08 50 POP 0A09 61 PUSH2 0x1419 0A0C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @09E3 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0A03 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1419 label_0A0D: // Incoming return from call to 0x09C1 at 0x09BC // Inputs[4] // { // @0A10 memory[0x40:0x60] // @0A12 stack[-1] // @0A21 memory[0x40:0x60] // @0A26 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A0D 5B JUMPDEST 0A0E 60 PUSH1 0x40 0A10 51 MLOAD 0A11 80 DUP1 0A12 82 DUP3 0A13 15 ISZERO 0A14 15 ISZERO 0A15 15 ISZERO 0A16 15 ISZERO 0A17 81 DUP2 0A18 52 MSTORE 0A19 60 PUSH1 0x20 0A1B 01 ADD 0A1C 91 SWAP2 0A1D 50 POP 0A1E 50 POP 0A1F 60 PUSH1 0x40 0A21 51 MLOAD 0A22 80 DUP1 0A23 91 SWAP2 0A24 03 SUB 0A25 90 SWAP1 0A26 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0A26 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A27: // Incoming jump from 0x01A3 // Inputs[4] // { // @0A2D stack[-1] // @0A79 memory[0x00:0x40] // @0A7D storage[keccak256(memory[0x00:0x40])] // @0A8A stack[-2] // } 0A27 5B JUMPDEST 0A28 60 PUSH1 0x00 0A2A 80 DUP1 0A2B 60 PUSH1 0x00 0A2D 83 DUP4 0A2E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0A4B 19 NOT 0A4C 16 AND 0A4D 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0A6A 19 NOT 0A6B 16 AND 0A6C 81 DUP2 0A6D 52 MSTORE 0A6E 60 PUSH1 0x20 0A70 01 ADD 0A71 90 SWAP1 0A72 81 DUP2 0A73 52 MSTORE 0A74 60 PUSH1 0x20 0A76 01 ADD 0A77 60 PUSH1 0x00 0A79 20 SHA3 0A7A 60 PUSH1 0x00 0A7C 90 SWAP1 0A7D 54 SLOAD 0A7E 90 SWAP1 0A7F 61 PUSH2 0x0100 0A82 0A EXP 0A83 90 SWAP1 0A84 04 DIV 0A85 60 PUSH1 0xff 0A87 16 AND 0A88 90 SWAP1 0A89 50 POP 0A8A 91 SWAP2 0A8B 90 SWAP1 0A8C 50 POP 0A8D 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0A6D memory[0x00:0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A73 memory[0x20:0x40] = 0x00 // @0A8A stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_0A8E: // Incoming call from 0x01C5, returns to 0x01C6 // Inputs[3] // { // @0A94 storage[0x09] // @0AB5 memory[0x40:0x60] // @0AC8 storage[0x09] // } 0A8E 5B JUMPDEST 0A8F 60 PUSH1 0x60 0A91 60 PUSH1 0x09 0A93 80 DUP1 0A94 54 SLOAD 0A95 60 PUSH1 0x01 0A97 81 DUP2 0A98 60 PUSH1 0x01 0A9A 16 AND 0A9B 15 ISZERO 0A9C 61 PUSH2 0x0100 0A9F 02 MUL 0AA0 03 SUB 0AA1 16 AND 0AA2 60 PUSH1 0x02 0AA4 90 SWAP1 0AA5 04 DIV 0AA6 80 DUP1 0AA7 60 PUSH1 0x1f 0AA9 01 ADD 0AAA 60 PUSH1 0x20 0AAC 80 DUP1 0AAD 91 SWAP2 0AAE 04 DIV 0AAF 02 MUL 0AB0 60 PUSH1 0x20 0AB2 01 ADD 0AB3 60 PUSH1 0x40 0AB5 51 MLOAD 0AB6 90 SWAP1 0AB7 81 DUP2 0AB8 01 ADD 0AB9 60 PUSH1 0x40 0ABB 52 MSTORE 0ABC 80 DUP1 0ABD 92 SWAP3 0ABE 91 SWAP2 0ABF 90 SWAP1 0AC0 81 DUP2 0AC1 81 DUP2 0AC2 52 MSTORE 0AC3 60 PUSH1 0x20 0AC5 01 ADD 0AC6 82 DUP3 0AC7 80 DUP1 0AC8 54 SLOAD 0AC9 60 PUSH1 0x01 0ACB 81 DUP2 0ACC 60 PUSH1 0x01 0ACE 16 AND 0ACF 15 ISZERO 0AD0 61 PUSH2 0x0100 0AD3 02 MUL 0AD4 03 SUB 0AD5 16 AND 0AD6 60 PUSH1 0x02 0AD8 90 SWAP1 0AD9 04 DIV 0ADA 80 DUP1 0ADB 15 ISZERO 0ADC 61 PUSH2 0x0b26 0ADF 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0A8F stack[0] = 0x60 // @0ABB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) / 0x20 * 0x20 // @0ABD stack[1] = memory[0x40:0x60] // @0ABE stack[2] = 0x09 // @0ABF stack[3] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02 // @0AC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02 // @0AC5 stack[4] = 0x20 + memory[0x40:0x60] // @0AC6 stack[5] = 0x09 // @0AD9 stack[6] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02 // } // Block ends with conditional jump to 0x0b26, if !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) label_0AE0: // Incoming jump from 0x0ADF, if not !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) // Inputs[1] { @0AE0 stack[-1] } 0AE0 80 DUP1 0AE1 60 PUSH1 0x1f 0AE3 10 LT 0AE4 61 PUSH2 0x0afb 0AE7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0afb, if 0x1f < stack[-1] label_0AE8: // Incoming jump from 0x0AE7, if not 0x1f < stack[-1] // Inputs[4] // { // @0AEC stack[-2] // @0AED storage[stack[-2]] // @0AF0 stack[-3] // @0AF2 stack[-1] // } 0AE8 61 PUSH2 0x0100 0AEB 80 DUP1 0AEC 83 DUP4 0AED 54 SLOAD 0AEE 04 DIV 0AEF 02 MUL 0AF0 83 DUP4 0AF1 52 MSTORE 0AF2 91 SWAP2 0AF3 60 PUSH1 0x20 0AF5 01 ADD 0AF6 91 SWAP2 0AF7 61 PUSH2 0x0b26 0AFA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AF1 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0AF6 stack[-1] = stack[-1] // @0AF6 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b26 label_0AFB: // Incoming jump from 0x0AE7, if 0x1f < stack[-1] // Inputs[5] // { // @0AFC stack[-3] // @0AFD stack[-1] // @0AFF stack[-2] // @0B07 memory[0x00:0x20] // @0B0B storage[keccak256(memory[0x00:0x20])] // } 0AFB 5B JUMPDEST 0AFC 82 DUP3 0AFD 01 ADD 0AFE 91 SWAP2 0AFF 90 SWAP1 0B00 60 PUSH1 0x00 0B02 52 MSTORE 0B03 60 PUSH1 0x20 0B05 60 PUSH1 0x00 0B07 20 SHA3 0B08 90 SWAP1 0B09 5B JUMPDEST 0B0A 81 DUP2 0B0B 54 SLOAD 0B0C 81 DUP2 0B0D 52 MSTORE 0B0E 90 SWAP1 0B0F 60 PUSH1 0x01 0B11 01 ADD 0B12 90 SWAP1 0B13 60 PUSH1 0x20 0B15 01 ADD 0B16 80 DUP1 0B17 83 DUP4 0B18 11 GT 0B19 61 PUSH2 0x0b09 0B1C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AFE stack[-3] = stack[-3] + stack[-1] // @0B02 memory[0x00:0x20] = stack[-2] // @0B0D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B12 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B15 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b09, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B1D: // Incoming jump from 0x0B1C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0B1C, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0B1D stack[-3] // @0B1E stack[-1] // } 0B1D 82 DUP3 0B1E 90 SWAP1 0B1F 03 SUB 0B20 60 PUSH1 0x1f 0B22 16 AND 0B23 82 DUP3 0B24 01 ADD 0B25 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B25 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B25 stack[-1] = stack[-3] // } // Block continues label_0B26: // Incoming jump from 0x0ADF, if !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) // Incoming jump from 0x0AFA // Incoming jump from 0x0B25 // Inputs[3] // { // @0B2C stack[-6] // @0B2C stack[-7] // @0B2E stack[-8] // } 0B26 5B JUMPDEST 0B27 50 POP 0B28 50 POP 0B29 50 POP 0B2A 50 POP 0B2B 50 POP 0B2C 90 SWAP1 0B2D 50 POP 0B2E 90 SWAP1 0B2F 56 *JUMP // Stack delta = -7 // Outputs[1] { @0B2E stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0B30: // Incoming jump from 0x026C // Incoming call from 0x1581, returns to 0x1582 // Inputs[1] { @0B36 stack[-1] } 0B30 5B JUMPDEST 0B31 60 PUSH1 0x00 0B33 61 PUSH2 0x0b3b 0B36 82 DUP3 0B37 61 PUSH2 0x14ad 0B3A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B31 stack[0] = 0x00 // @0B33 stack[1] = 0x0b3b // @0B36 stack[2] = stack[-1] // } // Block ends with call to 0x14ad, returns to 0x0B3B label_0B3B: // Incoming return from call to 0x14AD at 0x0B3A // Inputs[1] { @0B3C stack[-1] } 0B3B 5B JUMPDEST 0B3C 15 ISZERO 0B3D 15 ISZERO 0B3E 61 PUSH2 0x0b46 0B41 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b46, if !!stack[-1] label_0B42: // Incoming jump from 0x0B41, if not !!stack[-1] // Inputs[1] { @0B45 memory[0x00:0x00] } 0B42 60 PUSH1 0x00 0B44 80 DUP1 0B45 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B45 revert(memory[0x00:0x00]); } // Block terminates label_0B46: // Incoming jump from 0x0B41, if !!stack[-1] // Inputs[5] // { // @0B4B stack[-2] // @0B59 memory[0x00:0x40] // @0B5D storage[keccak256(memory[0x00:0x40])] // @0B7B stack[-1] // @0B7D stack[-3] // } 0B46 5B JUMPDEST 0B47 60 PUSH1 0x02 0B49 60 PUSH1 0x00 0B4B 83 DUP4 0B4C 81 DUP2 0B4D 52 MSTORE 0B4E 60 PUSH1 0x20 0B50 01 ADD 0B51 90 SWAP1 0B52 81 DUP2 0B53 52 MSTORE 0B54 60 PUSH1 0x20 0B56 01 ADD 0B57 60 PUSH1 0x00 0B59 20 SHA3 0B5A 60 PUSH1 0x00 0B5C 90 SWAP1 0B5D 54 SLOAD 0B5E 90 SWAP1 0B5F 61 PUSH2 0x0100 0B62 0A EXP 0B63 90 SWAP1 0B64 04 DIV 0B65 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B7A 16 AND 0B7B 90 SWAP1 0B7C 50 POP 0B7D 91 SWAP2 0B7E 90 SWAP1 0B7F 50 POP 0B80 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0B4D memory[0x00:0x20] = stack[-2] // @0B53 memory[0x20:0x40] = 0x02 // @0B7D stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_0B81: // Incoming jump from 0x02FA // Inputs[1] { @0B87 stack[-1] } 0B81 5B JUMPDEST 0B82 60 PUSH1 0x00 0B84 61 PUSH2 0x0b8c 0B87 82 DUP3 0B88 61 PUSH2 0x0ff9 0B8B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B82 stack[0] = 0x00 // @0B84 stack[1] = 0x0b8c // @0B87 stack[2] = stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x0B8C label_0B8C: // Incoming return from call to 0x0FF9 at 0x0B8B // Inputs[3] // { // @0B8D stack[-1] // @0B8D stack[-2] // @0BA6 stack[-4] // } 0B8C 5B JUMPDEST 0B8D 90 SWAP1 0B8E 50 POP 0B8F 80 DUP1 0B90 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BA5 16 AND 0BA6 83 DUP4 0BA7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BBC 16 AND 0BBD 14 EQ 0BBE 15 ISZERO 0BBF 15 ISZERO 0BC0 15 ISZERO 0BC1 61 PUSH2 0x0bc9 0BC4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0B8D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0bc9, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0BC5: // Incoming jump from 0x0BC4, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0BC8 memory[0x00:0x00] } 0BC5 60 PUSH1 0x00 0BC7 80 DUP1 0BC8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BC8 revert(memory[0x00:0x00]); } // Block terminates label_0BC9: // Incoming jump from 0x0BC4, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[2] // { // @0BCA stack[-1] // @0BE1 msg.sender // } 0BC9 5B JUMPDEST 0BCA 80 DUP1 0BCB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BE0 16 AND 0BE1 33 CALLER 0BE2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BF7 16 AND 0BF8 14 EQ 0BF9 80 DUP1 0BFA 61 PUSH2 0x0c09 0BFD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BF8 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] } // Block ends with conditional jump to 0x0c09, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_0BFE: // Incoming jump from 0x0BFD, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @0C02 stack[-2] // @0C03 msg.sender // } 0BFE 50 POP 0BFF 61 PUSH2 0x0c08 0C02 81 DUP2 0C03 33 CALLER 0C04 61 PUSH2 0x1419 0C07 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BFF stack[-1] = 0x0c08 // @0C02 stack[0] = stack[-2] // @0C03 stack[1] = msg.sender // } // Block ends with call to 0x1419, returns to 0x0C08 label_0C08: // Incoming return from call to 0x1419 at 0x0C07 0C08 5B JUMPDEST // Stack delta = +0 // Block continues label_0C09: // Incoming jump from 0x0C08 // Incoming jump from 0x0BFD, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @0C0A stack[-1] } 0C09 5B JUMPDEST 0C0A 15 ISZERO 0C0B 15 ISZERO 0C0C 61 PUSH2 0x0c14 0C0F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c14, if !!stack[-1] label_0C10: // Incoming jump from 0x0C0F, if not !!stack[-1] // Inputs[1] { @0C13 memory[0x00:0x00] } 0C10 60 PUSH1 0x00 0C12 80 DUP1 0C13 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C13 revert(memory[0x00:0x00]); } // Block terminates label_0C14: // Incoming jump from 0x0C0F, if !!stack[-1] // Inputs[9] // { // @0C15 stack[-3] // @0C1A stack[-2] // @0C28 memory[0x00:0x40] // @0C30 storage[keccak256(memory[0x00:0x40])] // @0C7F stack[-1] // @0CB9 memory[0x40:0x60] // @0CBC memory[0x40:0x60] // @0CC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0CC5 stack[-4] // } 0C14 5B JUMPDEST 0C15 82 DUP3 0C16 60 PUSH1 0x02 0C18 60 PUSH1 0x00 0C1A 84 DUP5 0C1B 81 DUP2 0C1C 52 MSTORE 0C1D 60 PUSH1 0x20 0C1F 01 ADD 0C20 90 SWAP1 0C21 81 DUP2 0C22 52 MSTORE 0C23 60 PUSH1 0x20 0C25 01 ADD 0C26 60 PUSH1 0x00 0C28 20 SHA3 0C29 60 PUSH1 0x00 0C2B 61 PUSH2 0x0100 0C2E 0A EXP 0C2F 81 DUP2 0C30 54 SLOAD 0C31 81 DUP2 0C32 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C47 02 MUL 0C48 19 NOT 0C49 16 AND 0C4A 90 SWAP1 0C4B 83 DUP4 0C4C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C61 16 AND 0C62 02 MUL 0C63 17 OR 0C64 90 SWAP1 0C65 55 SSTORE 0C66 50 POP 0C67 81 DUP2 0C68 83 DUP4 0C69 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C7E 16 AND 0C7F 82 DUP3 0C80 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C95 16 AND 0C96 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0CB7 60 PUSH1 0x40 0CB9 51 MLOAD 0CBA 60 PUSH1 0x40 0CBC 51 MLOAD 0CBD 80 DUP1 0CBE 91 SWAP2 0CBF 03 SUB 0CC0 90 SWAP1 0CC1 A4 LOG4 0CC2 50 POP 0CC3 50 POP 0CC4 50 POP 0CC5 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0C1C memory[0x00:0x20] = stack[-2] // @0C22 memory[0x20:0x40] = 0x02 // @0C65 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @0CC1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0CC6: // Incoming call from 0x0FCA, returns to 0x0FCB // Incoming call from 0x0304, returns to 0x0305 // Incoming call from 0x15FB, returns to 0x15FC // Inputs[2] // { // @0CCC storage[0x07] // @0CD1 stack[-1] // } 0CC6 5B JUMPDEST 0CC7 60 PUSH1 0x00 0CC9 60 PUSH1 0x07 0CCB 80 DUP1 0CCC 54 SLOAD 0CCD 90 SWAP1 0CCE 50 POP 0CCF 90 SWAP1 0CD0 50 POP 0CD1 90 SWAP1 0CD2 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CD1 stack[-1] = storage[0x07] } // Block ends with unconditional jump to stack[-1] label_0CD3: // Incoming jump from 0x0386 // Incoming call from 0x1332, returns to 0x1333 // Inputs[2] // { // @0CD7 msg.sender // @0CD8 stack[-1] // } 0CD3 5B JUMPDEST 0CD4 61 PUSH2 0x0cdd 0CD7 33 CALLER 0CD8 82 DUP3 0CD9 61 PUSH2 0x151f 0CDC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CD4 stack[0] = 0x0cdd // @0CD7 stack[1] = msg.sender // @0CD8 stack[2] = stack[-1] // } // Block ends with call to 0x151f, returns to 0x0CDD label_0CDD: // Incoming return from call to 0x151F at 0x0CDC // Inputs[1] { @0CDE stack[-1] } 0CDD 5B JUMPDEST 0CDE 15 ISZERO 0CDF 15 ISZERO 0CE0 61 PUSH2 0x0ce8 0CE3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ce8, if !!stack[-1] label_0CE4: // Incoming jump from 0x0CE3, if not !!stack[-1] // Inputs[1] { @0CE7 memory[0x00:0x00] } 0CE4 60 PUSH1 0x00 0CE6 80 DUP1 0CE7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CE7 revert(memory[0x00:0x00]); } // Block terminates label_0CE8: // Incoming jump from 0x0CE3, if !!stack[-1] // Inputs[3] // { // @0CEC stack[-3] // @0CED stack[-2] // @0CEE stack[-1] // } 0CE8 5B JUMPDEST 0CE9 61 PUSH2 0x0cf3 0CEC 83 DUP4 0CED 83 DUP4 0CEE 83 DUP4 0CEF 61 PUSH2 0x15b4 0CF2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CE9 stack[0] = 0x0cf3 // @0CEC stack[1] = stack[-3] // @0CED stack[2] = stack[-2] // @0CEE stack[3] = stack[-1] // } // Block ends with call to 0x15b4, returns to 0x0CF3 label_0CF3: // Incoming return from call to 0x15B4 at 0x0CF2 // Inputs[1] { @0CF7 stack[-4] } 0CF3 5B JUMPDEST 0CF4 50 POP 0CF5 50 POP 0CF6 50 POP 0CF7 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0CF8: // Incoming jump from 0x03D4 // Inputs[1] { @0CFE stack[-2] } 0CF8 5B JUMPDEST 0CF9 60 PUSH1 0x00 0CFB 61 PUSH2 0x0d03 0CFE 83 DUP4 0CFF 61 PUSH2 0x1077 0D02 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CF9 stack[0] = 0x00 // @0CFB stack[1] = 0x0d03 // @0CFE stack[2] = stack[-2] // } // Block ends with call to 0x1077, returns to 0x0D03 label_0D03: // Incoming return from call to 0x1077 at 0x0D02 // Inputs[2] // { // @0D04 stack[-3] // @0D05 stack[-1] // } 0D03 5B JUMPDEST 0D04 82 DUP3 0D05 10 LT 0D06 15 ISZERO 0D07 15 ISZERO 0D08 61 PUSH2 0x0d10 0D0B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d10, if !!(stack[-3] < stack[-1]) label_0D0C: // Incoming jump from 0x0D0B, if not !!(stack[-3] < stack[-1]) // Inputs[1] { @0D0F memory[0x00:0x00] } 0D0C 60 PUSH1 0x00 0D0E 80 DUP1 0D0F FD *REVERT // Stack delta = +0 // Outputs[1] { @0D0F revert(memory[0x00:0x00]); } // Block terminates label_0D10: // Incoming jump from 0x0D0B, if !!(stack[-3] < stack[-1]) // Inputs[4] // { // @0D15 stack[-3] // @0D4F memory[0x00:0x40] // @0D50 stack[-2] // @0D52 storage[keccak256(memory[0x00:0x40])] // } 0D10 5B JUMPDEST 0D11 60 PUSH1 0x05 0D13 60 PUSH1 0x00 0D15 84 DUP5 0D16 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D2B 16 AND 0D2C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D41 16 AND 0D42 81 DUP2 0D43 52 MSTORE 0D44 60 PUSH1 0x20 0D46 01 ADD 0D47 90 SWAP1 0D48 81 DUP2 0D49 52 MSTORE 0D4A 60 PUSH1 0x20 0D4C 01 ADD 0D4D 60 PUSH1 0x00 0D4F 20 SHA3 0D50 82 DUP3 0D51 81 DUP2 0D52 54 SLOAD 0D53 81 DUP2 0D54 10 LT 0D55 15 ISZERO 0D56 15 ISZERO 0D57 61 PUSH2 0x0d5c 0D5A 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0D43 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0D49 memory[0x20:0x40] = 0x05 // @0D4F stack[0] = keccak256(memory[0x00:0x40]) // @0D50 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0d5c, if !!(stack[-2] < storage[keccak256(memory[0x00:0x40])]) label_0D5B: // Incoming jump from 0x0D5A, if not !!(stack[-2] < storage[keccak256(memory[0x00:0x40])]) 0D5B FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D5B assert(); } // Block terminates label_0D5C: // Incoming jump from 0x0D5A, if !!(stack[-2] < storage[keccak256(memory[0x00:0x40])]) // Inputs[7] // { // @0D5D stack[-1] // @0D5D stack[-2] // @0D65 memory[0x00:0x20] // @0D67 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0D68 stack[-3] // @0D6A stack[-6] // @0D6B stack[-5] // } 0D5C 5B JUMPDEST 0D5D 90 SWAP1 0D5E 60 PUSH1 0x00 0D60 52 MSTORE 0D61 60 PUSH1 0x20 0D63 60 PUSH1 0x00 0D65 20 SHA3 0D66 01 ADD 0D67 54 SLOAD 0D68 90 SWAP1 0D69 50 POP 0D6A 92 SWAP3 0D6B 91 SWAP2 0D6C 50 POP 0D6D 50 POP 0D6E 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @0D60 memory[0x00:0x20] = stack[-2] // @0D6A stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] label_0D6F: // Incoming jump from 0x0456 // Inputs[4] // { // @0D73 stack[-3] // @0D74 stack[-2] // @0D75 stack[-1] // @0D7A memory[0x40:0x60] // } 0D6F 5B JUMPDEST 0D70 61 PUSH2 0x0d8b 0D73 83 DUP4 0D74 83 DUP4 0D75 83 DUP4 0D76 60 PUSH1 0x20 0D78 60 PUSH1 0x40 0D7A 51 MLOAD 0D7B 90 SWAP1 0D7C 81 DUP2 0D7D 01 ADD 0D7E 60 PUSH1 0x40 0D80 52 MSTORE 0D81 80 DUP1 0D82 60 PUSH1 0x00 0D84 81 DUP2 0D85 52 MSTORE 0D86 50 POP 0D87 61 PUSH2 0x1328 0D8A 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0D70 stack[0] = 0x0d8b // @0D73 stack[1] = stack[-3] // @0D74 stack[2] = stack[-2] // @0D75 stack[3] = stack[-1] // @0D7B stack[4] = memory[0x40:0x60] // @0D80 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0D85 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1328, returns to 0x0D8B label_0D8B: // Incoming return from call to 0x1328 at 0x0D8A // Inputs[1] { @0D8F stack[-4] } 0D8B 5B JUMPDEST 0D8C 50 POP 0D8D 50 POP 0D8E 50 POP 0D8F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0D90: // Incoming jump from 0x0484 // Inputs[2] // { // @0D94 msg.sender // @0D95 stack[-1] // } 0D90 5B JUMPDEST 0D91 61 PUSH2 0x0d9a 0D94 33 CALLER 0D95 82 DUP3 0D96 61 PUSH2 0x151f 0D99 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D91 stack[0] = 0x0d9a // @0D94 stack[1] = msg.sender // @0D95 stack[2] = stack[-1] // } // Block ends with call to 0x151f, returns to 0x0D9A label_0D9A: // Incoming return from call to 0x151F at 0x0D99 // Inputs[1] { @0D9B stack[-1] } 0D9A 5B JUMPDEST 0D9B 15 ISZERO 0D9C 15 ISZERO 0D9D 61 PUSH2 0x0da5 0DA0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0da5, if !!stack[-1] label_0DA1: // Incoming jump from 0x0DA0, if not !!stack[-1] // Inputs[1] { @0DA4 memory[0x00:0x00] } 0DA1 60 PUSH1 0x00 0DA3 80 DUP1 0DA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DA4 revert(memory[0x00:0x00]); } // Block terminates label_0DA5: // Incoming jump from 0x0DA0, if !!stack[-1] // Inputs[1] { @0DA9 stack[-1] } 0DA5 5B JUMPDEST 0DA6 61 PUSH2 0x0dae 0DA9 81 DUP2 0DAA 61 PUSH2 0x15d8 0DAD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DA6 stack[0] = 0x0dae // @0DA9 stack[1] = stack[-1] // } // Block ends with call to 0x15d8, returns to 0x0DAE label_0DAE: // Incoming return from call to 0x15D8 at 0x0DAD // Inputs[1] { @0DB0 stack[-2] } 0DAE 5B JUMPDEST 0DAF 50 POP 0DB0 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0DB1: // Incoming jump from 0x055F // Inputs[1] { @0DB7 msg.sender } 0DB1 5B JUMPDEST 0DB2 60 PUSH1 0x00 0DB4 61 PUSH2 0x0dbc 0DB7 33 CALLER 0DB8 61 PUSH2 0x130b 0DBB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DB2 stack[0] = 0x00 // @0DB4 stack[1] = 0x0dbc // @0DB7 stack[2] = msg.sender // } // Block ends with call to 0x130b, returns to 0x0DBC label_0DBC: // Incoming return from call to 0x130B at 0x0DBB // Inputs[1] { @0DBD stack[-1] } 0DBC 5B JUMPDEST 0DBD 15 ISZERO 0DBE 15 ISZERO 0DBF 61 PUSH2 0x0dc7 0DC2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dc7, if !!stack[-1] label_0DC3: // Incoming jump from 0x0DC2, if not !!stack[-1] // Inputs[1] { @0DC6 memory[0x00:0x00] } 0DC3 60 PUSH1 0x00 0DC5 80 DUP1 0DC6 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DC6 revert(memory[0x00:0x00]); } // Block terminates label_0DC7: // Incoming jump from 0x0DC2, if !!stack[-1] 0DC7 5B JUMPDEST 0DC8 60 PUSH1 0x00 0DCA 61 PUSH2 0x0dd1 0DCD 61 PUSH2 0x15ed 0DD0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DC8 stack[0] = 0x00 // @0DCA stack[1] = 0x0dd1 // } // Block ends with call to 0x15ed, returns to 0x0DD1 label_0DD1: // Incoming return from call to 0x15ED at 0x0DD0 // Inputs[7] // { // @0DD2 stack[-2] // @0DD2 stack[-1] // @0DD8 stack[-5] // @0E12 memory[0x00:0x40] // @0E13 stack[-4] // @0E16 memory[0x40:0x60] // @0E1A memory[stack[-4]:stack[-4] + 0x20] // } 0DD1 5B JUMPDEST 0DD2 90 SWAP1 0DD3 50 POP 0DD4 60 PUSH1 0x0d 0DD6 60 PUSH1 0x00 0DD8 85 DUP6 0DD9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DEE 16 AND 0DEF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E04 16 AND 0E05 81 DUP2 0E06 52 MSTORE 0E07 60 PUSH1 0x20 0E09 01 ADD 0E0A 90 SWAP1 0E0B 81 DUP2 0E0C 52 MSTORE 0E0D 60 PUSH1 0x20 0E0F 01 ADD 0E10 60 PUSH1 0x00 0E12 20 SHA3 0E13 83 DUP4 0E14 60 PUSH1 0x40 0E16 51 MLOAD 0E17 80 DUP1 0E18 82 DUP3 0E19 80 DUP1 0E1A 51 MLOAD 0E1B 90 SWAP1 0E1C 60 PUSH1 0x20 0E1E 01 ADD 0E1F 90 SWAP1 0E20 80 DUP1 0E21 83 DUP4 0E22 83 DUP4 0E23 5B JUMPDEST 0E24 60 PUSH1 0x20 0E26 83 DUP4 0E27 10 LT 0E28 15 ISZERO 0E29 15 ISZERO 0E2A 61 PUSH2 0x0e48 0E2D 57 *JUMPI // Stack delta = +8 // Outputs[12] // { // @0DD2 stack[-2] = stack[-1] // @0E06 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0E0C memory[0x20:0x40] = 0x0d // @0E12 stack[-1] = keccak256(memory[0x00:0x40]) // @0E13 stack[0] = stack[-4] // @0E16 stack[1] = memory[0x40:0x60] // @0E17 stack[2] = memory[0x40:0x60] // @0E1F stack[3] = 0x20 + stack[-4] // @0E1F stack[4] = memory[stack[-4]:stack[-4] + 0x20] // @0E20 stack[5] = memory[stack[-4]:stack[-4] + 0x20] // @0E21 stack[6] = memory[0x40:0x60] // @0E22 stack[7] = 0x20 + stack[-4] // } // Block ends with conditional jump to 0x0e48, if !!(memory[stack[-4]:stack[-4] + 0x20] < 0x20) label_0E2E: // Incoming jump from 0x0E2D, if not !!(stack[-3] < 0x20) // Incoming jump from 0x0E2D, if not !!(memory[stack[-4]:stack[-4] + 0x20] < 0x20) // Inputs[4] // { // @0E2E stack[-1] // @0E2F memory[stack[-1]:stack[-1] + 0x20] // @0E30 stack[-2] // @0E40 stack[-3] // } 0E2E 80 DUP1 0E2F 51 MLOAD 0E30 82 DUP3 0E31 52 MSTORE 0E32 60 PUSH1 0x20 0E34 82 DUP3 0E35 01 ADD 0E36 91 SWAP2 0E37 50 POP 0E38 60 PUSH1 0x20 0E3A 81 DUP2 0E3B 01 ADD 0E3C 90 SWAP1 0E3D 50 POP 0E3E 60 PUSH1 0x20 0E40 83 DUP4 0E41 03 SUB 0E42 92 SWAP3 0E43 50 POP 0E44 61 PUSH2 0x0e23 0E47 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0E31 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0E36 stack[-2] = stack[-2] + 0x20 // @0E3C stack[-1] = stack[-1] + 0x20 // @0E42 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x0e23 label_0E48: // Incoming jump from 0x0E2D, if !!(stack[-3] < 0x20) // Incoming jump from 0x0E2D, if !!(memory[stack[-4]:stack[-4] + 0x20] < 0x20) // Inputs[13] // { // @0E4B stack[-3] // @0E56 stack[-1] // @0E57 memory[stack[-1]:stack[-1] + 0x20] // @0E5A stack[-2] // @0E5B memory[stack[-2]:stack[-2] + 0x20] // @0E68 stack[-4] // @0E68 stack[-5] // @0E6A stack[-6] // @0E6B stack[-8] // @0E6E stack[-9] // @0E76 memory[0x40:0x60] // @0E7B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]] // @0E7F storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]])] // } 0E48 5B JUMPDEST 0E49 60 PUSH1 0x01 0E4B 83 DUP4 0E4C 60 PUSH1 0x20 0E4E 03 SUB 0E4F 61 PUSH2 0x0100 0E52 0A EXP 0E53 03 SUB 0E54 80 DUP1 0E55 19 NOT 0E56 82 DUP3 0E57 51 MLOAD 0E58 16 AND 0E59 81 DUP2 0E5A 84 DUP5 0E5B 51 MLOAD 0E5C 16 AND 0E5D 80 DUP1 0E5E 82 DUP3 0E5F 17 OR 0E60 85 DUP6 0E61 52 MSTORE 0E62 50 POP 0E63 50 POP 0E64 50 POP 0E65 50 POP 0E66 50 POP 0E67 50 POP 0E68 90 SWAP1 0E69 50 POP 0E6A 01 ADD 0E6B 91 SWAP2 0E6C 50 POP 0E6D 50 POP 0E6E 90 SWAP1 0E6F 81 DUP2 0E70 52 MSTORE 0E71 60 PUSH1 0x20 0E73 01 ADD 0E74 60 PUSH1 0x40 0E76 51 MLOAD 0E77 80 DUP1 0E78 91 SWAP2 0E79 03 SUB 0E7A 90 SWAP1 0E7B 20 SHA3 0E7C 60 PUSH1 0x00 0E7E 90 SWAP1 0E7F 54 SLOAD 0E80 90 SWAP1 0E81 61 PUSH2 0x0100 0E84 0A EXP 0E85 90 SWAP1 0E86 04 DIV 0E87 60 PUSH1 0xff 0E89 16 AND 0E8A 15 ISZERO 0E8B 15 ISZERO 0E8C 15 ISZERO 0E8D 61 PUSH2 0x0ee1 0E90 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @0E61 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @0E70 memory[stack[-4] + stack[-6]:stack[-4] + stack[-6] + 0x20] = stack[-9] // } // Block ends with conditional jump to 0x0ee1, if !!!(0xff & storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]])] / 0x0100 ** 0x00) label_0E91: // Incoming jump from 0x0E90, if not !!!(0xff & storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]])] / 0x0100 ** 0x00) // Inputs[3] // { // @0E93 memory[0x40:0x60] // @0EDB memory[0x40:0x60] // @0EE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E91 60 PUSH1 0x40 0E93 51 MLOAD 0E94 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0EB5 81 DUP2 0EB6 52 MSTORE 0EB7 60 PUSH1 0x04 0EB9 01 ADD 0EBA 80 DUP1 0EBB 80 DUP1 0EBC 60 PUSH1 0x20 0EBE 01 ADD 0EBF 82 DUP3 0EC0 81 DUP2 0EC1 03 SUB 0EC2 82 DUP3 0EC3 52 MSTORE 0EC4 60 PUSH1 0x29 0EC6 81 DUP2 0EC7 52 MSTORE 0EC8 60 PUSH1 0x20 0ECA 01 ADD 0ECB 80 DUP1 0ECC 61 PUSH2 0x2615 0ECF 60 PUSH1 0x29 0ED1 91 SWAP2 0ED2 39 CODECOPY 0ED3 60 PUSH1 0x40 0ED5 01 ADD 0ED6 91 SWAP2 0ED7 50 POP 0ED8 50 POP 0ED9 60 PUSH1 0x40 0EDB 51 MLOAD 0EDC 80 DUP1 0EDD 91 SWAP2 0EDE 03 SUB 0EDF 90 SWAP1 0EE0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0EB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0EC3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0EC7 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @0ED2 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x2615:0x263e] // @0EE0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EE1: // Incoming jump from 0x0E90, if !!!(0xff & storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]])] / 0x0100 ** 0x00) // Inputs[2] // { // @0EE5 stack[-4] // @0EE6 stack[-1] // } 0EE1 5B JUMPDEST 0EE2 61 PUSH2 0x0eeb 0EE5 84 DUP5 0EE6 82 DUP3 0EE7 61 PUSH2 0x160f 0EEA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EE2 stack[0] = 0x0eeb // @0EE5 stack[1] = stack[-4] // @0EE6 stack[2] = stack[-1] // } // Block ends with call to 0x160f, returns to 0x0EEB label_0EEB: // Incoming return from call to 0x160F at 0x0EEA // Inputs[2] // { // @0EEF stack[-1] // @0EF0 stack[-3] // } 0EEB 5B JUMPDEST 0EEC 61 PUSH2 0x0ef5 0EEF 81 DUP2 0EF0 84 DUP5 0EF1 61 PUSH2 0x1630 0EF4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EEC stack[0] = 0x0ef5 // @0EEF stack[1] = stack[-1] // @0EF0 stack[2] = stack[-3] // } // Block ends with call to 0x1630, returns to 0x0EF5 label_0EF5: // Incoming return from call to 0x1630 at 0x0EF4 // Inputs[5] // { // @0EFC stack[-4] // @0F36 memory[0x00:0x40] // @0F37 stack[-3] // @0F3A memory[0x40:0x60] // @0F3E memory[stack[-3]:stack[-3] + 0x20] // } 0EF5 5B JUMPDEST 0EF6 60 PUSH1 0x01 0EF8 60 PUSH1 0x0d 0EFA 60 PUSH1 0x00 0EFC 86 DUP7 0EFD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F12 16 AND 0F13 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F28 16 AND 0F29 81 DUP2 0F2A 52 MSTORE 0F2B 60 PUSH1 0x20 0F2D 01 ADD 0F2E 90 SWAP1 0F2F 81 DUP2 0F30 52 MSTORE 0F31 60 PUSH1 0x20 0F33 01 ADD 0F34 60 PUSH1 0x00 0F36 20 SHA3 0F37 84 DUP5 0F38 60 PUSH1 0x40 0F3A 51 MLOAD 0F3B 80 DUP1 0F3C 82 DUP3 0F3D 80 DUP1 0F3E 51 MLOAD 0F3F 90 SWAP1 0F40 60 PUSH1 0x20 0F42 01 ADD 0F43 90 SWAP1 0F44 80 DUP1 0F45 83 DUP4 0F46 83 DUP4 0F47 5B JUMPDEST 0F48 60 PUSH1 0x20 0F4A 83 DUP4 0F4B 10 LT 0F4C 15 ISZERO 0F4D 15 ISZERO 0F4E 61 PUSH2 0x0f6c 0F51 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0EF6 stack[0] = 0x01 // @0F2A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0F30 memory[0x20:0x40] = 0x0d // @0F36 stack[1] = keccak256(memory[0x00:0x40]) // @0F37 stack[2] = stack[-3] // @0F3A stack[3] = memory[0x40:0x60] // @0F3B stack[4] = memory[0x40:0x60] // @0F43 stack[5] = 0x20 + stack[-3] // @0F43 stack[6] = memory[stack[-3]:stack[-3] + 0x20] // @0F44 stack[7] = memory[stack[-3]:stack[-3] + 0x20] // @0F45 stack[8] = memory[0x40:0x60] // @0F46 stack[9] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0f6c, if !!(memory[stack[-3]:stack[-3] + 0x20] < 0x20) label_0F52: // Incoming jump from 0x0F51, if not !!(stack[-3] < 0x20) // Incoming jump from 0x0F51, if not !!(memory[stack[-3]:stack[-3] + 0x20] < 0x20) // Inputs[4] // { // @0F52 stack[-1] // @0F53 memory[stack[-1]:stack[-1] + 0x20] // @0F54 stack[-2] // @0F64 stack[-3] // } 0F52 80 DUP1 0F53 51 MLOAD 0F54 82 DUP3 0F55 52 MSTORE 0F56 60 PUSH1 0x20 0F58 82 DUP3 0F59 01 ADD 0F5A 91 SWAP2 0F5B 50 POP 0F5C 60 PUSH1 0x20 0F5E 81 DUP2 0F5F 01 ADD 0F60 90 SWAP1 0F61 50 POP 0F62 60 PUSH1 0x20 0F64 83 DUP4 0F65 03 SUB 0F66 92 SWAP3 0F67 50 POP 0F68 61 PUSH2 0x0f47 0F6B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0F55 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0F5A stack[-2] = stack[-2] + 0x20 // @0F60 stack[-1] = stack[-1] + 0x20 // @0F66 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x0f47 label_0F6C: // Incoming jump from 0x0F51, if !!(stack[-3] < 0x20) // Incoming jump from 0x0F51, if !!(memory[stack[-3]:stack[-3] + 0x20] < 0x20) // Inputs[17] // { // @0F6F stack[-3] // @0F7A stack[-1] // @0F7B memory[stack[-1]:stack[-1] + 0x20] // @0F7E stack[-2] // @0F7F memory[stack[-2]:stack[-2] + 0x20] // @0F8C stack[-5] // @0F8C stack[-4] // @0F8E stack[-6] // @0F8F stack[-8] // @0F92 stack[-9] // @0F9A memory[0x40:0x60] // @0F9F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]] // @0FA7 storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]])] // @0FAF stack[-10] // @0FB9 stack[-12] // @0FBC stack[-15] // @0FBD stack[-14] // } 0F6C 5B JUMPDEST 0F6D 60 PUSH1 0x01 0F6F 83 DUP4 0F70 60 PUSH1 0x20 0F72 03 SUB 0F73 61 PUSH2 0x0100 0F76 0A EXP 0F77 03 SUB 0F78 80 DUP1 0F79 19 NOT 0F7A 82 DUP3 0F7B 51 MLOAD 0F7C 16 AND 0F7D 81 DUP2 0F7E 84 DUP5 0F7F 51 MLOAD 0F80 16 AND 0F81 80 DUP1 0F82 82 DUP3 0F83 17 OR 0F84 85 DUP6 0F85 52 MSTORE 0F86 50 POP 0F87 50 POP 0F88 50 POP 0F89 50 POP 0F8A 50 POP 0F8B 50 POP 0F8C 90 SWAP1 0F8D 50 POP 0F8E 01 ADD 0F8F 91 SWAP2 0F90 50 POP 0F91 50 POP 0F92 90 SWAP1 0F93 81 DUP2 0F94 52 MSTORE 0F95 60 PUSH1 0x20 0F97 01 ADD 0F98 60 PUSH1 0x40 0F9A 51 MLOAD 0F9B 80 DUP1 0F9C 91 SWAP2 0F9D 03 SUB 0F9E 90 SWAP1 0F9F 20 SHA3 0FA0 60 PUSH1 0x00 0FA2 61 PUSH2 0x0100 0FA5 0A EXP 0FA6 81 DUP2 0FA7 54 SLOAD 0FA8 81 DUP2 0FA9 60 PUSH1 0xff 0FAB 02 MUL 0FAC 19 NOT 0FAD 16 AND 0FAE 90 SWAP1 0FAF 83 DUP4 0FB0 15 ISZERO 0FB1 15 ISZERO 0FB2 02 MUL 0FB3 17 OR 0FB4 90 SWAP1 0FB5 55 SSTORE 0FB6 50 POP 0FB7 60 PUSH1 0x01 0FB9 91 SWAP2 0FBA 50 POP 0FBB 50 POP 0FBC 92 SWAP3 0FBD 91 SWAP2 0FBE 50 POP 0FBF 50 POP 0FC0 56 *JUMP // Stack delta = -14 // Outputs[4] // { // @0F85 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @0F94 memory[stack[-4] + stack[-6]:stack[-4] + stack[-6] + 0x20] = stack[-9] // @0FB5 storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]])] = !!stack[-10] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + stack[-4] + stack[-6]) - memory[0x40:0x60]])]) // @0FBC stack[-15] = 0x01 // } // Block ends with unconditional jump to stack[-15] label_0FC1: // Incoming jump from 0x05A5 0FC1 5B JUMPDEST 0FC2 60 PUSH1 0x00 0FC4 61 PUSH2 0x0fcb 0FC7 61 PUSH2 0x0cc6 0FCA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FC2 stack[0] = 0x00 // @0FC4 stack[1] = 0x0fcb // } // Block ends with call to 0x0cc6, returns to 0x0FCB label_0FCB: // Incoming return from call to 0x0CC6 at 0x0FCA // Inputs[2] // { // @0FCC stack[-3] // @0FCD stack[-1] // } 0FCB 5B JUMPDEST 0FCC 82 DUP3 0FCD 10 LT 0FCE 15 ISZERO 0FCF 15 ISZERO 0FD0 61 PUSH2 0x0fd8 0FD3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fd8, if !!(stack[-3] < stack[-1]) label_0FD4: // Incoming jump from 0x0FD3, if not !!(stack[-3] < stack[-1]) // Inputs[1] { @0FD7 memory[0x00:0x00] } 0FD4 60 PUSH1 0x00 0FD6 80 DUP1 0FD7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FD7 revert(memory[0x00:0x00]); } // Block terminates label_0FD8: // Incoming jump from 0x0FD3, if !!(stack[-3] < stack[-1]) // Inputs[2] // { // @0FDB stack[-2] // @0FDD storage[0x07] // } 0FD8 5B JUMPDEST 0FD9 60 PUSH1 0x07 0FDB 82 DUP3 0FDC 81 DUP2 0FDD 54 SLOAD 0FDE 81 DUP2 0FDF 10 LT 0FE0 15 ISZERO 0FE1 15 ISZERO 0FE2 61 PUSH2 0x0fe7 0FE5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0FD9 stack[0] = 0x07 // @0FDB stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0fe7, if !!(stack[-2] < storage[0x07]) label_0FE6: // Incoming jump from 0x0FE5, if not !!(stack[-2] < storage[0x07]) 0FE6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0FE6 assert(); } // Block terminates label_0FE7: // Incoming jump from 0x0FE5, if !!(stack[-2] < storage[0x07]) // Inputs[7] // { // @0FE8 stack[-2] // @0FE8 stack[-1] // @0FF0 memory[0x00:0x20] // @0FF2 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0FF3 stack[-3] // @0FF5 stack[-5] // @0FF6 stack[-4] // } 0FE7 5B JUMPDEST 0FE8 90 SWAP1 0FE9 60 PUSH1 0x00 0FEB 52 MSTORE 0FEC 60 PUSH1 0x20 0FEE 60 PUSH1 0x00 0FF0 20 SHA3 0FF1 01 ADD 0FF2 54 SLOAD 0FF3 90 SWAP1 0FF4 50 POP 0FF5 91 SWAP2 0FF6 90 SWAP1 0FF7 50 POP 0FF8 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0FEB memory[0x00:0x20] = stack[-2] // @0FF5 stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_0FF9: // Incoming call from 0x0B8B, returns to 0x0B8C // Incoming jump from 0x05E7 // Incoming call from 0x2317, returns to 0x2318 // Incoming call from 0x1A08, returns to 0x1A09 // Incoming call from 0x15E3, returns to 0x15E4 // Incoming call from 0x152A, returns to 0x152B // Inputs[3] // { // @1001 stack[-1] // @100F memory[0x00:0x40] // @1013 storage[keccak256(memory[0x00:0x40])] // } 0FF9 5B JUMPDEST 0FFA 60 PUSH1 0x00 0FFC 80 DUP1 0FFD 60 PUSH1 0x01 0FFF 60 PUSH1 0x00 1001 84 DUP5 1002 81 DUP2 1003 52 MSTORE 1004 60 PUSH1 0x20 1006 01 ADD 1007 90 SWAP1 1008 81 DUP2 1009 52 MSTORE 100A 60 PUSH1 0x20 100C 01 ADD 100D 60 PUSH1 0x00 100F 20 SHA3 1010 60 PUSH1 0x00 1012 90 SWAP1 1013 54 SLOAD 1014 90 SWAP1 1015 61 PUSH2 0x0100 1018 0A EXP 1019 90 SWAP1 101A 04 DIV 101B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1030 16 AND 1031 90 SWAP1 1032 50 POP 1033 60 PUSH1 0x00 1035 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 104A 16 AND 104B 81 DUP2 104C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1061 16 AND 1062 14 EQ 1063 15 ISZERO 1064 15 ISZERO 1065 15 ISZERO 1066 61 PUSH2 0x106e 1069 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0FFA stack[0] = 0x00 // @1003 memory[0x00:0x20] = stack[-1] // @1009 memory[0x20:0x40] = 0x01 // @1031 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with conditional jump to 0x106e, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_106A: // Incoming jump from 0x1069, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @106D memory[0x00:0x00] } 106A 60 PUSH1 0x00 106C 80 DUP1 106D FD *REVERT // Stack delta = +0 // Outputs[1] { @106D revert(memory[0x00:0x00]); } // Block terminates label_106E: // Incoming jump from 0x1069, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @106F stack[-1] // @1070 stack[-2] // @1073 stack[-4] // @1074 stack[-3] // } 106E 5B JUMPDEST 106F 80 DUP1 1070 91 SWAP2 1071 50 POP 1072 50 POP 1073 91 SWAP2 1074 90 SWAP1 1075 50 POP 1076 56 *JUMP // Stack delta = -3 // Outputs[1] { @1073 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1077: // Incoming jump from 0x066B // Incoming call from 0x0D02, returns to 0x0D03 // Inputs[1] { @1091 stack[-1] } 1077 5B JUMPDEST 1078 60 PUSH1 0x00 107A 80 DUP1 107B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1090 16 AND 1091 82 DUP3 1092 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10A7 16 AND 10A8 14 EQ 10A9 15 ISZERO 10AA 15 ISZERO 10AB 15 ISZERO 10AC 61 PUSH2 0x10b4 10AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1078 stack[0] = 0x00 } // Block ends with conditional jump to 0x10b4, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_10B0: // Incoming jump from 0x10AF, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @10B3 memory[0x00:0x00] } 10B0 60 PUSH1 0x00 10B2 80 DUP1 10B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @10B3 revert(memory[0x00:0x00]); } // Block terminates label_10B4: // Incoming jump from 0x10AF, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @10BC stack[-2] // @10F6 memory[0x00:0x40] // } 10B4 5B JUMPDEST 10B5 61 PUSH2 0x10fb 10B8 60 PUSH1 0x03 10BA 60 PUSH1 0x00 10BC 84 DUP5 10BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10D2 16 AND 10D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10E8 16 AND 10E9 81 DUP2 10EA 52 MSTORE 10EB 60 PUSH1 0x20 10ED 01 ADD 10EE 90 SWAP1 10EF 81 DUP2 10F0 52 MSTORE 10F1 60 PUSH1 0x20 10F3 01 ADD 10F4 60 PUSH1 0x00 10F6 20 SHA3 10F7 61 PUSH2 0x1670 10FA 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @10B5 stack[0] = 0x10fb // @10EA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @10F0 memory[0x20:0x40] = 0x03 // @10F6 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x1670, returns to 0x10FB label_10FB: // Incoming return from call to 0x1670 at 0x10FA // Inputs[4] // { // @10FC stack[-2] // @10FC stack[-1] // @10FE stack[-4] // @10FF stack[-3] // } 10FB 5B JUMPDEST 10FC 90 SWAP1 10FD 50 POP 10FE 91 SWAP2 10FF 90 SWAP1 1100 50 POP 1101 56 *JUMP // Stack delta = -3 // Outputs[1] { @10FE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1102: // Incoming call from 0x0689, returns to 0x068A // Inputs[3] // { // @1108 storage[0x0a] // @1129 memory[0x40:0x60] // @113C storage[0x0a] // } 1102 5B JUMPDEST 1103 60 PUSH1 0x60 1105 60 PUSH1 0x0a 1107 80 DUP1 1108 54 SLOAD 1109 60 PUSH1 0x01 110B 81 DUP2 110C 60 PUSH1 0x01 110E 16 AND 110F 15 ISZERO 1110 61 PUSH2 0x0100 1113 02 MUL 1114 03 SUB 1115 16 AND 1116 60 PUSH1 0x02 1118 90 SWAP1 1119 04 DIV 111A 80 DUP1 111B 60 PUSH1 0x1f 111D 01 ADD 111E 60 PUSH1 0x20 1120 80 DUP1 1121 91 SWAP2 1122 04 DIV 1123 02 MUL 1124 60 PUSH1 0x20 1126 01 ADD 1127 60 PUSH1 0x40 1129 51 MLOAD 112A 90 SWAP1 112B 81 DUP2 112C 01 ADD 112D 60 PUSH1 0x40 112F 52 MSTORE 1130 80 DUP1 1131 92 SWAP3 1132 91 SWAP2 1133 90 SWAP1 1134 81 DUP2 1135 81 DUP2 1136 52 MSTORE 1137 60 PUSH1 0x20 1139 01 ADD 113A 82 DUP3 113B 80 DUP1 113C 54 SLOAD 113D 60 PUSH1 0x01 113F 81 DUP2 1140 60 PUSH1 0x01 1142 16 AND 1143 15 ISZERO 1144 61 PUSH2 0x0100 1147 02 MUL 1148 03 SUB 1149 16 AND 114A 60 PUSH1 0x02 114C 90 SWAP1 114D 04 DIV 114E 80 DUP1 114F 15 ISZERO 1150 61 PUSH2 0x119a 1153 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1103 stack[0] = 0x60 // @112F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) / 0x20 * 0x20 // @1131 stack[1] = memory[0x40:0x60] // @1132 stack[2] = 0x0a // @1133 stack[3] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // @1136 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // @1139 stack[4] = 0x20 + memory[0x40:0x60] // @113A stack[5] = 0x0a // @114D stack[6] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // } // Block ends with conditional jump to 0x119a, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) label_1154: // Incoming jump from 0x1153, if not !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Inputs[1] { @1154 stack[-1] } 1154 80 DUP1 1155 60 PUSH1 0x1f 1157 10 LT 1158 61 PUSH2 0x116f 115B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x116f, if 0x1f < stack[-1] label_115C: // Incoming jump from 0x115B, if not 0x1f < stack[-1] // Inputs[4] // { // @1160 stack[-2] // @1161 storage[stack[-2]] // @1164 stack[-3] // @1166 stack[-1] // } 115C 61 PUSH2 0x0100 115F 80 DUP1 1160 83 DUP4 1161 54 SLOAD 1162 04 DIV 1163 02 MUL 1164 83 DUP4 1165 52 MSTORE 1166 91 SWAP2 1167 60 PUSH1 0x20 1169 01 ADD 116A 91 SWAP2 116B 61 PUSH2 0x119a 116E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1165 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @116A stack[-1] = stack[-1] // @116A stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x119a label_116F: // Incoming jump from 0x115B, if 0x1f < stack[-1] // Inputs[5] // { // @1170 stack[-3] // @1171 stack[-1] // @1173 stack[-2] // @117B memory[0x00:0x20] // @117F storage[keccak256(memory[0x00:0x20])] // } 116F 5B JUMPDEST 1170 82 DUP3 1171 01 ADD 1172 91 SWAP2 1173 90 SWAP1 1174 60 PUSH1 0x00 1176 52 MSTORE 1177 60 PUSH1 0x20 1179 60 PUSH1 0x00 117B 20 SHA3 117C 90 SWAP1 117D 5B JUMPDEST 117E 81 DUP2 117F 54 SLOAD 1180 81 DUP2 1181 52 MSTORE 1182 90 SWAP1 1183 60 PUSH1 0x01 1185 01 ADD 1186 90 SWAP1 1187 60 PUSH1 0x20 1189 01 ADD 118A 80 DUP1 118B 83 DUP4 118C 11 GT 118D 61 PUSH2 0x117d 1190 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1172 stack[-3] = stack[-3] + stack[-1] // @1176 memory[0x00:0x20] = stack[-2] // @1181 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1186 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1189 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x117d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1191: // Incoming jump from 0x1190, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1190, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1191 stack[-3] // @1192 stack[-1] // } 1191 82 DUP3 1192 90 SWAP1 1193 03 SUB 1194 60 PUSH1 0x1f 1196 16 AND 1197 82 DUP3 1198 01 ADD 1199 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1199 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1199 stack[-1] = stack[-3] // } // Block continues label_119A: // Incoming jump from 0x116E // Incoming jump from 0x1153, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Incoming jump from 0x1199 // Inputs[3] // { // @11A0 stack[-6] // @11A0 stack[-7] // @11A2 stack[-8] // } 119A 5B JUMPDEST 119B 50 POP 119C 50 POP 119D 50 POP 119E 50 POP 119F 50 POP 11A0 90 SWAP1 11A1 50 POP 11A2 90 SWAP1 11A3 56 *JUMP // Stack delta = -7 // Outputs[1] { @11A2 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_11A4: // Incoming jump from 0x0746 // Inputs[1] { @11A8 msg.sender } 11A4 5B JUMPDEST 11A5 61 PUSH2 0x11ad 11A8 33 CALLER 11A9 61 PUSH2 0x130b 11AC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11A5 stack[0] = 0x11ad // @11A8 stack[1] = msg.sender // } // Block ends with call to 0x130b, returns to 0x11AD label_11AD: // Incoming return from call to 0x130B at 0x11AC // Inputs[1] { @11AE stack[-1] } 11AD 5B JUMPDEST 11AE 15 ISZERO 11AF 15 ISZERO 11B0 61 PUSH2 0x11b8 11B3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11b8, if !!stack[-1] label_11B4: // Incoming jump from 0x11B3, if not !!stack[-1] // Inputs[1] { @11B7 memory[0x00:0x00] } 11B4 60 PUSH1 0x00 11B6 80 DUP1 11B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @11B7 revert(memory[0x00:0x00]); } // Block terminates label_11B8: // Incoming jump from 0x11B3, if !!stack[-1] // Inputs[1] { @11BC stack[-1] } 11B8 5B JUMPDEST 11B9 61 PUSH2 0x11c1 11BC 81 DUP2 11BD 61 PUSH2 0x167e 11C0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11B9 stack[0] = 0x11c1 // @11BC stack[1] = stack[-1] // } // Block ends with call to 0x167e, returns to 0x11C1 label_11C1: // Incoming return from call to 0x167E at 0x11C0 // Inputs[1] { @11C3 stack[-2] } 11C1 5B JUMPDEST 11C2 50 POP 11C3 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_11C4: // Incoming call from 0x0750, returns to 0x0751 // Inputs[1] { @11C8 msg.sender } 11C4 5B JUMPDEST 11C5 61 PUSH2 0x11cd 11C8 33 CALLER 11C9 61 PUSH2 0x16d8 11CC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11C5 stack[0] = 0x11cd // @11C8 stack[1] = msg.sender // } // Block ends with call to 0x16d8, returns to 0x11CD label_11CD: // Incoming return from call to 0x16D8 at 0x11CC // Inputs[1] { @11CE stack[-1] } 11CD 5B JUMPDEST 11CE 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_11CF: // Incoming jump from 0x07A0 // Inputs[2] // { // @11D0 msg.sender // @11E7 stack[-2] // } 11CF 5B JUMPDEST 11D0 33 CALLER 11D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11E6 16 AND 11E7 82 DUP3 11E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11FD 16 AND 11FE 14 EQ 11FF 15 ISZERO 1200 15 ISZERO 1201 15 ISZERO 1202 61 PUSH2 0x120a 1205 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x120a, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) label_1206: // Incoming jump from 0x1205, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[1] { @1209 memory[0x00:0x00] } 1206 60 PUSH1 0x00 1208 80 DUP1 1209 FD *REVERT // Stack delta = +0 // Outputs[1] { @1209 revert(memory[0x00:0x00]); } // Block terminates label_120A: // Incoming jump from 0x1205, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[11] // { // @120B stack[-1] // @1210 msg.sender // @124A memory[0x00:0x40] // @124D stack[-2] // @1287 memory[0x00:0x40] // @128F storage[keccak256(memory[0x00:0x40])] // @12B6 msg.sender // @12F1 memory[0x40:0x60] // @1302 memory[0x40:0x60] // @1307 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @130A stack[-3] // } 120A 5B JUMPDEST 120B 80 DUP1 120C 60 PUSH1 0x04 120E 60 PUSH1 0x00 1210 33 CALLER 1211 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1226 16 AND 1227 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 123C 16 AND 123D 81 DUP2 123E 52 MSTORE 123F 60 PUSH1 0x20 1241 01 ADD 1242 90 SWAP1 1243 81 DUP2 1244 52 MSTORE 1245 60 PUSH1 0x20 1247 01 ADD 1248 60 PUSH1 0x00 124A 20 SHA3 124B 60 PUSH1 0x00 124D 84 DUP5 124E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1263 16 AND 1264 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1279 16 AND 127A 81 DUP2 127B 52 MSTORE 127C 60 PUSH1 0x20 127E 01 ADD 127F 90 SWAP1 1280 81 DUP2 1281 52 MSTORE 1282 60 PUSH1 0x20 1284 01 ADD 1285 60 PUSH1 0x00 1287 20 SHA3 1288 60 PUSH1 0x00 128A 61 PUSH2 0x0100 128D 0A EXP 128E 81 DUP2 128F 54 SLOAD 1290 81 DUP2 1291 60 PUSH1 0xff 1293 02 MUL 1294 19 NOT 1295 16 AND 1296 90 SWAP1 1297 83 DUP4 1298 15 ISZERO 1299 15 ISZERO 129A 02 MUL 129B 17 OR 129C 90 SWAP1 129D 55 SSTORE 129E 50 POP 129F 81 DUP2 12A0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12B5 16 AND 12B6 33 CALLER 12B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12CC 16 AND 12CD 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 12EE 83 DUP4 12EF 60 PUSH1 0x40 12F1 51 MLOAD 12F2 80 DUP1 12F3 82 DUP3 12F4 15 ISZERO 12F5 15 ISZERO 12F6 15 ISZERO 12F7 15 ISZERO 12F8 81 DUP2 12F9 52 MSTORE 12FA 60 PUSH1 0x20 12FC 01 ADD 12FD 91 SWAP2 12FE 50 POP 12FF 50 POP 1300 60 PUSH1 0x40 1302 51 MLOAD 1303 80 DUP1 1304 91 SWAP2 1305 03 SUB 1306 90 SWAP1 1307 A3 LOG3 1308 50 POP 1309 50 POP 130A 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @123E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1244 memory[0x20:0x40] = 0x04 // @127B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1281 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @129D storage[keccak256(memory[0x00:0x40])] = !!stack[-1] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @12F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @1307 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-3] label_130B: // Incoming jump from 0x07E4 // Incoming call from 0x11AC, returns to 0x11AD // Incoming call from 0x0DBB, returns to 0x0DBC // Inputs[1] { @1311 stack[-1] } 130B 5B JUMPDEST 130C 60 PUSH1 0x00 130E 61 PUSH2 0x1321 1311 82 DUP3 1312 60 PUSH1 0x0c 1314 61 PUSH2 0x1732 1317 90 SWAP1 1318 91 SWAP2 1319 90 SWAP1 131A 63 PUSH4 0xffffffff 131F 16 AND 1320 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @130C stack[0] = 0x00 // @130E stack[1] = 0x1321 // @1318 stack[2] = 0x0c // @1319 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1732, returns to 0x1321 label_1321: // Incoming return from call to 0x1732 at 0x1320 // Inputs[4] // { // @1322 stack[-1] // @1322 stack[-2] // @1324 stack[-4] // @1325 stack[-3] // } 1321 5B JUMPDEST 1322 90 SWAP1 1323 50 POP 1324 91 SWAP2 1325 90 SWAP1 1326 50 POP 1327 56 *JUMP // Stack delta = -3 // Outputs[1] { @1324 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1328: // Incoming jump from 0x0901 // Incoming call from 0x0D8A, returns to 0x0D8B // Inputs[3] // { // @132C stack[-4] // @132D stack[-3] // @132E stack[-2] // } 1328 5B JUMPDEST 1329 61 PUSH2 0x1333 132C 84 DUP5 132D 84 DUP5 132E 84 DUP5 132F 61 PUSH2 0x0cd3 1332 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1329 stack[0] = 0x1333 // @132C stack[1] = stack[-4] // @132D stack[2] = stack[-3] // @132E stack[3] = stack[-2] // } // Block ends with call to 0x0cd3, returns to 0x1333 label_1333: // Incoming return from call to 0x0CD3 at 0x1332 // Inputs[4] // { // @1337 stack[-4] // @1338 stack[-3] // @1339 stack[-2] // @133A stack[-1] // } 1333 5B JUMPDEST 1334 61 PUSH2 0x133f 1337 84 DUP5 1338 84 DUP5 1339 84 DUP5 133A 84 DUP5 133B 61 PUSH2 0x17c6 133E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1334 stack[0] = 0x133f // @1337 stack[1] = stack[-4] // @1338 stack[2] = stack[-3] // @1339 stack[3] = stack[-2] // @133A stack[4] = stack[-1] // } // Block ends with call to 0x17c6, returns to 0x133F label_133F: // Incoming return from call to 0x17C6 at 0x133E // Inputs[1] { @1340 stack[-1] } 133F 5B JUMPDEST 1340 15 ISZERO 1341 15 ISZERO 1342 61 PUSH2 0x134a 1345 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x134a, if !!stack[-1] label_1346: // Incoming jump from 0x1345, if not !!stack[-1] // Inputs[1] { @1349 memory[0x00:0x00] } 1346 60 PUSH1 0x00 1348 80 DUP1 1349 FD *REVERT // Stack delta = +0 // Outputs[1] { @1349 revert(memory[0x00:0x00]); } // Block terminates label_134A: // Incoming jump from 0x1345, if !!stack[-1] // Inputs[1] { @134F stack[-5] } 134A 5B JUMPDEST 134B 50 POP 134C 50 POP 134D 50 POP 134E 50 POP 134F 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1350: // Incoming jump from 0x092F // Inputs[1] { @1356 stack[-1] } 1350 5B JUMPDEST 1351 60 PUSH1 0x60 1353 61 PUSH2 0x135b 1356 82 DUP3 1357 61 PUSH2 0x14ad 135A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1351 stack[0] = 0x60 // @1353 stack[1] = 0x135b // @1356 stack[2] = stack[-1] // } // Block ends with call to 0x14ad, returns to 0x135B label_135B: // Incoming return from call to 0x14AD at 0x135A // Inputs[1] { @135C stack[-1] } 135B 5B JUMPDEST 135C 15 ISZERO 135D 15 ISZERO 135E 61 PUSH2 0x1366 1361 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1366, if !!stack[-1] label_1362: // Incoming jump from 0x1361, if not !!stack[-1] // Inputs[1] { @1365 memory[0x00:0x00] } 1362 60 PUSH1 0x00 1364 80 DUP1 1365 FD *REVERT // Stack delta = +0 // Outputs[1] { @1365 revert(memory[0x00:0x00]); } // Block terminates label_1366: // Incoming jump from 0x1361, if !!stack[-1] // Inputs[5] // { // @136B stack[-2] // @1379 memory[0x00:0x40] // @137B storage[keccak256(memory[0x00:0x40])] // @139C memory[0x40:0x60] // @13AF storage[keccak256(memory[0x00:0x40])] // } 1366 5B JUMPDEST 1367 60 PUSH1 0x0b 1369 60 PUSH1 0x00 136B 83 DUP4 136C 81 DUP2 136D 52 MSTORE 136E 60 PUSH1 0x20 1370 01 ADD 1371 90 SWAP1 1372 81 DUP2 1373 52 MSTORE 1374 60 PUSH1 0x20 1376 01 ADD 1377 60 PUSH1 0x00 1379 20 SHA3 137A 80 DUP1 137B 54 SLOAD 137C 60 PUSH1 0x01 137E 81 DUP2 137F 60 PUSH1 0x01 1381 16 AND 1382 15 ISZERO 1383 61 PUSH2 0x0100 1386 02 MUL 1387 03 SUB 1388 16 AND 1389 60 PUSH1 0x02 138B 90 SWAP1 138C 04 DIV 138D 80 DUP1 138E 60 PUSH1 0x1f 1390 01 ADD 1391 60 PUSH1 0x20 1393 80 DUP1 1394 91 SWAP2 1395 04 DIV 1396 02 MUL 1397 60 PUSH1 0x20 1399 01 ADD 139A 60 PUSH1 0x40 139C 51 MLOAD 139D 90 SWAP1 139E 81 DUP2 139F 01 ADD 13A0 60 PUSH1 0x40 13A2 52 MSTORE 13A3 80 DUP1 13A4 92 SWAP3 13A5 91 SWAP2 13A6 90 SWAP1 13A7 81 DUP2 13A8 81 DUP2 13A9 52 MSTORE 13AA 60 PUSH1 0x20 13AC 01 ADD 13AD 82 DUP3 13AE 80 DUP1 13AF 54 SLOAD 13B0 60 PUSH1 0x01 13B2 81 DUP2 13B3 60 PUSH1 0x01 13B5 16 AND 13B6 15 ISZERO 13B7 61 PUSH2 0x0100 13BA 02 MUL 13BB 03 SUB 13BC 16 AND 13BD 60 PUSH1 0x02 13BF 90 SWAP1 13C0 04 DIV 13C1 80 DUP1 13C2 15 ISZERO 13C3 61 PUSH2 0x140d 13C6 57 *JUMPI // Stack delta = +6 // Outputs[10] // { // @136D memory[0x00:0x20] = stack[-2] // @1373 memory[0x20:0x40] = 0x0b // @13A2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @13A4 stack[0] = memory[0x40:0x60] // @13A5 stack[1] = keccak256(memory[0x00:0x40]) // @13A6 stack[2] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @13A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @13AC stack[3] = 0x20 + memory[0x40:0x60] // @13AD stack[4] = keccak256(memory[0x00:0x40]) // @13C0 stack[5] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x140d, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_13C7: // Incoming jump from 0x13C6, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @13C7 stack[-1] } 13C7 80 DUP1 13C8 60 PUSH1 0x1f 13CA 10 LT 13CB 61 PUSH2 0x13e2 13CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13e2, if 0x1f < stack[-1] label_13CF: // Incoming jump from 0x13CE, if not 0x1f < stack[-1] // Inputs[4] // { // @13D3 stack[-2] // @13D4 storage[stack[-2]] // @13D7 stack[-3] // @13D9 stack[-1] // } 13CF 61 PUSH2 0x0100 13D2 80 DUP1 13D3 83 DUP4 13D4 54 SLOAD 13D5 04 DIV 13D6 02 MUL 13D7 83 DUP4 13D8 52 MSTORE 13D9 91 SWAP2 13DA 60 PUSH1 0x20 13DC 01 ADD 13DD 91 SWAP2 13DE 61 PUSH2 0x140d 13E1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @13D8 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @13DD stack[-1] = stack[-1] // @13DD stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x140d label_13E2: // Incoming jump from 0x13CE, if 0x1f < stack[-1] // Inputs[5] // { // @13E3 stack[-3] // @13E4 stack[-1] // @13E6 stack[-2] // @13EE memory[0x00:0x20] // @13F2 storage[keccak256(memory[0x00:0x20])] // } 13E2 5B JUMPDEST 13E3 82 DUP3 13E4 01 ADD 13E5 91 SWAP2 13E6 90 SWAP1 13E7 60 PUSH1 0x00 13E9 52 MSTORE 13EA 60 PUSH1 0x20 13EC 60 PUSH1 0x00 13EE 20 SHA3 13EF 90 SWAP1 13F0 5B JUMPDEST 13F1 81 DUP2 13F2 54 SLOAD 13F3 81 DUP2 13F4 52 MSTORE 13F5 90 SWAP1 13F6 60 PUSH1 0x01 13F8 01 ADD 13F9 90 SWAP1 13FA 60 PUSH1 0x20 13FC 01 ADD 13FD 80 DUP1 13FE 83 DUP4 13FF 11 GT 1400 61 PUSH2 0x13f0 1403 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @13E5 stack[-3] = stack[-3] + stack[-1] // @13E9 memory[0x00:0x20] = stack[-2] // @13F4 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @13F9 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @13FC stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x13f0, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1404: // Incoming jump from 0x1403, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1403, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1404 stack[-3] // @1405 stack[-1] // } 1404 82 DUP3 1405 90 SWAP1 1406 03 SUB 1407 60 PUSH1 0x1f 1409 16 AND 140A 82 DUP3 140B 01 ADD 140C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @140C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @140C stack[-1] = stack[-3] // } // Block continues label_140D: // Incoming jump from 0x13E1 // Incoming jump from 0x140C // Incoming jump from 0x13C6, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[4] // { // @1413 stack[-6] // @1413 stack[-7] // @1415 stack[-9] // @1416 stack[-8] // } 140D 5B JUMPDEST 140E 50 POP 140F 50 POP 1410 50 POP 1411 50 POP 1412 50 POP 1413 90 SWAP1 1414 50 POP 1415 91 SWAP2 1416 90 SWAP1 1417 50 POP 1418 56 *JUMP // Stack delta = -8 // Outputs[1] { @1415 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_1419: // Incoming call from 0x15A9, returns to 0x15AA // Incoming jump from 0x0A0C // Incoming call from 0x0C07, returns to 0x0C08 // Inputs[6] // { // @1420 stack[-2] // @145A memory[0x00:0x40] // @145D stack[-1] // @1497 memory[0x00:0x40] // @149B storage[keccak256(memory[0x00:0x40])] // @14A8 stack[-3] // } 1419 5B JUMPDEST 141A 60 PUSH1 0x00 141C 60 PUSH1 0x04 141E 60 PUSH1 0x00 1420 84 DUP5 1421 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1436 16 AND 1437 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 144C 16 AND 144D 81 DUP2 144E 52 MSTORE 144F 60 PUSH1 0x20 1451 01 ADD 1452 90 SWAP1 1453 81 DUP2 1454 52 MSTORE 1455 60 PUSH1 0x20 1457 01 ADD 1458 60 PUSH1 0x00 145A 20 SHA3 145B 60 PUSH1 0x00 145D 83 DUP4 145E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1473 16 AND 1474 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1489 16 AND 148A 81 DUP2 148B 52 MSTORE 148C 60 PUSH1 0x20 148E 01 ADD 148F 90 SWAP1 1490 81 DUP2 1491 52 MSTORE 1492 60 PUSH1 0x20 1494 01 ADD 1495 60 PUSH1 0x00 1497 20 SHA3 1498 60 PUSH1 0x00 149A 90 SWAP1 149B 54 SLOAD 149C 90 SWAP1 149D 61 PUSH2 0x0100 14A0 0A EXP 14A1 90 SWAP1 14A2 04 DIV 14A3 60 PUSH1 0xff 14A5 16 AND 14A6 90 SWAP1 14A7 50 POP 14A8 92 SWAP3 14A9 91 SWAP2 14AA 50 POP 14AB 50 POP 14AC 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @144E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1454 memory[0x20:0x40] = 0x04 // @148B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1491 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @14A8 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_14AD: // Incoming call from 0x0B3A, returns to 0x0B3B // Incoming call from 0x135A, returns to 0x135B // Incoming call from 0x1EDF, returns to 0x1EE0 // Incoming call from 0x1638, returns to 0x1639 // Inputs[4] // { // @14B5 stack[-1] // @14C3 memory[0x00:0x40] // @14C7 storage[keccak256(memory[0x00:0x40])] // @151B stack[-2] // } 14AD 5B JUMPDEST 14AE 60 PUSH1 0x00 14B0 80 DUP1 14B1 60 PUSH1 0x01 14B3 60 PUSH1 0x00 14B5 84 DUP5 14B6 81 DUP2 14B7 52 MSTORE 14B8 60 PUSH1 0x20 14BA 01 ADD 14BB 90 SWAP1 14BC 81 DUP2 14BD 52 MSTORE 14BE 60 PUSH1 0x20 14C0 01 ADD 14C1 60 PUSH1 0x00 14C3 20 SHA3 14C4 60 PUSH1 0x00 14C6 90 SWAP1 14C7 54 SLOAD 14C8 90 SWAP1 14C9 61 PUSH2 0x0100 14CC 0A EXP 14CD 90 SWAP1 14CE 04 DIV 14CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14E4 16 AND 14E5 90 SWAP1 14E6 50 POP 14E7 60 PUSH1 0x00 14E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14FE 16 AND 14FF 81 DUP2 1500 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1515 16 AND 1516 14 EQ 1517 15 ISZERO 1518 91 SWAP2 1519 50 POP 151A 50 POP 151B 91 SWAP2 151C 90 SWAP1 151D 50 POP 151E 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @14B7 memory[0x00:0x20] = stack[-1] // @14BD memory[0x20:0x40] = 0x01 // @151B stack[-2] = !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // } // Block ends with unconditional jump to stack[-2] label_151F: // Incoming call from 0x0CDC, returns to 0x0CDD // Incoming call from 0x0D99, returns to 0x0D9A // Inputs[1] { @1526 stack[-1] } 151F 5B JUMPDEST 1520 60 PUSH1 0x00 1522 80 DUP1 1523 61 PUSH2 0x152b 1526 83 DUP4 1527 61 PUSH2 0x0ff9 152A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1520 stack[0] = 0x00 // @1522 stack[1] = 0x00 // @1523 stack[2] = 0x152b // @1526 stack[3] = stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x152B label_152B: // Incoming return from call to 0x0FF9 at 0x152A // Inputs[3] // { // @152C stack[-2] // @152C stack[-1] // @1545 stack[-5] // } 152B 5B JUMPDEST 152C 90 SWAP1 152D 50 POP 152E 80 DUP1 152F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1544 16 AND 1545 84 DUP5 1546 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 155B 16 AND 155C 14 EQ 155D 80 DUP1 155E 61 PUSH2 0x159a 1561 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @152C stack[-2] = stack[-1] // @155C stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x159a, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_1562: // Incoming jump from 0x1561, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @1563 stack[-5] // @157D stack[-4] // } 1562 50 POP 1563 83 DUP4 1564 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1579 16 AND 157A 61 PUSH2 0x1582 157D 84 DUP5 157E 61 PUSH2 0x0b30 1581 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1579 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @157A stack[0] = 0x1582 // @157D stack[1] = stack[-4] // } // Block ends with call to 0x0b30, returns to 0x1582 label_1582: // Incoming return from call to 0x0B30 at 0x1581 // Inputs[2] // { // @1598 stack[-1] // @1599 stack[-2] // } 1582 5B JUMPDEST 1583 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1598 16 AND 1599 14 EQ // Stack delta = -1 // Outputs[1] { @1599 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_159A: // Incoming jump from 0x1561, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Incoming jump from 0x1599 // Inputs[1] { @159B stack[-1] } 159A 5B JUMPDEST 159B 80 DUP1 159C 61 PUSH2 0x15ab 159F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15ab, if stack[-1] label_15A0: // Incoming jump from 0x159F, if not stack[-1] // Inputs[2] // { // @15A4 stack[-2] // @15A5 stack[-5] // } 15A0 50 POP 15A1 61 PUSH2 0x15aa 15A4 81 DUP2 15A5 85 DUP6 15A6 61 PUSH2 0x1419 15A9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15A1 stack[-1] = 0x15aa // @15A4 stack[0] = stack[-2] // @15A5 stack[1] = stack[-5] // } // Block ends with call to 0x1419, returns to 0x15AA label_15AA: // Incoming return from call to 0x1419 at 0x15A9 15AA 5B JUMPDEST // Stack delta = +0 // Block continues label_15AB: // Incoming jump from 0x15AA // Incoming jump from 0x159F, if stack[-1] // Inputs[4] // { // @15AC stack[-3] // @15AC stack[-1] // @15AF stack[-6] // @15B0 stack[-5] // } 15AB 5B JUMPDEST 15AC 91 SWAP2 15AD 50 POP 15AE 50 POP 15AF 92 SWAP3 15B0 91 SWAP2 15B1 50 POP 15B2 50 POP 15B3 56 *JUMP // Stack delta = -5 // Outputs[1] { @15AF stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_15B4: // Incoming call from 0x0CF2, returns to 0x0CF3 // Inputs[3] // { // @15B8 stack[-3] // @15B9 stack[-2] // @15BA stack[-1] // } 15B4 5B JUMPDEST 15B5 61 PUSH2 0x15bf 15B8 83 DUP4 15B9 83 DUP4 15BA 83 DUP4 15BB 61 PUSH2 0x19e9 15BE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15B5 stack[0] = 0x15bf // @15B8 stack[1] = stack[-3] // @15B9 stack[2] = stack[-2] // @15BA stack[3] = stack[-1] // } // Block ends with call to 0x19e9, returns to 0x15BF label_15BF: // Incoming return from call to 0x19E9 at 0x15BE // Inputs[2] // { // @15C3 stack[-3] // @15C4 stack[-1] // } 15BF 5B JUMPDEST 15C0 61 PUSH2 0x15c9 15C3 83 DUP4 15C4 82 DUP3 15C5 61 PUSH2 0x1bb0 15C8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15C0 stack[0] = 0x15c9 // @15C3 stack[1] = stack[-3] // @15C4 stack[2] = stack[-1] // } // Block ends with call to 0x1bb0, returns to 0x15C9 label_15C9: // Incoming return from call to 0x1BB0 at 0x15C8 // Inputs[2] // { // @15CD stack[-2] // @15CE stack[-1] // } 15C9 5B JUMPDEST 15CA 61 PUSH2 0x15d3 15CD 82 DUP3 15CE 82 DUP3 15CF 61 PUSH2 0x1d54 15D2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15CA stack[0] = 0x15d3 // @15CD stack[1] = stack[-2] // @15CE stack[2] = stack[-1] // } // Block ends with call to 0x1d54, returns to 0x15D3 label_15D3: // Incoming return from call to 0x1D54 at 0x15D2 // Inputs[1] { @15D7 stack[-4] } 15D3 5B JUMPDEST 15D4 50 POP 15D5 50 POP 15D6 50 POP 15D7 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_15D8: // Incoming call from 0x0DAD, returns to 0x0DAE // Inputs[1] { @15DF stack[-1] } 15D8 5B JUMPDEST 15D9 61 PUSH2 0x15ea 15DC 61 PUSH2 0x15e4 15DF 82 DUP3 15E0 61 PUSH2 0x0ff9 15E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15D9 stack[0] = 0x15ea // @15DC stack[1] = 0x15e4 // @15DF stack[2] = stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x15E4 label_15E4: // Incoming return from call to 0x0FF9 at 0x15E3 // Inputs[1] { @15E5 stack[-3] } 15E4 5B JUMPDEST 15E5 82 DUP3 15E6 61 PUSH2 0x1e1b 15E9 56 *JUMP // Stack delta = +1 // Outputs[1] { @15E5 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x1e1b label_15EA: // Incoming return from call to 0x15E4 at 0x15E3 // Inputs[1] { @15EC stack[-2] } 15EA 5B JUMPDEST 15EB 50 POP 15EC 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_15ED: // Incoming call from 0x0DD0, returns to 0x0DD1 15ED 5B JUMPDEST 15EE 60 PUSH1 0x00 15F0 61 PUSH2 0x160a 15F3 60 PUSH1 0x01 15F5 61 PUSH2 0x15fc 15F8 61 PUSH2 0x0cc6 15FB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15EE stack[0] = 0x00 // @15F0 stack[1] = 0x160a // @15F3 stack[2] = 0x01 // @15F5 stack[3] = 0x15fc // } // Block ends with call to 0x0cc6, returns to 0x15FC label_15FC: // Incoming return from call to 0x0CC6 at 0x15FB // Inputs[2] // { // @1600 stack[-1] // @1601 stack[-2] // } 15FC 5B JUMPDEST 15FD 61 PUSH2 0x1e7a 1600 90 SWAP1 1601 91 SWAP2 1602 90 SWAP1 1603 63 PUSH4 0xffffffff 1608 16 AND 1609 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1601 stack[-2] = stack[-1] // @1602 stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x1e7a label_160A: // Incoming return from call to 0x15FC at 0x15FB // Inputs[3] // { // @160B stack[-2] // @160B stack[-1] // @160D stack[-3] // } 160A 5B JUMPDEST 160B 90 SWAP1 160C 50 POP 160D 90 SWAP1 160E 56 *JUMP // Stack delta = -2 // Outputs[1] { @160D stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_160F: // Incoming call from 0x0EEA, returns to 0x0EEB // Inputs[2] // { // @1613 stack[-2] // @1614 stack[-1] // } 160F 5B JUMPDEST 1610 61 PUSH2 0x1619 1613 82 DUP3 1614 82 DUP3 1615 61 PUSH2 0x1e9b 1618 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1610 stack[0] = 0x1619 // @1613 stack[1] = stack[-2] // @1614 stack[2] = stack[-1] // } // Block ends with call to 0x1e9b, returns to 0x1619 label_1619: // Incoming return from call to 0x1E9B at 0x1618 // Inputs[2] // { // @161D stack[-2] // @161E stack[-1] // } 1619 5B JUMPDEST 161A 61 PUSH2 0x1623 161D 82 DUP3 161E 82 DUP3 161F 61 PUSH2 0x1d54 1622 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @161A stack[0] = 0x1623 // @161D stack[1] = stack[-2] // @161E stack[2] = stack[-1] // } // Block ends with call to 0x1d54, returns to 0x1623 label_1623: // Incoming return from call to 0x1D54 at 0x1622 // Inputs[1] { @1627 stack[-1] } 1623 5B JUMPDEST 1624 61 PUSH2 0x162c 1627 81 DUP2 1628 61 PUSH2 0x1fe5 162B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1624 stack[0] = 0x162c // @1627 stack[1] = stack[-1] // } // Block ends with call to 0x1fe5, returns to 0x162C label_162C: // Incoming return from call to 0x1FE5 at 0x162B // Inputs[1] { @162F stack[-3] } 162C 5B JUMPDEST 162D 50 POP 162E 50 POP 162F 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1630: // Incoming call from 0x0EF4, returns to 0x0EF5 // Inputs[1] { @1634 stack[-2] } 1630 5B JUMPDEST 1631 61 PUSH2 0x1639 1634 82 DUP3 1635 61 PUSH2 0x14ad 1638 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1631 stack[0] = 0x1639 // @1634 stack[1] = stack[-2] // } // Block ends with call to 0x14ad, returns to 0x1639 label_1639: // Incoming return from call to 0x14AD at 0x1638 // Inputs[1] { @163A stack[-1] } 1639 5B JUMPDEST 163A 15 ISZERO 163B 15 ISZERO 163C 61 PUSH2 0x1644 163F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1644, if !!stack[-1] label_1640: // Incoming jump from 0x163F, if not !!stack[-1] // Inputs[1] { @1643 memory[0x00:0x00] } 1640 60 PUSH1 0x00 1642 80 DUP1 1643 FD *REVERT // Stack delta = +0 // Outputs[1] { @1643 revert(memory[0x00:0x00]); } // Block terminates label_1644: // Incoming jump from 0x163F, if !!stack[-1] // Inputs[4] // { // @1645 stack[-1] // @164A stack[-2] // @1658 memory[0x00:0x40] // @165B memory[stack[-1]:stack[-1] + 0x20] // } 1644 5B JUMPDEST 1645 80 DUP1 1646 60 PUSH1 0x0b 1648 60 PUSH1 0x00 164A 84 DUP5 164B 81 DUP2 164C 52 MSTORE 164D 60 PUSH1 0x20 164F 01 ADD 1650 90 SWAP1 1651 81 DUP2 1652 52 MSTORE 1653 60 PUSH1 0x20 1655 01 ADD 1656 60 PUSH1 0x00 1658 20 SHA3 1659 90 SWAP1 165A 80 DUP1 165B 51 MLOAD 165C 90 SWAP1 165D 60 PUSH1 0x20 165F 01 ADD 1660 90 SWAP1 1661 61 PUSH2 0x166b 1664 92 SWAP3 1665 91 SWAP2 1666 90 SWAP1 1667 61 PUSH2 0x24fb 166A 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @164C memory[0x00:0x20] = stack[-2] // @1652 memory[0x20:0x40] = 0x0b // @1664 stack[0] = 0x166b // @1665 stack[1] = keccak256(memory[0x00:0x40]) // @1666 stack[2] = 0x20 + stack[-1] // @1666 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x24fb, returns to 0x166B label_166B: // Incoming return from call to 0x24FB at 0x166A // Inputs[1] { @166F stack[-4] } 166B 5B JUMPDEST 166C 50 POP 166D 50 POP 166E 50 POP 166F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1670: // Incoming call from 0x10FA, returns to 0x10FB // Inputs[3] // { // @1673 stack[-1] // @1677 storage[0x00 + stack[-1]] // @167A stack[-2] // } 1670 5B JUMPDEST 1671 60 PUSH1 0x00 1673 81 DUP2 1674 60 PUSH1 0x00 1676 01 ADD 1677 54 SLOAD 1678 90 SWAP1 1679 50 POP 167A 91 SWAP2 167B 90 SWAP1 167C 50 POP 167D 56 *JUMP // Stack delta = -1 // Outputs[1] { @167A stack[-2] = storage[0x00 + stack[-1]] } // Block ends with unconditional jump to stack[-2] label_167E: // Incoming call from 0x11C0, returns to 0x11C1 // Inputs[1] { @1682 stack[-1] } 167E 5B JUMPDEST 167F 61 PUSH2 0x1692 1682 81 DUP2 1683 60 PUSH1 0x0c 1685 61 PUSH2 0x2031 1688 90 SWAP1 1689 91 SWAP2 168A 90 SWAP1 168B 63 PUSH4 0xffffffff 1690 16 AND 1691 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @167F stack[0] = 0x1692 // @1689 stack[1] = 0x0c // @168A stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2031, returns to 0x1692 label_1692: // Incoming return from call to 0x2031 at 0x1691 // Inputs[5] // { // @1693 stack[-1] // @16CD memory[0x40:0x60] // @16D0 memory[0x40:0x60] // @16D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @16D7 stack[-2] // } 1692 5B JUMPDEST 1693 80 DUP1 1694 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16A9 16 AND 16AA 7F PUSH32 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6 16CB 60 PUSH1 0x40 16CD 51 MLOAD 16CE 60 PUSH1 0x40 16D0 51 MLOAD 16D1 80 DUP1 16D2 91 SWAP2 16D3 03 SUB 16D4 90 SWAP1 16D5 A2 LOG2 16D6 50 POP 16D7 56 *JUMP // Stack delta = -2 // Outputs[1] { @16D5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } // Block ends with unconditional jump to stack[-2] label_16D8: // Incoming call from 0x11CC, returns to 0x11CD // Inputs[1] { @16DC stack[-1] } 16D8 5B JUMPDEST 16D9 61 PUSH2 0x16ec 16DC 81 DUP2 16DD 60 PUSH1 0x0c 16DF 61 PUSH2 0x20e1 16E2 90 SWAP1 16E3 91 SWAP2 16E4 90 SWAP1 16E5 63 PUSH4 0xffffffff 16EA 16 AND 16EB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16D9 stack[0] = 0x16ec // @16E3 stack[1] = 0x0c // @16E4 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x20e1, returns to 0x16EC label_16EC: // Incoming return from call to 0x20E1 at 0x16EB // Inputs[5] // { // @16ED stack[-1] // @1727 memory[0x40:0x60] // @172A memory[0x40:0x60] // @172F memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1731 stack[-2] // } 16EC 5B JUMPDEST 16ED 80 DUP1 16EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1703 16 AND 1704 7F PUSH32 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692 1725 60 PUSH1 0x40 1727 51 MLOAD 1728 60 PUSH1 0x40 172A 51 MLOAD 172B 80 DUP1 172C 91 SWAP2 172D 03 SUB 172E 90 SWAP1 172F A2 LOG2 1730 50 POP 1731 56 *JUMP // Stack delta = -2 // Outputs[1] { @172F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } // Block ends with unconditional jump to stack[-2] label_1732: // Incoming call from 0x1320, returns to 0x1321 // Incoming call from 0x2126, returns to 0x2127 // Incoming call from 0x2076, returns to 0x2077 // Inputs[1] { @174C stack[-1] } 1732 5B JUMPDEST 1733 60 PUSH1 0x00 1735 80 DUP1 1736 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 174B 16 AND 174C 82 DUP3 174D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1762 16 AND 1763 14 EQ 1764 15 ISZERO 1765 15 ISZERO 1766 15 ISZERO 1767 61 PUSH2 0x176f 176A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1733 stack[0] = 0x00 } // Block ends with conditional jump to 0x176f, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_176B: // Incoming jump from 0x176A, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @176E memory[0x00:0x00] } 176B 60 PUSH1 0x00 176D 80 DUP1 176E FD *REVERT // Stack delta = +0 // Outputs[1] { @176E revert(memory[0x00:0x00]); } // Block terminates label_176F: // Incoming jump from 0x176A, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @1770 stack[-3] // @1776 stack[-2] // @17B0 memory[0x00:0x40] // @17B4 storage[keccak256(memory[0x00:0x40])] // @17BF stack[-1] // @17C1 stack[-4] // } 176F 5B JUMPDEST 1770 82 DUP3 1771 60 PUSH1 0x00 1773 01 ADD 1774 60 PUSH1 0x00 1776 83 DUP4 1777 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 178C 16 AND 178D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17A2 16 AND 17A3 81 DUP2 17A4 52 MSTORE 17A5 60 PUSH1 0x20 17A7 01 ADD 17A8 90 SWAP1 17A9 81 DUP2 17AA 52 MSTORE 17AB 60 PUSH1 0x20 17AD 01 ADD 17AE 60 PUSH1 0x00 17B0 20 SHA3 17B1 60 PUSH1 0x00 17B3 90 SWAP1 17B4 54 SLOAD 17B5 90 SWAP1 17B6 61 PUSH2 0x0100 17B9 0A EXP 17BA 90 SWAP1 17BB 04 DIV 17BC 60 PUSH1 0xff 17BE 16 AND 17BF 90 SWAP1 17C0 50 POP 17C1 92 SWAP3 17C2 91 SWAP2 17C3 50 POP 17C4 50 POP 17C5 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @17A4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @17AA memory[0x20:0x40] = 0x00 + stack[-3] // @17C1 stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-4] label_17C6: // Incoming call from 0x133E, returns to 0x133F // Inputs[1] { @17CC stack[-3] } 17C6 5B JUMPDEST 17C7 60 PUSH1 0x00 17C9 61 PUSH2 0x17e7 17CC 84 DUP5 17CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17E2 16 AND 17E3 61 PUSH2 0x2190 17E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17C7 stack[0] = 0x00 // @17C9 stack[1] = 0x17e7 // @17E2 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with call to 0x2190, returns to 0x17E7 label_17E7: // Incoming return from call to 0x2190 at 0x17E6 // Inputs[1] { @17E8 stack[-1] } 17E7 5B JUMPDEST 17E8 15 ISZERO 17E9 15 ISZERO 17EA 61 PUSH2 0x17f6 17ED 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17f6, if !!stack[-1] label_17EE: // Incoming jump from 0x17ED, if not !!stack[-1] // Inputs[1] { @17F0 stack[-1] } 17EE 60 PUSH1 0x01 17F0 90 SWAP1 17F1 50 POP 17F2 61 PUSH2 0x19e1 17F5 56 *JUMP // Stack delta = +0 // Outputs[1] { @17F0 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x19e1 label_17F6: // Incoming jump from 0x17ED, if !!stack[-1] // Inputs[8] // { // @17F9 stack[-4] // @1815 msg.sender // @1816 stack[-5] // @1817 stack[-3] // @1818 stack[-2] // @181B memory[0x40:0x60] // @18BE memory[stack[-2]:stack[-2] + 0x20] // @18C7 memory[stack[-2]:stack[-2] + 0x20] // } 17F6 5B JUMPDEST 17F7 60 PUSH1 0x00 17F9 84 DUP5 17FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 180F 16 AND 1810 63 PUSH4 0x150b7a02 1815 33 CALLER 1816 88 DUP9 1817 87 DUP8 1818 87 DUP8 1819 60 PUSH1 0x40 181B 51 MLOAD 181C 85 DUP6 181D 63 PUSH4 0xffffffff 1822 16 AND 1823 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1841 02 MUL 1842 81 DUP2 1843 52 MSTORE 1844 60 PUSH1 0x04 1846 01 ADD 1847 80 DUP1 1848 85 DUP6 1849 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 185E 16 AND 185F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1874 16 AND 1875 81 DUP2 1876 52 MSTORE 1877 60 PUSH1 0x20 1879 01 ADD 187A 84 DUP5 187B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1890 16 AND 1891 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18A6 16 AND 18A7 81 DUP2 18A8 52 MSTORE 18A9 60 PUSH1 0x20 18AB 01 ADD 18AC 83 DUP4 18AD 81 DUP2 18AE 52 MSTORE 18AF 60 PUSH1 0x20 18B1 01 ADD 18B2 80 DUP1 18B3 60 PUSH1 0x20 18B5 01 ADD 18B6 82 DUP3 18B7 81 DUP2 18B8 03 SUB 18B9 82 DUP3 18BA 52 MSTORE 18BB 83 DUP4 18BC 81 DUP2 18BD 81 DUP2 18BE 51 MLOAD 18BF 81 DUP2 18C0 52 MSTORE 18C1 60 PUSH1 0x20 18C3 01 ADD 18C4 91 SWAP2 18C5 50 POP 18C6 80 DUP1 18C7 51 MLOAD 18C8 90 SWAP1 18C9 60 PUSH1 0x20 18CB 01 ADD 18CC 90 SWAP1 18CD 80 DUP1 18CE 83 DUP4 18CF 83 DUP4 18D0 60 PUSH1 0x00 18D2 5B JUMPDEST 18D3 83 DUP4 18D4 81 DUP2 18D5 10 LT 18D6 15 ISZERO 18D7 61 PUSH2 0x18ed 18DA 57 *JUMPI // Stack delta = +16 // Outputs[22] // { // @17F7 stack[0] = 0x00 // @180F stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1810 stack[2] = 0x150b7a02 // @1815 stack[3] = msg.sender // @1816 stack[4] = stack[-5] // @1817 stack[5] = stack[-3] // @1818 stack[6] = stack[-2] // @1843 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x150b7a02) // @1846 stack[7] = 0x04 + memory[0x40:0x60] // @1876 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @18A8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @18AE memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-3] // @18B1 stack[8] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @18BA memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @18C0 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @18C4 stack[9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @18CC stack[10] = 0x20 + stack[-2] // @18CC stack[11] = memory[stack[-2]:stack[-2] + 0x20] // @18CD stack[12] = memory[stack[-2]:stack[-2] + 0x20] // @18CE stack[13] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @18CF stack[14] = 0x20 + stack[-2] // @18D0 stack[15] = 0x00 // } // Block ends with conditional jump to 0x18ed, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_18DB: // Incoming jump from 0x18DA, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x18DA, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @18DB stack[-1] // @18DC stack[-2] // @18DE memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @18E0 stack[-3] // } 18DB 80 DUP1 18DC 82 DUP3 18DD 01 ADD 18DE 51 MLOAD 18DF 81 DUP2 18E0 84 DUP5 18E1 01 ADD 18E2 52 MSTORE 18E3 60 PUSH1 0x20 18E5 81 DUP2 18E6 01 ADD 18E7 90 SWAP1 18E8 50 POP 18E9 61 PUSH2 0x18d2 18EC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18E2 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @18E7 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x18d2 label_18ED: // Incoming jump from 0x18DA, if !(stack[-1] < stack[-4]) // Incoming jump from 0x18DA, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @18F2 stack[-5] // @18F2 stack[-6] // @18F4 stack[-7] // } 18ED 5B JUMPDEST 18EE 50 POP 18EF 50 POP 18F0 50 POP 18F1 50 POP 18F2 90 SWAP1 18F3 50 POP 18F4 90 SWAP1 18F5 81 DUP2 18F6 01 ADD 18F7 90 SWAP1 18F8 60 PUSH1 0x1f 18FA 16 AND 18FB 80 DUP1 18FC 15 ISZERO 18FD 61 PUSH2 0x191a 1900 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @18F7 stack[-7] = stack[-5] + stack[-7] // @18FA stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x191a, if !(0x1f & stack[-5]) label_1901: // Incoming jump from 0x1900, if not !(0x1f & stack[-5]) // Inputs[7] // { // @1901 stack[-1] // @1902 stack[-2] // @1905 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @191C stack[-8] // @1927 memory[0x40:0x60] // @192E stack[-10] // @1930 address(stack[-10]).code.length // } 1901 80 DUP1 1902 82 DUP3 1903 03 SUB 1904 80 DUP1 1905 51 MLOAD 1906 60 PUSH1 0x01 1908 83 DUP4 1909 60 PUSH1 0x20 190B 03 SUB 190C 61 PUSH2 0x0100 190F 0A EXP 1910 03 SUB 1911 19 NOT 1912 16 AND 1913 81 DUP2 1914 52 MSTORE 1915 60 PUSH1 0x20 1917 01 ADD 1918 91 SWAP2 1919 50 POP 191A 5B JUMPDEST 191B 50 POP 191C 95 SWAP6 191D 50 POP 191E 50 POP 191F 50 POP 1920 50 POP 1921 50 POP 1922 50 POP 1923 60 PUSH1 0x20 1925 60 PUSH1 0x40 1927 51 MLOAD 1928 80 DUP1 1929 83 DUP4 192A 03 SUB 192B 81 DUP2 192C 60 PUSH1 0x00 192E 87 DUP8 192F 80 DUP1 1930 3B EXTCODESIZE 1931 15 ISZERO 1932 80 DUP1 1933 15 ISZERO 1934 61 PUSH2 0x193c 1937 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1914 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @191C stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @1923 stack[-7] = 0x20 // @1927 stack[-6] = memory[0x40:0x60] // @192A stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @192B stack[-4] = memory[0x40:0x60] // @192C stack[-3] = 0x00 // @192E stack[-2] = stack[-10] // @1931 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x193c, if !!address(stack[-10]).code.length label_1938: // Incoming jump from 0x1937, if not !!address(stack[-10]).code.length // Incoming jump from 0x1937, if not !!address(stack[-10]).code.length // Inputs[1] { @193B memory[0x00:0x00] } 1938 60 PUSH1 0x00 193A 80 DUP1 193B FD *REVERT // Stack delta = +0 // Outputs[1] { @193B revert(memory[0x00:0x00]); } // Block terminates label_193C: // Incoming jump from 0x1937, if !!address(stack[-10]).code.length // Incoming jump from 0x1937, if !!address(stack[-10]).code.length // Inputs[9] // { // @193E msg.gas // @193F memory[stack[-4]:stack[-4] + stack[-5]] // @193F stack[-2] // @193F stack[-4] // @193F stack[-6] // @193F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @193F stack[-5] // @193F stack[-7] // @193F stack[-3] // } 193C 5B JUMPDEST 193D 50 POP 193E 5A GAS 193F F1 CALL 1940 15 ISZERO 1941 80 DUP1 1942 15 ISZERO 1943 61 PUSH2 0x1950 1946 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @193F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1940 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1950, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1947: // Incoming jump from 0x1946, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1947 returndata.length // @194B returndata[0x00:0x00 + returndata.length] // @194C returndata.length // @194F memory[0x00:0x00 + returndata.length] // } 1947 3D RETURNDATASIZE 1948 60 PUSH1 0x00 194A 80 DUP1 194B 3E RETURNDATACOPY 194C 3D RETURNDATASIZE 194D 60 PUSH1 0x00 194F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @194B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @194F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1950: // Incoming jump from 0x1946, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1957 memory[0x40:0x60] // @1958 returndata.length // } 1950 5B JUMPDEST 1951 50 POP 1952 50 POP 1953 50 POP 1954 50 POP 1955 60 PUSH1 0x40 1957 51 MLOAD 1958 3D RETURNDATASIZE 1959 60 PUSH1 0x20 195B 81 DUP2 195C 10 LT 195D 15 ISZERO 195E 61 PUSH2 0x1966 1961 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1957 stack[-4] = memory[0x40:0x60] // @1958 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1966, if !(returndata.length < 0x20) label_1962: // Incoming jump from 0x1961, if not !(returndata.length < 0x20) // Inputs[1] { @1965 memory[0x00:0x00] } 1962 60 PUSH1 0x00 1964 80 DUP1 1965 FD *REVERT // Stack delta = +0 // Outputs[1] { @1965 revert(memory[0x00:0x00]); } // Block terminates label_1966: // Incoming jump from 0x1961, if !(returndata.length < 0x20) // Inputs[5] // { // @1967 stack[-2] // @1968 stack[-1] // @196C memory[stack[-2]:stack[-2] + 0x20] // @1978 stack[-3] // @19DE stack[-4] // } 1966 5B JUMPDEST 1967 81 DUP2 1968 01 ADD 1969 90 SWAP1 196A 80 DUP1 196B 80 DUP1 196C 51 MLOAD 196D 90 SWAP1 196E 60 PUSH1 0x20 1970 01 ADD 1971 90 SWAP1 1972 92 SWAP3 1973 91 SWAP2 1974 90 SWAP1 1975 50 POP 1976 50 POP 1977 50 POP 1978 90 SWAP1 1979 50 POP 197A 63 PUSH4 0x150b7a02 197F 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 199D 02 MUL 199E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 19BB 19 NOT 19BC 16 AND 19BD 81 DUP2 19BE 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 19DB 19 NOT 19DC 16 AND 19DD 14 EQ 19DE 91 SWAP2 19DF 50 POP 19E0 50 POP // Stack delta = -3 // Outputs[1] { @19DE stack[-4] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000 * 0x150b7a02 } // Block continues label_19E1: // Incoming jump from 0x19E0 // Incoming jump from 0x17F5 // Inputs[3] // { // @19E2 stack[-1] // @19E2 stack[-6] // @19E3 stack[-5] // } 19E1 5B JUMPDEST 19E2 94 SWAP5 19E3 93 SWAP4 19E4 50 POP 19E5 50 POP 19E6 50 POP 19E7 50 POP 19E8 56 *JUMP // Stack delta = -5 // Outputs[1] { @19E2 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_19E9: // Incoming call from 0x15BE, returns to 0x15BF // Inputs[2] // { // @19EA stack[-3] // @1A04 stack[-1] // } 19E9 5B JUMPDEST 19EA 82 DUP3 19EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A00 16 AND 1A01 61 PUSH2 0x1a09 1A04 82 DUP3 1A05 61 PUSH2 0x0ff9 1A08 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A00 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1A01 stack[1] = 0x1a09 // @1A04 stack[2] = stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x1A09 label_1A09: // Incoming return from call to 0x0FF9 at 0x1A08 // Inputs[2] // { // @1A1F stack[-1] // @1A20 stack[-2] // } 1A09 5B JUMPDEST 1A0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A1F 16 AND 1A20 14 EQ 1A21 15 ISZERO 1A22 15 ISZERO 1A23 61 PUSH2 0x1a2b 1A26 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1a2b, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) label_1A27: // Incoming jump from 0x1A26, if not !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) // Inputs[1] { @1A2A memory[0x00:0x00] } 1A27 60 PUSH1 0x00 1A29 80 DUP1 1A2A FD *REVERT // Stack delta = +0 // Outputs[1] { @1A2A revert(memory[0x00:0x00]); } // Block terminates label_1A2B: // Incoming jump from 0x1A26, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) // Inputs[1] { @1A44 stack[-2] } 1A2B 5B JUMPDEST 1A2C 60 PUSH1 0x00 1A2E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A43 16 AND 1A44 82 DUP3 1A45 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A5A 16 AND 1A5B 14 EQ 1A5C 15 ISZERO 1A5D 15 ISZERO 1A5E 15 ISZERO 1A5F 61 PUSH2 0x1a67 1A62 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a67, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1A63: // Incoming jump from 0x1A62, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1A66 memory[0x00:0x00] } 1A63 60 PUSH1 0x00 1A65 80 DUP1 1A66 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A66 revert(memory[0x00:0x00]); } // Block terminates label_1A67: // Incoming jump from 0x1A62, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1A6B stack[-1] } 1A67 5B JUMPDEST 1A68 61 PUSH2 0x1a70 1A6B 81 DUP2 1A6C 61 PUSH2 0x21a3 1A6F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A68 stack[0] = 0x1a70 // @1A6B stack[1] = stack[-1] // } // Block ends with call to 0x21a3, returns to 0x1A70 label_1A70: // Incoming return from call to 0x21A3 at 0x1A6F // Inputs[2] // { // @1A78 stack[-3] // @1AB2 memory[0x00:0x40] // } 1A70 5B JUMPDEST 1A71 61 PUSH2 0x1ab7 1A74 60 PUSH1 0x03 1A76 60 PUSH1 0x00 1A78 85 DUP6 1A79 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A8E 16 AND 1A8F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AA4 16 AND 1AA5 81 DUP2 1AA6 52 MSTORE 1AA7 60 PUSH1 0x20 1AA9 01 ADD 1AAA 90 SWAP1 1AAB 81 DUP2 1AAC 52 MSTORE 1AAD 60 PUSH1 0x20 1AAF 01 ADD 1AB0 60 PUSH1 0x00 1AB2 20 SHA3 1AB3 61 PUSH2 0x2263 1AB6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1A71 stack[0] = 0x1ab7 // @1AA6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1AAC memory[0x20:0x40] = 0x03 // @1AB2 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2263, returns to 0x1AB7 label_1AB7: // Incoming return from call to 0x2263 at 0x1AB6 // Inputs[2] // { // @1ABF stack[-2] // @1AF9 memory[0x00:0x40] // } 1AB7 5B JUMPDEST 1AB8 61 PUSH2 0x1afe 1ABB 60 PUSH1 0x03 1ABD 60 PUSH1 0x00 1ABF 84 DUP5 1AC0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AD5 16 AND 1AD6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AEB 16 AND 1AEC 81 DUP2 1AED 52 MSTORE 1AEE 60 PUSH1 0x20 1AF0 01 ADD 1AF1 90 SWAP1 1AF2 81 DUP2 1AF3 52 MSTORE 1AF4 60 PUSH1 0x20 1AF6 01 ADD 1AF7 60 PUSH1 0x00 1AF9 20 SHA3 1AFA 61 PUSH2 0x2286 1AFD 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1AB8 stack[0] = 0x1afe // @1AED memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1AF3 memory[0x20:0x40] = 0x03 // @1AF9 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2286, returns to 0x1AFE label_1AFE: // Incoming return from call to 0x2286 at 0x1AFD // Inputs[9] // { // @1AFF stack[-2] // @1B04 stack[-1] // @1B12 memory[0x00:0x40] // @1B1A storage[keccak256(memory[0x00:0x40])] // @1B69 stack[-3] // @1BA3 memory[0x40:0x60] // @1BA6 memory[0x40:0x60] // @1BAB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1BAF stack[-4] // } 1AFE 5B JUMPDEST 1AFF 81 DUP2 1B00 60 PUSH1 0x01 1B02 60 PUSH1 0x00 1B04 83 DUP4 1B05 81 DUP2 1B06 52 MSTORE 1B07 60 PUSH1 0x20 1B09 01 ADD 1B0A 90 SWAP1 1B0B 81 DUP2 1B0C 52 MSTORE 1B0D 60 PUSH1 0x20 1B0F 01 ADD 1B10 60 PUSH1 0x00 1B12 20 SHA3 1B13 60 PUSH1 0x00 1B15 61 PUSH2 0x0100 1B18 0A EXP 1B19 81 DUP2 1B1A 54 SLOAD 1B1B 81 DUP2 1B1C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B31 02 MUL 1B32 19 NOT 1B33 16 AND 1B34 90 SWAP1 1B35 83 DUP4 1B36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B4B 16 AND 1B4C 02 MUL 1B4D 17 OR 1B4E 90 SWAP1 1B4F 55 SSTORE 1B50 50 POP 1B51 80 DUP1 1B52 82 DUP3 1B53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B68 16 AND 1B69 84 DUP5 1B6A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B7F 16 AND 1B80 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1BA1 60 PUSH1 0x40 1BA3 51 MLOAD 1BA4 60 PUSH1 0x40 1BA6 51 MLOAD 1BA7 80 DUP1 1BA8 91 SWAP2 1BA9 03 SUB 1BAA 90 SWAP1 1BAB A4 LOG4 1BAC 50 POP 1BAD 50 POP 1BAE 50 POP 1BAF 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1B06 memory[0x00:0x20] = stack[-1] // @1B0C memory[0x20:0x40] = 0x01 // @1B4F storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1BAB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); // } // Block ends with unconditional jump to stack[-4] label_1BB0: // Incoming call from 0x22D1, returns to 0x22D2 // Incoming call from 0x15C8, returns to 0x15C9 // Inputs[3] // { // @1BBC stack[-2] // @1BF6 memory[0x00:0x40] // @1BF8 storage[keccak256(memory[0x00:0x40])] // } 1BB0 5B JUMPDEST 1BB1 60 PUSH1 0x00 1BB3 61 PUSH2 0x1c08 1BB6 60 PUSH1 0x01 1BB8 60 PUSH1 0x05 1BBA 60 PUSH1 0x00 1BBC 86 DUP7 1BBD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BD2 16 AND 1BD3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BE8 16 AND 1BE9 81 DUP2 1BEA 52 MSTORE 1BEB 60 PUSH1 0x20 1BED 01 ADD 1BEE 90 SWAP1 1BEF 81 DUP2 1BF0 52 MSTORE 1BF1 60 PUSH1 0x20 1BF3 01 ADD 1BF4 60 PUSH1 0x00 1BF6 20 SHA3 1BF7 80 DUP1 1BF8 54 SLOAD 1BF9 90 SWAP1 1BFA 50 POP 1BFB 61 PUSH2 0x229c 1BFE 90 SWAP1 1BFF 91 SWAP2 1C00 90 SWAP1 1C01 63 PUSH4 0xffffffff 1C06 16 AND 1C07 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1BB1 stack[0] = 0x00 // @1BB3 stack[1] = 0x1c08 // @1BEA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1BF0 memory[0x20:0x40] = 0x05 // @1BFF stack[2] = storage[keccak256(memory[0x00:0x40])] // @1C00 stack[3] = 0x01 // } // Block ends with call to 0xffffffff & 0x229c, returns to 0x1C08 label_1C08: // Incoming return from call to 0x229C at 0x1C07 // Inputs[5] // { // @1C09 stack[-1] // @1C09 stack[-2] // @1C11 stack[-3] // @1C1F memory[0x00:0x40] // @1C20 storage[keccak256(memory[0x00:0x40])] // } 1C08 5B JUMPDEST 1C09 90 SWAP1 1C0A 50 POP 1C0B 60 PUSH1 0x00 1C0D 60 PUSH1 0x06 1C0F 60 PUSH1 0x00 1C11 84 DUP5 1C12 81 DUP2 1C13 52 MSTORE 1C14 60 PUSH1 0x20 1C16 01 ADD 1C17 90 SWAP1 1C18 81 DUP2 1C19 52 MSTORE 1C1A 60 PUSH1 0x20 1C1C 01 ADD 1C1D 60 PUSH1 0x00 1C1F 20 SHA3 1C20 54 SLOAD 1C21 90 SWAP1 1C22 50 POP 1C23 81 DUP2 1C24 81 DUP2 1C25 14 EQ 1C26 15 ISZERO 1C27 15 ISZERO 1C28 61 PUSH2 0x1cfb 1C2B 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C09 stack[-2] = stack[-1] // @1C13 memory[0x00:0x20] = stack[-3] // @1C19 memory[0x20:0x40] = 0x06 // @1C21 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1cfb, if !!(storage[keccak256(memory[0x00:0x40])] == stack[-1]) label_1C2C: // Incoming jump from 0x1C2B, if not !!(storage[keccak256(memory[0x00:0x40])] == stack[-1]) // Inputs[4] // { // @1C32 stack[-4] // @1C6C memory[0x00:0x40] // @1C6D stack[-2] // @1C6F storage[keccak256(memory[0x00:0x40])] // } 1C2C 60 PUSH1 0x00 1C2E 60 PUSH1 0x05 1C30 60 PUSH1 0x00 1C32 86 DUP7 1C33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C48 16 AND 1C49 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C5E 16 AND 1C5F 81 DUP2 1C60 52 MSTORE 1C61 60 PUSH1 0x20 1C63 01 ADD 1C64 90 SWAP1 1C65 81 DUP2 1C66 52 MSTORE 1C67 60 PUSH1 0x20 1C69 01 ADD 1C6A 60 PUSH1 0x00 1C6C 20 SHA3 1C6D 83 DUP4 1C6E 81 DUP2 1C6F 54 SLOAD 1C70 81 DUP2 1C71 10 LT 1C72 15 ISZERO 1C73 15 ISZERO 1C74 61 PUSH2 0x1c79 1C77 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @1C2C stack[0] = 0x00 // @1C60 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1C66 memory[0x20:0x40] = 0x05 // @1C6C stack[1] = keccak256(memory[0x00:0x40]) // @1C6D stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1c79, if !!(stack[-2] < storage[keccak256(memory[0x00:0x40])]) label_1C78: // Incoming jump from 0x1C77, if not !!(stack[-2] < storage[keccak256(memory[0x00:0x40])]) 1C78 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C78 assert(); } // Block terminates label_1C79: // Incoming jump from 0x1C77, if !!(stack[-2] < storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @1C7A stack[-1] // @1C7A stack[-2] // @1C82 memory[0x00:0x20] // @1C84 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1C85 stack[-3] // @1C8C stack[-7] // @1CC6 memory[0x00:0x40] // @1CC7 stack[-4] // @1CC9 storage[keccak256(memory[0x00:0x40])] // } 1C79 5B JUMPDEST 1C7A 90 SWAP1 1C7B 60 PUSH1 0x00 1C7D 52 MSTORE 1C7E 60 PUSH1 0x20 1C80 60 PUSH1 0x00 1C82 20 SHA3 1C83 01 ADD 1C84 54 SLOAD 1C85 90 SWAP1 1C86 50 POP 1C87 80 DUP1 1C88 60 PUSH1 0x05 1C8A 60 PUSH1 0x00 1C8C 87 DUP8 1C8D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CA2 16 AND 1CA3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CB8 16 AND 1CB9 81 DUP2 1CBA 52 MSTORE 1CBB 60 PUSH1 0x20 1CBD 01 ADD 1CBE 90 SWAP1 1CBF 81 DUP2 1CC0 52 MSTORE 1CC1 60 PUSH1 0x20 1CC3 01 ADD 1CC4 60 PUSH1 0x00 1CC6 20 SHA3 1CC7 83 DUP4 1CC8 81 DUP2 1CC9 54 SLOAD 1CCA 81 DUP2 1CCB 10 LT 1CCC 15 ISZERO 1CCD 15 ISZERO 1CCE 61 PUSH2 0x1cd3 1CD1 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @1C7D memory[0x00:0x20] = stack[-2] // @1C85 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1C87 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1CBA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @1CC0 memory[0x20:0x40] = 0x05 // @1CC6 stack[-1] = keccak256(memory[0x00:0x40]) // @1CC7 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x1cd3, if !!(stack[-4] < storage[keccak256(memory[0x00:0x40])]) label_1CD2: // Incoming jump from 0x1CD1, if not !!(stack[-4] < storage[keccak256(memory[0x00:0x40])]) 1CD2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1CD2 assert(); } // Block terminates label_1CD3: // Incoming jump from 0x1CD1, if !!(stack[-4] < storage[keccak256(memory[0x00:0x40])]) // Inputs[7] // { // @1CD4 stack[-1] // @1CD4 stack[-2] // @1CDC memory[0x00:0x20] // @1CDE stack[-3] // @1CE2 stack[-5] // @1CE7 stack[-4] // @1CF5 memory[0x00:0x40] // } 1CD3 5B JUMPDEST 1CD4 90 SWAP1 1CD5 60 PUSH1 0x00 1CD7 52 MSTORE 1CD8 60 PUSH1 0x20 1CDA 60 PUSH1 0x00 1CDC 20 SHA3 1CDD 01 ADD 1CDE 81 DUP2 1CDF 90 SWAP1 1CE0 55 SSTORE 1CE1 50 POP 1CE2 81 DUP2 1CE3 60 PUSH1 0x06 1CE5 60 PUSH1 0x00 1CE7 83 DUP4 1CE8 81 DUP2 1CE9 52 MSTORE 1CEA 60 PUSH1 0x20 1CEC 01 ADD 1CED 90 SWAP1 1CEE 81 DUP2 1CEF 52 MSTORE 1CF0 60 PUSH1 0x20 1CF2 01 ADD 1CF3 60 PUSH1 0x00 1CF5 20 SHA3 1CF6 81 DUP2 1CF7 90 SWAP1 1CF8 55 SSTORE 1CF9 50 POP 1CFA 50 POP // Stack delta = -4 // Outputs[5] // { // @1CD7 memory[0x00:0x20] = stack[-2] // @1CE0 storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @1CE9 memory[0x00:0x20] = stack[-4] // @1CEF memory[0x20:0x40] = 0x06 // @1CF8 storage[keccak256(memory[0x00:0x40])] = stack[-5] // } // Block continues label_1CFB: // Incoming jump from 0x1CFA // Incoming jump from 0x1C2B, if !!(storage[keccak256(memory[0x00:0x40])] == stack[-1]) // Inputs[3] // { // @1D00 stack[-4] // @1D3A memory[0x00:0x40] // @1D3C storage[keccak256(memory[0x00:0x40])] // } 1CFB 5B JUMPDEST 1CFC 60 PUSH1 0x05 1CFE 60 PUSH1 0x00 1D00 85 DUP6 1D01 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D16 16 AND 1D17 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D2C 16 AND 1D2D 81 DUP2 1D2E 52 MSTORE 1D2F 60 PUSH1 0x20 1D31 01 ADD 1D32 90 SWAP1 1D33 81 DUP2 1D34 52 MSTORE 1D35 60 PUSH1 0x20 1D37 01 ADD 1D38 60 PUSH1 0x00 1D3A 20 SHA3 1D3B 80 DUP1 1D3C 54 SLOAD 1D3D 80 DUP1 1D3E 91 SWAP2 1D3F 90 SWAP1 1D40 60 PUSH1 0x01 1D42 90 SWAP1 1D43 03 SUB 1D44 61 PUSH2 0x1d4d 1D47 91 SWAP2 1D48 90 SWAP1 1D49 61 PUSH2 0x257b 1D4C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1D2E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1D34 memory[0x20:0x40] = 0x05 // @1D3E stack[0] = storage[keccak256(memory[0x00:0x40])] // @1D47 stack[1] = 0x1d4d // @1D48 stack[2] = keccak256(memory[0x00:0x40]) // @1D48 stack[3] = storage[keccak256(memory[0x00:0x40])] - 0x01 // } // Block ends with call to 0x257b, returns to 0x1D4D label_1D4D: // Incoming return from call to 0x257B at 0x1D4C // Inputs[1] { @1D53 stack[-6] } 1D4D 5B JUMPDEST 1D4E 50 POP 1D4F 50 POP 1D50 50 POP 1D51 50 POP 1D52 50 POP 1D53 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1D54: // Incoming call from 0x1622, returns to 0x1623 // Incoming call from 0x15D2, returns to 0x15D3 // Inputs[9] // { // @1D59 stack[-2] // @1D93 memory[0x00:0x40] // @1D95 storage[keccak256(memory[0x00:0x40])] // @1D9C stack[-1] // @1DAA memory[0x00:0x40] // @1DED memory[0x00:0x40] // @1DF4 storage[keccak256(memory[0x00:0x40])] // @1E0A memory[0x00:0x20] // @1E1A stack[-3] // } 1D54 5B JUMPDEST 1D55 60 PUSH1 0x05 1D57 60 PUSH1 0x00 1D59 83 DUP4 1D5A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D6F 16 AND 1D70 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D85 16 AND 1D86 81 DUP2 1D87 52 MSTORE 1D88 60 PUSH1 0x20 1D8A 01 ADD 1D8B 90 SWAP1 1D8C 81 DUP2 1D8D 52 MSTORE 1D8E 60 PUSH1 0x20 1D90 01 ADD 1D91 60 PUSH1 0x00 1D93 20 SHA3 1D94 80 DUP1 1D95 54 SLOAD 1D96 90 SWAP1 1D97 50 POP 1D98 60 PUSH1 0x06 1D9A 60 PUSH1 0x00 1D9C 83 DUP4 1D9D 81 DUP2 1D9E 52 MSTORE 1D9F 60 PUSH1 0x20 1DA1 01 ADD 1DA2 90 SWAP1 1DA3 81 DUP2 1DA4 52 MSTORE 1DA5 60 PUSH1 0x20 1DA7 01 ADD 1DA8 60 PUSH1 0x00 1DAA 20 SHA3 1DAB 81 DUP2 1DAC 90 SWAP1 1DAD 55 SSTORE 1DAE 50 POP 1DAF 60 PUSH1 0x05 1DB1 60 PUSH1 0x00 1DB3 83 DUP4 1DB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DC9 16 AND 1DCA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DDF 16 AND 1DE0 81 DUP2 1DE1 52 MSTORE 1DE2 60 PUSH1 0x20 1DE4 01 ADD 1DE5 90 SWAP1 1DE6 81 DUP2 1DE7 52 MSTORE 1DE8 60 PUSH1 0x20 1DEA 01 ADD 1DEB 60 PUSH1 0x00 1DED 20 SHA3 1DEE 81 DUP2 1DEF 90 SWAP1 1DF0 80 DUP1 1DF1 60 PUSH1 0x01 1DF3 81 DUP2 1DF4 54 SLOAD 1DF5 01 ADD 1DF6 80 DUP1 1DF7 82 DUP3 1DF8 55 SSTORE 1DF9 80 DUP1 1DFA 91 SWAP2 1DFB 50 POP 1DFC 50 POP 1DFD 90 SWAP1 1DFE 60 PUSH1 0x01 1E00 82 DUP3 1E01 03 SUB 1E02 90 SWAP1 1E03 60 PUSH1 0x00 1E05 52 MSTORE 1E06 60 PUSH1 0x20 1E08 60 PUSH1 0x00 1E0A 20 SHA3 1E0B 01 ADD 1E0C 60 PUSH1 0x00 1E0E 90 SWAP1 1E0F 91 SWAP2 1E10 92 SWAP3 1E11 90 SWAP1 1E12 91 SWAP2 1E13 90 SWAP1 1E14 91 SWAP2 1E15 50 POP 1E16 55 SSTORE 1E17 50 POP 1E18 50 POP 1E19 50 POP 1E1A 56 *JUMP // Stack delta = -3 // Outputs[10] // { // @1D87 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1D8D memory[0x20:0x40] = 0x05 // @1D9E memory[0x00:0x20] = stack[-1] // @1DA4 memory[0x20:0x40] = 0x06 // @1DAD storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @1DE1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1DE7 memory[0x20:0x40] = 0x05 // @1DF8 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @1E05 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @1E16 storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1E1B: // Incoming jump from 0x15E9 // Inputs[2] // { // @1E1F stack[-2] // @1E20 stack[-1] // } 1E1B 5B JUMPDEST 1E1C 61 PUSH2 0x1e25 1E1F 82 DUP3 1E20 82 DUP3 1E21 61 PUSH2 0x22be 1E24 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E1C stack[0] = 0x1e25 // @1E1F stack[1] = stack[-2] // @1E20 stack[2] = stack[-1] // } // Block ends with call to 0x22be, returns to 0x1E25 label_1E25: // Incoming return from call to 0x22BE at 0x1E24 // Inputs[3] // { // @1E2C stack[-1] // @1E3A memory[0x00:0x40] // @1E3C storage[keccak256(memory[0x00:0x40])] // } 1E25 5B JUMPDEST 1E26 60 PUSH1 0x00 1E28 60 PUSH1 0x0b 1E2A 60 PUSH1 0x00 1E2C 83 DUP4 1E2D 81 DUP2 1E2E 52 MSTORE 1E2F 60 PUSH1 0x20 1E31 01 ADD 1E32 90 SWAP1 1E33 81 DUP2 1E34 52 MSTORE 1E35 60 PUSH1 0x20 1E37 01 ADD 1E38 60 PUSH1 0x00 1E3A 20 SHA3 1E3B 80 DUP1 1E3C 54 SLOAD 1E3D 60 PUSH1 0x01 1E3F 81 DUP2 1E40 60 PUSH1 0x01 1E42 16 AND 1E43 15 ISZERO 1E44 61 PUSH2 0x0100 1E47 02 MUL 1E48 03 SUB 1E49 16 AND 1E4A 60 PUSH1 0x02 1E4C 90 SWAP1 1E4D 04 DIV 1E4E 90 SWAP1 1E4F 50 POP 1E50 14 EQ 1E51 15 ISZERO 1E52 15 ISZERO 1E53 61 PUSH2 0x1e76 1E56 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1E2E memory[0x00:0x20] = stack[-1] // @1E34 memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x1e76, if !!((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 == 0x00) label_1E57: // Incoming jump from 0x1E56, if not !!((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 == 0x00) // Inputs[2] // { // @1E5B stack[-1] // @1E69 memory[0x00:0x40] // } 1E57 60 PUSH1 0x0b 1E59 60 PUSH1 0x00 1E5B 82 DUP3 1E5C 81 DUP2 1E5D 52 MSTORE 1E5E 60 PUSH1 0x20 1E60 01 ADD 1E61 90 SWAP1 1E62 81 DUP2 1E63 52 MSTORE 1E64 60 PUSH1 0x20 1E66 01 ADD 1E67 60 PUSH1 0x00 1E69 20 SHA3 1E6A 60 PUSH1 0x00 1E6C 61 PUSH2 0x1e75 1E6F 91 SWAP2 1E70 90 SWAP1 1E71 61 PUSH2 0x25a7 1E74 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1E5D memory[0x00:0x20] = stack[-1] // @1E63 memory[0x20:0x40] = 0x0b // @1E6F stack[0] = 0x1e75 // @1E70 stack[1] = keccak256(memory[0x00:0x40]) // @1E70 stack[2] = 0x00 // } // Block ends with call to 0x25a7, returns to 0x1E75 label_1E75: // Incoming return from call to 0x25A7 at 0x1E74 1E75 5B JUMPDEST // Stack delta = +0 // Block continues label_1E76: // Incoming jump from 0x1E56, if !!((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 == 0x00) // Incoming jump from 0x1E75 // Inputs[1] { @1E79 stack[-3] } 1E76 5B JUMPDEST 1E77 50 POP 1E78 50 POP 1E79 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1E7A: // Incoming jump from 0x1609 // Inputs[2] // { // @1E7E stack[-1] // @1E7F stack[-2] // } 1E7A 5B JUMPDEST 1E7B 60 PUSH1 0x00 1E7D 80 DUP1 1E7E 82 DUP3 1E7F 84 DUP5 1E80 01 ADD 1E81 90 SWAP1 1E82 50 POP 1E83 83 DUP4 1E84 81 DUP2 1E85 10 LT 1E86 15 ISZERO 1E87 15 ISZERO 1E88 15 ISZERO 1E89 61 PUSH2 0x1e91 1E8C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E7B stack[0] = 0x00 // @1E81 stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x1e91, if !!!(stack[-2] + stack[-1] < stack[-2]) label_1E8D: // Incoming jump from 0x1E8C, if not !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @1E90 memory[0x00:0x00] } 1E8D 60 PUSH1 0x00 1E8F 80 DUP1 1E90 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E90 revert(memory[0x00:0x00]); } // Block terminates label_1E91: // Incoming jump from 0x1E8C, if !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @1E92 stack[-1] // @1E93 stack[-2] // @1E96 stack[-5] // @1E97 stack[-4] // } 1E91 5B JUMPDEST 1E92 80 DUP1 1E93 91 SWAP2 1E94 50 POP 1E95 50 POP 1E96 92 SWAP3 1E97 91 SWAP2 1E98 50 POP 1E99 50 POP 1E9A 56 *JUMP // Stack delta = -4 // Outputs[1] { @1E96 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1E9B: // Incoming call from 0x1618, returns to 0x1619 // Inputs[1] { @1EB4 stack[-2] } 1E9B 5B JUMPDEST 1E9C 60 PUSH1 0x00 1E9E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EB3 16 AND 1EB4 82 DUP3 1EB5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1ECA 16 AND 1ECB 14 EQ 1ECC 15 ISZERO 1ECD 15 ISZERO 1ECE 15 ISZERO 1ECF 61 PUSH2 0x1ed7 1ED2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ed7, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1ED3: // Incoming jump from 0x1ED2, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1ED6 memory[0x00:0x00] } 1ED3 60 PUSH1 0x00 1ED5 80 DUP1 1ED6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1ED6 revert(memory[0x00:0x00]); } // Block terminates label_1ED7: // Incoming jump from 0x1ED2, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1EDB stack[-1] } 1ED7 5B JUMPDEST 1ED8 61 PUSH2 0x1ee0 1EDB 81 DUP2 1EDC 61 PUSH2 0x14ad 1EDF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1ED8 stack[0] = 0x1ee0 // @1EDB stack[1] = stack[-1] // } // Block ends with call to 0x14ad, returns to 0x1EE0 label_1EE0: // Incoming return from call to 0x14AD at 0x1EDF // Inputs[1] { @1EE1 stack[-1] } 1EE0 5B JUMPDEST 1EE1 15 ISZERO 1EE2 15 ISZERO 1EE3 15 ISZERO 1EE4 61 PUSH2 0x1eec 1EE7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1eec, if !!!stack[-1] label_1EE8: // Incoming jump from 0x1EE7, if not !!!stack[-1] // Inputs[1] { @1EEB memory[0x00:0x00] } 1EE8 60 PUSH1 0x00 1EEA 80 DUP1 1EEB FD *REVERT // Stack delta = +0 // Outputs[1] { @1EEB revert(memory[0x00:0x00]); } // Block terminates label_1EEC: // Incoming jump from 0x1EE7, if !!!stack[-1] // Inputs[5] // { // @1EED stack[-2] // @1EF2 stack[-1] // @1F00 memory[0x00:0x40] // @1F08 storage[keccak256(memory[0x00:0x40])] // @1F80 memory[0x00:0x40] // } 1EEC 5B JUMPDEST 1EED 81 DUP2 1EEE 60 PUSH1 0x01 1EF0 60 PUSH1 0x00 1EF2 83 DUP4 1EF3 81 DUP2 1EF4 52 MSTORE 1EF5 60 PUSH1 0x20 1EF7 01 ADD 1EF8 90 SWAP1 1EF9 81 DUP2 1EFA 52 MSTORE 1EFB 60 PUSH1 0x20 1EFD 01 ADD 1EFE 60 PUSH1 0x00 1F00 20 SHA3 1F01 60 PUSH1 0x00 1F03 61 PUSH2 0x0100 1F06 0A EXP 1F07 81 DUP2 1F08 54 SLOAD 1F09 81 DUP2 1F0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F1F 02 MUL 1F20 19 NOT 1F21 16 AND 1F22 90 SWAP1 1F23 83 DUP4 1F24 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F39 16 AND 1F3A 02 MUL 1F3B 17 OR 1F3C 90 SWAP1 1F3D 55 SSTORE 1F3E 50 POP 1F3F 61 PUSH2 0x1f85 1F42 60 PUSH1 0x03 1F44 60 PUSH1 0x00 1F46 84 DUP5 1F47 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F5C 16 AND 1F5D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F72 16 AND 1F73 81 DUP2 1F74 52 MSTORE 1F75 60 PUSH1 0x20 1F77 01 ADD 1F78 90 SWAP1 1F79 81 DUP2 1F7A 52 MSTORE 1F7B 60 PUSH1 0x20 1F7D 01 ADD 1F7E 60 PUSH1 0x00 1F80 20 SHA3 1F81 61 PUSH2 0x2286 1F84 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @1EF4 memory[0x00:0x20] = stack[-1] // @1EFA memory[0x20:0x40] = 0x01 // @1F3D storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1F3F stack[0] = 0x1f85 // @1F74 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1F7A memory[0x20:0x40] = 0x03 // @1F80 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2286, returns to 0x1F85 label_1F85: // Incoming return from call to 0x2286 at 0x1F84 // Inputs[6] // { // @1F86 stack[-1] // @1F87 stack[-2] // @1FD9 memory[0x40:0x60] // @1FDC memory[0x40:0x60] // @1FE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1FE4 stack[-3] // } 1F85 5B JUMPDEST 1F86 80 DUP1 1F87 82 DUP3 1F88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F9D 16 AND 1F9E 60 PUSH1 0x00 1FA0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FB5 16 AND 1FB6 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1FD7 60 PUSH1 0x40 1FD9 51 MLOAD 1FDA 60 PUSH1 0x40 1FDC 51 MLOAD 1FDD 80 DUP1 1FDE 91 SWAP2 1FDF 03 SUB 1FE0 90 SWAP1 1FE1 A4 LOG4 1FE2 50 POP 1FE3 50 POP 1FE4 56 *JUMP // Stack delta = -3 // Outputs[1] { @1FE1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); } // Block ends with unconditional jump to stack[-3] label_1FE5: // Incoming call from 0x162B, returns to 0x162C // Inputs[6] // { // @1FE9 storage[0x07] // @1FF0 stack[-1] // @1FFE memory[0x00:0x40] // @200B storage[0x07] // @2021 memory[0x00:0x20] // @2030 stack[-2] // } 1FE5 5B JUMPDEST 1FE6 60 PUSH1 0x07 1FE8 80 DUP1 1FE9 54 SLOAD 1FEA 90 SWAP1 1FEB 50 POP 1FEC 60 PUSH1 0x08 1FEE 60 PUSH1 0x00 1FF0 83 DUP4 1FF1 81 DUP2 1FF2 52 MSTORE 1FF3 60 PUSH1 0x20 1FF5 01 ADD 1FF6 90 SWAP1 1FF7 81 DUP2 1FF8 52 MSTORE 1FF9 60 PUSH1 0x20 1FFB 01 ADD 1FFC 60 PUSH1 0x00 1FFE 20 SHA3 1FFF 81 DUP2 2000 90 SWAP1 2001 55 SSTORE 2002 50 POP 2003 60 PUSH1 0x07 2005 81 DUP2 2006 90 SWAP1 2007 80 DUP1 2008 60 PUSH1 0x01 200A 81 DUP2 200B 54 SLOAD 200C 01 ADD 200D 80 DUP1 200E 82 DUP3 200F 55 SSTORE 2010 80 DUP1 2011 91 SWAP2 2012 50 POP 2013 50 POP 2014 90 SWAP1 2015 60 PUSH1 0x01 2017 82 DUP3 2018 03 SUB 2019 90 SWAP1 201A 60 PUSH1 0x00 201C 52 MSTORE 201D 60 PUSH1 0x20 201F 60 PUSH1 0x00 2021 20 SHA3 2022 01 ADD 2023 60 PUSH1 0x00 2025 90 SWAP1 2026 91 SWAP2 2027 92 SWAP3 2028 90 SWAP1 2029 91 SWAP2 202A 90 SWAP1 202B 91 SWAP2 202C 50 POP 202D 55 SSTORE 202E 50 POP 202F 50 POP 2030 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @1FF2 memory[0x00:0x20] = stack[-1] // @1FF8 memory[0x20:0x40] = 0x08 // @2001 storage[keccak256(memory[0x00:0x40])] = storage[0x07] // @200F storage[0x07] = storage[0x07] + 0x01 // @201C memory[0x00:0x20] = 0x07 // @202D storage[keccak256(memory[0x00:0x20]) + ((storage[0x07] + 0x01) - 0x01)] = stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2031: // Incoming call from 0x1691, returns to 0x1692 // Inputs[1] { @204A stack[-1] } 2031 5B JUMPDEST 2032 60 PUSH1 0x00 2034 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2049 16 AND 204A 81 DUP2 204B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2060 16 AND 2061 14 EQ 2062 15 ISZERO 2063 15 ISZERO 2064 15 ISZERO 2065 61 PUSH2 0x206d 2068 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x206d, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2069: // Incoming jump from 0x2068, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @206C memory[0x00:0x00] } 2069 60 PUSH1 0x00 206B 80 DUP1 206C FD *REVERT // Stack delta = +0 // Outputs[1] { @206C revert(memory[0x00:0x00]); } // Block terminates label_206D: // Incoming jump from 0x2068, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @2071 stack[-2] // @2072 stack[-1] // } 206D 5B JUMPDEST 206E 61 PUSH2 0x2077 2071 82 DUP3 2072 82 DUP3 2073 61 PUSH2 0x1732 2076 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @206E stack[0] = 0x2077 // @2071 stack[1] = stack[-2] // @2072 stack[2] = stack[-1] // } // Block ends with call to 0x1732, returns to 0x2077 label_2077: // Incoming return from call to 0x1732 at 0x2076 // Inputs[1] { @2078 stack[-1] } 2077 5B JUMPDEST 2078 15 ISZERO 2079 15 ISZERO 207A 15 ISZERO 207B 61 PUSH2 0x2083 207E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2083, if !!!stack[-1] label_207F: // Incoming jump from 0x207E, if not !!!stack[-1] // Inputs[1] { @2082 memory[0x00:0x00] } 207F 60 PUSH1 0x00 2081 80 DUP1 2082 FD *REVERT // Stack delta = +0 // Outputs[1] { @2082 revert(memory[0x00:0x00]); } // Block terminates label_2083: // Incoming jump from 0x207E, if !!!stack[-1] // Inputs[5] // { // @2086 stack[-2] // @208C stack[-1] // @20C6 memory[0x00:0x40] // @20CE storage[keccak256(memory[0x00:0x40])] // @20E0 stack[-3] // } 2083 5B JUMPDEST 2084 60 PUSH1 0x01 2086 82 DUP3 2087 60 PUSH1 0x00 2089 01 ADD 208A 60 PUSH1 0x00 208C 83 DUP4 208D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20A2 16 AND 20A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20B8 16 AND 20B9 81 DUP2 20BA 52 MSTORE 20BB 60 PUSH1 0x20 20BD 01 ADD 20BE 90 SWAP1 20BF 81 DUP2 20C0 52 MSTORE 20C1 60 PUSH1 0x20 20C3 01 ADD 20C4 60 PUSH1 0x00 20C6 20 SHA3 20C7 60 PUSH1 0x00 20C9 61 PUSH2 0x0100 20CC 0A EXP 20CD 81 DUP2 20CE 54 SLOAD 20CF 81 DUP2 20D0 60 PUSH1 0xff 20D2 02 MUL 20D3 19 NOT 20D4 16 AND 20D5 90 SWAP1 20D6 83 DUP4 20D7 15 ISZERO 20D8 15 ISZERO 20D9 02 MUL 20DA 17 OR 20DB 90 SWAP1 20DC 55 SSTORE 20DD 50 POP 20DE 50 POP 20DF 50 POP 20E0 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @20BA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @20C0 memory[0x20:0x40] = 0x00 + stack[-2] // @20DC storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_20E1: // Incoming call from 0x16EB, returns to 0x16EC // Inputs[1] { @20FA stack[-1] } 20E1 5B JUMPDEST 20E2 60 PUSH1 0x00 20E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20F9 16 AND 20FA 81 DUP2 20FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2110 16 AND 2111 14 EQ 2112 15 ISZERO 2113 15 ISZERO 2114 15 ISZERO 2115 61 PUSH2 0x211d 2118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x211d, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2119: // Incoming jump from 0x2118, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @211C memory[0x00:0x00] } 2119 60 PUSH1 0x00 211B 80 DUP1 211C FD *REVERT // Stack delta = +0 // Outputs[1] { @211C revert(memory[0x00:0x00]); } // Block terminates label_211D: // Incoming jump from 0x2118, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @2121 stack[-2] // @2122 stack[-1] // } 211D 5B JUMPDEST 211E 61 PUSH2 0x2127 2121 82 DUP3 2122 82 DUP3 2123 61 PUSH2 0x1732 2126 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @211E stack[0] = 0x2127 // @2121 stack[1] = stack[-2] // @2122 stack[2] = stack[-1] // } // Block ends with call to 0x1732, returns to 0x2127 label_2127: // Incoming return from call to 0x1732 at 0x2126 // Inputs[1] { @2128 stack[-1] } 2127 5B JUMPDEST 2128 15 ISZERO 2129 15 ISZERO 212A 61 PUSH2 0x2132 212D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2132, if !!stack[-1] label_212E: // Incoming jump from 0x212D, if not !!stack[-1] // Inputs[1] { @2131 memory[0x00:0x00] } 212E 60 PUSH1 0x00 2130 80 DUP1 2131 FD *REVERT // Stack delta = +0 // Outputs[1] { @2131 revert(memory[0x00:0x00]); } // Block terminates label_2132: // Incoming jump from 0x212D, if !!stack[-1] // Inputs[5] // { // @2135 stack[-2] // @213B stack[-1] // @2175 memory[0x00:0x40] // @217D storage[keccak256(memory[0x00:0x40])] // @218F stack[-3] // } 2132 5B JUMPDEST 2133 60 PUSH1 0x00 2135 82 DUP3 2136 60 PUSH1 0x00 2138 01 ADD 2139 60 PUSH1 0x00 213B 83 DUP4 213C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2151 16 AND 2152 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2167 16 AND 2168 81 DUP2 2169 52 MSTORE 216A 60 PUSH1 0x20 216C 01 ADD 216D 90 SWAP1 216E 81 DUP2 216F 52 MSTORE 2170 60 PUSH1 0x20 2172 01 ADD 2173 60 PUSH1 0x00 2175 20 SHA3 2176 60 PUSH1 0x00 2178 61 PUSH2 0x0100 217B 0A EXP 217C 81 DUP2 217D 54 SLOAD 217E 81 DUP2 217F 60 PUSH1 0xff 2181 02 MUL 2182 19 NOT 2183 16 AND 2184 90 SWAP1 2185 83 DUP4 2186 15 ISZERO 2187 15 ISZERO 2188 02 MUL 2189 17 OR 218A 90 SWAP1 218B 55 SSTORE 218C 50 POP 218D 50 POP 218E 50 POP 218F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2169 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @216F memory[0x20:0x40] = 0x00 + stack[-2] // @218B storage[keccak256(memory[0x00:0x40])] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_2190: // Incoming call from 0x17E6, returns to 0x17E7 // Inputs[3] // { // @2194 stack[-1] // @2195 address(stack[-1]).code.length // @219F stack[-2] // } 2190 5B JUMPDEST 2191 60 PUSH1 0x00 2193 80 DUP1 2194 82 DUP3 2195 3B EXTCODESIZE 2196 90 SWAP1 2197 50 POP 2198 60 PUSH1 0x00 219A 81 DUP2 219B 11 GT 219C 91 SWAP2 219D 50 POP 219E 50 POP 219F 91 SWAP2 21A0 90 SWAP1 21A1 50 POP 21A2 56 *JUMP // Stack delta = -1 // Outputs[1] { @219F stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_21A3: // Incoming call from 0x1A6F, returns to 0x1A70 // Incoming call from 0x2342, returns to 0x2343 // Inputs[3] // { // @21C0 stack[-1] // @21CE memory[0x00:0x40] // @21D2 storage[keccak256(memory[0x00:0x40])] // } 21A3 5B JUMPDEST 21A4 60 PUSH1 0x00 21A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21BB 16 AND 21BC 60 PUSH1 0x02 21BE 60 PUSH1 0x00 21C0 83 DUP4 21C1 81 DUP2 21C2 52 MSTORE 21C3 60 PUSH1 0x20 21C5 01 ADD 21C6 90 SWAP1 21C7 81 DUP2 21C8 52 MSTORE 21C9 60 PUSH1 0x20 21CB 01 ADD 21CC 60 PUSH1 0x00 21CE 20 SHA3 21CF 60 PUSH1 0x00 21D1 90 SWAP1 21D2 54 SLOAD 21D3 90 SWAP1 21D4 61 PUSH2 0x0100 21D7 0A EXP 21D8 90 SWAP1 21D9 04 DIV 21DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21EF 16 AND 21F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2205 16 AND 2206 14 EQ 2207 15 ISZERO 2208 15 ISZERO 2209 61 PUSH2 0x2260 220C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @21C2 memory[0x00:0x20] = stack[-1] // @21C8 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x2260, if !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_220D: // Incoming jump from 0x220C, if not !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @2213 stack[-1] // @2221 memory[0x00:0x40] // @2229 storage[keccak256(memory[0x00:0x40])] // @2262 stack[-2] // } 220D 60 PUSH1 0x00 220F 60 PUSH1 0x02 2211 60 PUSH1 0x00 2213 83 DUP4 2214 81 DUP2 2215 52 MSTORE 2216 60 PUSH1 0x20 2218 01 ADD 2219 90 SWAP1 221A 81 DUP2 221B 52 MSTORE 221C 60 PUSH1 0x20 221E 01 ADD 221F 60 PUSH1 0x00 2221 20 SHA3 2222 60 PUSH1 0x00 2224 61 PUSH2 0x0100 2227 0A EXP 2228 81 DUP2 2229 54 SLOAD 222A 81 DUP2 222B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2240 02 MUL 2241 19 NOT 2242 16 AND 2243 90 SWAP1 2244 83 DUP4 2245 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 225A 16 AND 225B 02 MUL 225C 17 OR 225D 90 SWAP1 225E 55 SSTORE 225F 50 POP 2260 5B JUMPDEST 2261 50 POP 2262 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2215 memory[0x00:0x20] = stack[-1] // @221B memory[0x20:0x40] = 0x02 // @225E storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_2263: // Incoming call from 0x1AB6, returns to 0x1AB7 // Incoming call from 0x2389, returns to 0x238A // Inputs[2] // { // @2269 stack[-1] // @226D storage[0x00 + stack[-1]] // } 2263 5B JUMPDEST 2264 61 PUSH2 0x227b 2267 60 PUSH1 0x01 2269 82 DUP3 226A 60 PUSH1 0x00 226C 01 ADD 226D 54 SLOAD 226E 61 PUSH2 0x229c 2271 90 SWAP1 2272 91 SWAP2 2273 90 SWAP1 2274 63 PUSH4 0xffffffff 2279 16 AND 227A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2264 stack[0] = 0x227b // @2272 stack[1] = storage[0x00 + stack[-1]] // @2273 stack[2] = 0x01 // } // Block ends with call to 0xffffffff & 0x229c, returns to 0x227B label_227B: // Incoming return from call to 0x229C at 0x227A // Inputs[3] // { // @227C stack[-2] // @2280 stack[-1] // @2285 stack[-3] // } 227B 5B JUMPDEST 227C 81 DUP2 227D 60 PUSH1 0x00 227F 01 ADD 2280 81 DUP2 2281 90 SWAP1 2282 55 SSTORE 2283 50 POP 2284 50 POP 2285 56 *JUMP // Stack delta = -3 // Outputs[1] { @2282 storage[0x00 + stack[-2]] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2286: // Incoming call from 0x1AFD, returns to 0x1AFE // Incoming call from 0x1F84, returns to 0x1F85 // Inputs[3] // { // @2289 stack[-1] // @2291 storage[0x00 + stack[-1]] // @229B stack[-2] // } 2286 5B JUMPDEST 2287 60 PUSH1 0x01 2289 81 DUP2 228A 60 PUSH1 0x00 228C 01 ADD 228D 60 PUSH1 0x00 228F 82 DUP3 2290 82 DUP3 2291 54 SLOAD 2292 01 ADD 2293 92 SWAP3 2294 50 POP 2295 50 POP 2296 81 DUP2 2297 90 SWAP1 2298 55 SSTORE 2299 50 POP 229A 50 POP 229B 56 *JUMP // Stack delta = -2 // Outputs[1] { @2298 storage[0x00 + stack[-1]] = storage[0x00 + stack[-1]] + 0x01 } // Block ends with unconditional jump to stack[-2] label_229C: // Incoming call from 0x227A, returns to 0x227B // Incoming call from 0x2457, returns to 0x2458 // Incoming call from 0x1C07, returns to 0x1C08 // Inputs[2] // { // @229F stack[-2] // @22A0 stack[-1] // } 229C 5B JUMPDEST 229D 60 PUSH1 0x00 229F 82 DUP3 22A0 82 DUP3 22A1 11 GT 22A2 15 ISZERO 22A3 15 ISZERO 22A4 15 ISZERO 22A5 61 PUSH2 0x22ad 22A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @229D stack[0] = 0x00 } // Block ends with conditional jump to 0x22ad, if !!!(stack[-1] > stack[-2]) label_22A9: // Incoming jump from 0x22A8, if not !!!(stack[-1] > stack[-2]) // Inputs[1] { @22AC memory[0x00:0x00] } 22A9 60 PUSH1 0x00 22AB 80 DUP1 22AC FD *REVERT // Stack delta = +0 // Outputs[1] { @22AC revert(memory[0x00:0x00]); } // Block terminates label_22AD: // Incoming jump from 0x22A8, if !!!(stack[-1] > stack[-2]) // Inputs[4] // { // @22B0 stack[-2] // @22B1 stack[-3] // @22B6 stack[-1] // @22B9 stack[-4] // } 22AD 5B JUMPDEST 22AE 60 PUSH1 0x00 22B0 82 DUP3 22B1 84 DUP5 22B2 03 SUB 22B3 90 SWAP1 22B4 50 POP 22B5 80 DUP1 22B6 91 SWAP2 22B7 50 POP 22B8 50 POP 22B9 92 SWAP3 22BA 91 SWAP2 22BB 50 POP 22BC 50 POP 22BD 56 *JUMP // Stack delta = -3 // Outputs[1] { @22B9 stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_22BE: // Incoming call from 0x1E24, returns to 0x1E25 // Inputs[2] // { // @22C2 stack[-2] // @22C3 stack[-1] // } 22BE 5B JUMPDEST 22BF 61 PUSH2 0x22c8 22C2 82 DUP3 22C3 82 DUP3 22C4 61 PUSH2 0x22f8 22C7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22BF stack[0] = 0x22c8 // @22C2 stack[1] = stack[-2] // @22C3 stack[2] = stack[-1] // } // Block ends with call to 0x22f8, returns to 0x22C8 label_22C8: // Incoming return from call to 0x22F8 at 0x22C7 // Inputs[2] // { // @22CC stack[-2] // @22CD stack[-1] // } 22C8 5B JUMPDEST 22C9 61 PUSH2 0x22d2 22CC 82 DUP3 22CD 82 DUP3 22CE 61 PUSH2 0x1bb0 22D1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22C9 stack[0] = 0x22d2 // @22CC stack[1] = stack[-2] // @22CD stack[2] = stack[-1] // } // Block ends with call to 0x1bb0, returns to 0x22D2 label_22D2: // Incoming return from call to 0x1BB0 at 0x22D1 // Inputs[2] // { // @22D9 stack[-1] // @22E7 memory[0x00:0x40] // } 22D2 5B JUMPDEST 22D3 60 PUSH1 0x00 22D5 60 PUSH1 0x06 22D7 60 PUSH1 0x00 22D9 83 DUP4 22DA 81 DUP2 22DB 52 MSTORE 22DC 60 PUSH1 0x20 22DE 01 ADD 22DF 90 SWAP1 22E0 81 DUP2 22E1 52 MSTORE 22E2 60 PUSH1 0x20 22E4 01 ADD 22E5 60 PUSH1 0x00 22E7 20 SHA3 22E8 81 DUP2 22E9 90 SWAP1 22EA 55 SSTORE 22EB 50 POP 22EC 61 PUSH2 0x22f4 22EF 81 DUP2 22F0 61 PUSH2 0x243d 22F3 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @22DB memory[0x00:0x20] = stack[-1] // @22E1 memory[0x20:0x40] = 0x06 // @22EA storage[keccak256(memory[0x00:0x40])] = 0x00 // @22EC stack[0] = 0x22f4 // @22EF stack[1] = stack[-1] // } // Block ends with call to 0x243d, returns to 0x22F4 label_22F4: // Incoming return from call to 0x243D at 0x22F3 // Inputs[1] { @22F7 stack[-3] } 22F4 5B JUMPDEST 22F5 50 POP 22F6 50 POP 22F7 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_22F8: // Incoming call from 0x22C7, returns to 0x22C8 // Inputs[2] // { // @22F9 stack[-2] // @2313 stack[-1] // } 22F8 5B JUMPDEST 22F9 81 DUP2 22FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 230F 16 AND 2310 61 PUSH2 0x2318 2313 82 DUP3 2314 61 PUSH2 0x0ff9 2317 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @230F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2310 stack[1] = 0x2318 // @2313 stack[2] = stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x2318 label_2318: // Incoming return from call to 0x0FF9 at 0x2317 // Inputs[2] // { // @232E stack[-1] // @232F stack[-2] // } 2318 5B JUMPDEST 2319 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 232E 16 AND 232F 14 EQ 2330 15 ISZERO 2331 15 ISZERO 2332 61 PUSH2 0x233a 2335 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x233a, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) label_2336: // Incoming jump from 0x2335, if not !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) // Inputs[1] { @2339 memory[0x00:0x00] } 2336 60 PUSH1 0x00 2338 80 DUP1 2339 FD *REVERT // Stack delta = +0 // Outputs[1] { @2339 revert(memory[0x00:0x00]); } // Block terminates label_233A: // Incoming jump from 0x2335, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) // Inputs[1] { @233E stack[-1] } 233A 5B JUMPDEST 233B 61 PUSH2 0x2343 233E 81 DUP2 233F 61 PUSH2 0x21a3 2342 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @233B stack[0] = 0x2343 // @233E stack[1] = stack[-1] // } // Block ends with call to 0x21a3, returns to 0x2343 label_2343: // Incoming return from call to 0x21A3 at 0x2342 // Inputs[2] // { // @234B stack[-2] // @2385 memory[0x00:0x40] // } 2343 5B JUMPDEST 2344 61 PUSH2 0x238a 2347 60 PUSH1 0x03 2349 60 PUSH1 0x00 234B 84 DUP5 234C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2361 16 AND 2362 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2377 16 AND 2378 81 DUP2 2379 52 MSTORE 237A 60 PUSH1 0x20 237C 01 ADD 237D 90 SWAP1 237E 81 DUP2 237F 52 MSTORE 2380 60 PUSH1 0x20 2382 01 ADD 2383 60 PUSH1 0x00 2385 20 SHA3 2386 61 PUSH2 0x2263 2389 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2344 stack[0] = 0x238a // @2379 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @237F memory[0x20:0x40] = 0x03 // @2385 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2263, returns to 0x238A label_238A: // Incoming return from call to 0x2263 at 0x2389 // Inputs[8] // { // @2391 stack[-1] // @239F memory[0x00:0x40] // @23A7 storage[keccak256(memory[0x00:0x40])] // @23F7 stack[-2] // @2431 memory[0x40:0x60] // @2434 memory[0x40:0x60] // @2439 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @243C stack[-3] // } 238A 5B JUMPDEST 238B 60 PUSH1 0x00 238D 60 PUSH1 0x01 238F 60 PUSH1 0x00 2391 83 DUP4 2392 81 DUP2 2393 52 MSTORE 2394 60 PUSH1 0x20 2396 01 ADD 2397 90 SWAP1 2398 81 DUP2 2399 52 MSTORE 239A 60 PUSH1 0x20 239C 01 ADD 239D 60 PUSH1 0x00 239F 20 SHA3 23A0 60 PUSH1 0x00 23A2 61 PUSH2 0x0100 23A5 0A EXP 23A6 81 DUP2 23A7 54 SLOAD 23A8 81 DUP2 23A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23BE 02 MUL 23BF 19 NOT 23C0 16 AND 23C1 90 SWAP1 23C2 83 DUP4 23C3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23D8 16 AND 23D9 02 MUL 23DA 17 OR 23DB 90 SWAP1 23DC 55 SSTORE 23DD 50 POP 23DE 80 DUP1 23DF 60 PUSH1 0x00 23E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23F6 16 AND 23F7 83 DUP4 23F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 240D 16 AND 240E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 242F 60 PUSH1 0x40 2431 51 MLOAD 2432 60 PUSH1 0x40 2434 51 MLOAD 2435 80 DUP1 2436 91 SWAP2 2437 03 SUB 2438 90 SWAP1 2439 A4 LOG4 243A 50 POP 243B 50 POP 243C 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @2393 memory[0x00:0x20] = stack[-1] // @2399 memory[0x20:0x40] = 0x01 // @23DC storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2439 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-1]]); // } // Block ends with unconditional jump to stack[-3] label_243D: // Incoming call from 0x22F3, returns to 0x22F4 // Inputs[1] { @2448 storage[0x07] } 243D 5B JUMPDEST 243E 60 PUSH1 0x00 2440 61 PUSH2 0x2458 2443 60 PUSH1 0x01 2445 60 PUSH1 0x07 2447 80 DUP1 2448 54 SLOAD 2449 90 SWAP1 244A 50 POP 244B 61 PUSH2 0x229c 244E 90 SWAP1 244F 91 SWAP2 2450 90 SWAP1 2451 63 PUSH4 0xffffffff 2456 16 AND 2457 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @243E stack[0] = 0x00 // @2440 stack[1] = 0x2458 // @244F stack[2] = storage[0x07] // @2450 stack[3] = 0x01 // } // Block ends with call to 0xffffffff & 0x229c, returns to 0x2458 label_2458: // Incoming return from call to 0x229C at 0x2457 // Inputs[6] // { // @2459 stack[-1] // @2459 stack[-2] // @2461 stack[-3] // @246F memory[0x00:0x40] // @2470 storage[keccak256(memory[0x00:0x40])] // @2479 storage[0x07] // } 2458 5B JUMPDEST 2459 90 SWAP1 245A 50 POP 245B 60 PUSH1 0x00 245D 60 PUSH1 0x08 245F 60 PUSH1 0x00 2461 84 DUP5 2462 81 DUP2 2463 52 MSTORE 2464 60 PUSH1 0x20 2466 01 ADD 2467 90 SWAP1 2468 81 DUP2 2469 52 MSTORE 246A 60 PUSH1 0x20 246C 01 ADD 246D 60 PUSH1 0x00 246F 20 SHA3 2470 54 SLOAD 2471 90 SWAP1 2472 50 POP 2473 60 PUSH1 0x00 2475 60 PUSH1 0x07 2477 83 DUP4 2478 81 DUP2 2479 54 SLOAD 247A 81 DUP2 247B 10 LT 247C 15 ISZERO 247D 15 ISZERO 247E 61 PUSH2 0x2483 2481 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @2459 stack[-2] = stack[-1] // @2463 memory[0x00:0x20] = stack[-3] // @2469 memory[0x20:0x40] = 0x08 // @2471 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2473 stack[0] = 0x00 // @2475 stack[1] = 0x07 // @2477 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x2483, if !!(stack[-1] < storage[0x07]) label_2482: // Incoming jump from 0x2481, if not !!(stack[-1] < storage[0x07]) 2482 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2482 assert(); } // Block terminates label_2483: // Incoming jump from 0x2481, if !!(stack[-1] < storage[0x07]) // Inputs[7] // { // @2484 stack[-2] // @2484 stack[-1] // @248C memory[0x00:0x20] // @248E storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @248F stack[-3] // @2494 stack[-4] // @2496 storage[0x07] // } 2483 5B JUMPDEST 2484 90 SWAP1 2485 60 PUSH1 0x00 2487 52 MSTORE 2488 60 PUSH1 0x20 248A 60 PUSH1 0x00 248C 20 SHA3 248D 01 ADD 248E 54 SLOAD 248F 90 SWAP1 2490 50 POP 2491 80 DUP1 2492 60 PUSH1 0x07 2494 83 DUP4 2495 81 DUP2 2496 54 SLOAD 2497 81 DUP2 2498 10 LT 2499 15 ISZERO 249A 15 ISZERO 249B 61 PUSH2 0x24a0 249E 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2487 memory[0x00:0x20] = stack[-2] // @248F stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2491 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2492 stack[-1] = 0x07 // @2494 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x24a0, if !!(stack[-4] < storage[0x07]) label_249F: // Incoming jump from 0x249E, if not !!(stack[-4] < storage[0x07]) 249F FE *ASSERT // Stack delta = +0 // Outputs[1] { @249F assert(); } // Block terminates label_24A0: // Incoming jump from 0x249E, if !!(stack[-4] < storage[0x07]) // Inputs[8] // { // @24A1 stack[-2] // @24A1 stack[-1] // @24A9 memory[0x00:0x20] // @24AB stack[-3] // @24AF stack[-5] // @24B4 stack[-4] // @24C2 memory[0x00:0x40] // @24CA storage[0x07] // } 24A0 5B JUMPDEST 24A1 90 SWAP1 24A2 60 PUSH1 0x00 24A4 52 MSTORE 24A5 60 PUSH1 0x20 24A7 60 PUSH1 0x00 24A9 20 SHA3 24AA 01 ADD 24AB 81 DUP2 24AC 90 SWAP1 24AD 55 SSTORE 24AE 50 POP 24AF 81 DUP2 24B0 60 PUSH1 0x08 24B2 60 PUSH1 0x00 24B4 83 DUP4 24B5 81 DUP2 24B6 52 MSTORE 24B7 60 PUSH1 0x20 24B9 01 ADD 24BA 90 SWAP1 24BB 81 DUP2 24BC 52 MSTORE 24BD 60 PUSH1 0x20 24BF 01 ADD 24C0 60 PUSH1 0x00 24C2 20 SHA3 24C3 81 DUP2 24C4 90 SWAP1 24C5 55 SSTORE 24C6 50 POP 24C7 60 PUSH1 0x07 24C9 80 DUP1 24CA 54 SLOAD 24CB 80 DUP1 24CC 91 SWAP2 24CD 90 SWAP1 24CE 60 PUSH1 0x01 24D0 90 SWAP1 24D1 03 SUB 24D2 61 PUSH2 0x24db 24D5 91 SWAP2 24D6 90 SWAP1 24D7 61 PUSH2 0x257b 24DA 56 *JUMP // Stack delta = +1 // Outputs[9] // { // @24A4 memory[0x00:0x20] = stack[-2] // @24AD storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @24B6 memory[0x00:0x20] = stack[-4] // @24BC memory[0x20:0x40] = 0x08 // @24C5 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @24CC stack[-3] = storage[0x07] // @24D5 stack[-2] = 0x24db // @24D6 stack[-1] = 0x07 // @24D6 stack[0] = storage[0x07] - 0x01 // } // Block ends with call to 0x257b, returns to 0x24DB label_24DB: // Incoming return from call to 0x257B at 0x24DA // Inputs[3] // { // @24E3 stack[-5] // @24F1 memory[0x00:0x40] // @24FA stack[-6] // } 24DB 5B JUMPDEST 24DC 50 POP 24DD 60 PUSH1 0x00 24DF 60 PUSH1 0x08 24E1 60 PUSH1 0x00 24E3 86 DUP7 24E4 81 DUP2 24E5 52 MSTORE 24E6 60 PUSH1 0x20 24E8 01 ADD 24E9 90 SWAP1 24EA 81 DUP2 24EB 52 MSTORE 24EC 60 PUSH1 0x20 24EE 01 ADD 24EF 60 PUSH1 0x00 24F1 20 SHA3 24F2 81 DUP2 24F3 90 SWAP1 24F4 55 SSTORE 24F5 50 POP 24F6 50 POP 24F7 50 POP 24F8 50 POP 24F9 50 POP 24FA 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @24E5 memory[0x00:0x20] = stack[-5] // @24EB memory[0x20:0x40] = 0x08 // @24F4 storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-6] label_24FB: // Incoming call from 0x166A, returns to 0x166B // Inputs[5] // { // @24FC stack[-3] // @24FE storage[stack[-3]] // @2518 memory[0x00:0x20] // @2523 stack[-2] // @2524 stack[-1] // } 24FB 5B JUMPDEST 24FC 82 DUP3 24FD 80 DUP1 24FE 54 SLOAD 24FF 60 PUSH1 0x01 2501 81 DUP2 2502 60 PUSH1 0x01 2504 16 AND 2505 15 ISZERO 2506 61 PUSH2 0x0100 2509 02 MUL 250A 03 SUB 250B 16 AND 250C 60 PUSH1 0x02 250E 90 SWAP1 250F 04 DIV 2510 90 SWAP1 2511 60 PUSH1 0x00 2513 52 MSTORE 2514 60 PUSH1 0x20 2516 60 PUSH1 0x00 2518 20 SHA3 2519 90 SWAP1 251A 60 PUSH1 0x1f 251C 01 ADD 251D 60 PUSH1 0x20 251F 90 SWAP1 2520 04 DIV 2521 81 DUP2 2522 01 ADD 2523 92 SWAP3 2524 82 DUP3 2525 60 PUSH1 0x1f 2527 10 LT 2528 61 PUSH2 0x253c 252B 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2513 memory[0x00:0x20] = stack[-3] // @2519 stack[0] = keccak256(memory[0x00:0x20]) // @2523 stack[1] = stack[-2] // @2523 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x253c, if 0x1f < stack[-1] label_252C: // Incoming jump from 0x252B, if not 0x1f < stack[-1] // Inputs[4] // { // @252C stack[-1] // @252D memory[stack[-1]:stack[-1] + 0x20] // @2532 stack[-3] // @2536 stack[-5] // } 252C 80 DUP1 252D 51 MLOAD 252E 60 PUSH1 0xff 2530 19 NOT 2531 16 AND 2532 83 DUP4 2533 80 DUP1 2534 01 ADD 2535 17 OR 2536 85 DUP6 2537 55 SSTORE 2538 61 PUSH2 0x256a 253B 56 *JUMP // Stack delta = +0 // Outputs[1] { @2537 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x256a label_253C: // Incoming jump from 0x252B, if 0x1f < stack[-1] // Inputs[2] // { // @253D stack[-3] // @2543 stack[-5] // } 253C 5B JUMPDEST 253D 82 DUP3 253E 80 DUP1 253F 01 ADD 2540 60 PUSH1 0x01 2542 01 ADD 2543 85 DUP6 2544 55 SSTORE 2545 82 DUP3 2546 15 ISZERO 2547 61 PUSH2 0x256a 254A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2544 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x256a, if !stack[-3] label_254B: // Incoming jump from 0x254A, if not !stack[-3] // Inputs[2] // { // @254B stack[-1] // @254B stack[-3] // } 254B 91 SWAP2 254C 82 DUP3 254D 01 ADD 254E 5B JUMPDEST 254F 82 DUP3 2550 81 DUP2 2551 11 GT 2552 15 ISZERO 2553 61 PUSH2 0x2569 2556 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @254B stack[-3] = stack[-1] // @254D stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2569, if !(stack[-1] + stack[-3] > stack[-1]) label_2557: // Incoming jump from 0x2556, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x2556, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @2557 stack[-3] // @2558 memory[stack[-3]:stack[-3] + 0x20] // @2559 stack[-2] // @255B stack[-1] // } 2557 82 DUP3 2558 51 MLOAD 2559 82 DUP3 255A 55 SSTORE 255B 91 SWAP2 255C 60 PUSH1 0x20 255E 01 ADD 255F 91 SWAP2 2560 90 SWAP1 2561 60 PUSH1 0x01 2563 01 ADD 2564 90 SWAP1 2565 61 PUSH2 0x254e 2568 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @255A storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @255F stack[-3] = 0x20 + stack[-3] // @2564 stack[-2] = 0x01 + stack[-2] // @2564 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x254e label_2569: // Incoming jump from 0x2556, if !(stack[-1] > stack[-3]) // Incoming jump from 0x2556, if !(stack[-1] + stack[-3] > stack[-1]) 2569 5B JUMPDEST // Stack delta = +0 // Block continues label_256A: // Incoming jump from 0x253B // Incoming jump from 0x2569 // Incoming jump from 0x254A, if !stack[-3] // Inputs[3] // { // @256C stack[-2] // @256C stack[-3] // @2571 stack[-4] // } 256A 5B JUMPDEST 256B 50 POP 256C 90 SWAP1 256D 50 POP 256E 61 PUSH2 0x2577 2571 91 SWAP2 2572 90 SWAP1 2573 61 PUSH2 0x25ef 2576 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @2571 stack[-4] = 0x2577 // @2572 stack[-2] = stack[-2] // @2572 stack[-3] = stack[-4] // } // Block ends with call to 0x25ef, returns to 0x2577 label_2577: // Incoming return from call to 0x25EF at 0x2576 // Inputs[2] // { // @2579 stack[-3] // @2579 stack[-2] // } 2577 5B JUMPDEST 2578 50 POP 2579 90 SWAP1 257A 56 *JUMP // Stack delta = -2 // Outputs[1] { @2579 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_257B: // Incoming call from 0x1D4C, returns to 0x1D4D // Incoming call from 0x24DA, returns to 0x24DB // Inputs[3] // { // @257C stack[-2] // @257D storage[stack[-2]] // @257E stack[-1] // } 257B 5B JUMPDEST 257C 81 DUP2 257D 54 SLOAD 257E 81 DUP2 257F 83 DUP4 2580 55 SSTORE 2581 81 DUP2 2582 81 DUP2 2583 11 GT 2584 15 ISZERO 2585 61 PUSH2 0x25a2 2588 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @257D stack[0] = storage[stack[-2]] // @2580 storage[stack[-2]] = stack[-1] // } // Block ends with conditional jump to 0x25a2, if !(storage[stack[-2]] > stack[-1]) label_2589: // Incoming jump from 0x2588, if not !(storage[stack[-2]] > stack[-1]) // Inputs[4] // { // @2589 stack[-2] // @258A stack[-3] // @2592 memory[0x00:0x20] // @2593 stack[-1] // } 2589 81 DUP2 258A 83 DUP4 258B 60 PUSH1 0x00 258D 52 MSTORE 258E 60 PUSH1 0x20 2590 60 PUSH1 0x00 2592 20 SHA3 2593 91 SWAP2 2594 82 DUP3 2595 01 ADD 2596 91 SWAP2 2597 01 ADD 2598 61 PUSH2 0x25a1 259B 91 SWAP2 259C 90 SWAP1 259D 61 PUSH2 0x25ef 25A0 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @258D memory[0x00:0x20] = stack[-3] // @259B stack[-1] = 0x25a1 // @259C stack[1] = keccak256(memory[0x00:0x20]) + stack[-2] // @259C stack[0] = keccak256(memory[0x00:0x20]) + stack[-1] // } // Block ends with call to 0x25ef, returns to 0x25A1 label_25A1: // Incoming return from call to 0x25EF at 0x25A0 25A1 5B JUMPDEST // Stack delta = +0 // Block continues label_25A2: // Incoming jump from 0x2588, if !(storage[stack[-2]] > stack[-1]) // Incoming jump from 0x25A1 // Inputs[1] { @25A6 stack[-4] } 25A2 5B JUMPDEST 25A3 50 POP 25A4 50 POP 25A5 50 POP 25A6 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_25A7: // Incoming call from 0x1E74, returns to 0x1E75 // Inputs[2] // { // @25A9 stack[-2] // @25AA storage[stack[-2]] // } 25A7 5B JUMPDEST 25A8 50 POP 25A9 80 DUP1 25AA 54 SLOAD 25AB 60 PUSH1 0x01 25AD 81 DUP2 25AE 60 PUSH1 0x01 25B0 16 AND 25B1 15 ISZERO 25B2 61 PUSH2 0x0100 25B5 02 MUL 25B6 03 SUB 25B7 16 AND 25B8 60 PUSH1 0x02 25BA 90 SWAP1 25BB 04 DIV 25BC 60 PUSH1 0x00 25BE 82 DUP3 25BF 55 SSTORE 25C0 80 DUP1 25C1 60 PUSH1 0x1f 25C3 10 LT 25C4 61 PUSH2 0x25cd 25C7 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @25BB stack[-1] = (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 // @25BF storage[stack[-2]] = 0x00 // } // Block ends with conditional jump to 0x25cd, if 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 label_25C8: // Incoming jump from 0x25C7, if not 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 25C8 50 POP 25C9 61 PUSH2 0x25ec 25CC 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x25ec label_25CD: // Incoming jump from 0x25C7, if 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 // Inputs[3] // { // @25D0 stack[-1] // @25D5 stack[-2] // @25DD memory[0x00:0x20] // } 25CD 5B JUMPDEST 25CE 60 PUSH1 0x1f 25D0 01 ADD 25D1 60 PUSH1 0x20 25D3 90 SWAP1 25D4 04 DIV 25D5 90 SWAP1 25D6 60 PUSH1 0x00 25D8 52 MSTORE 25D9 60 PUSH1 0x20 25DB 60 PUSH1 0x00 25DD 20 SHA3 25DE 90 SWAP1 25DF 81 DUP2 25E0 01 ADD 25E1 90 SWAP1 25E2 61 PUSH2 0x25eb 25E5 91 SWAP2 25E6 90 SWAP1 25E7 61 PUSH2 0x25ef 25EA 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @25D8 memory[0x00:0x20] = stack[-2] // @25E5 stack[-2] = 0x25eb // @25E6 stack[-1] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // @25E6 stack[0] = keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x25ef, returns to 0x25EB label_25EB: // Incoming return from call to 0x25EF at 0x25EA 25EB 5B JUMPDEST // Stack delta = +0 // Block continues label_25EC: // Incoming jump from 0x25CC // Incoming jump from 0x25EB // Inputs[1] { @25EE stack[-2] } 25EC 5B JUMPDEST 25ED 50 POP 25EE 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_25EF: // Incoming call from 0x25A0, returns to 0x25A1 // Incoming call from 0x2576, returns to 0x2577 // Incoming call from 0x25EA, returns to 0x25EB // Inputs[2] // { // @25F3 stack[-2] // @25F4 stack[-1] // } 25EF 5B JUMPDEST 25F0 61 PUSH2 0x2611 25F3 91 SWAP2 25F4 90 SWAP1 25F5 5B JUMPDEST 25F6 80 DUP1 25F7 82 DUP3 25F8 11 GT 25F9 15 ISZERO 25FA 61 PUSH2 0x260d 25FD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @25F3 stack[-2] = 0x2611 // @25F4 stack[-1] = stack[-2] // @25F4 stack[0] = stack[-1] // } // Block ends with conditional call to 0x260d, returns to 0x2611, if !(stack[-2] > stack[-1]) label_25FE: // Incoming jump from 0x25FD, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x25FD, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2600 stack[-1] } 25FE 60 PUSH1 0x00 2600 81 DUP2 2601 60 PUSH1 0x00 2603 90 SWAP1 2604 55 SSTORE 2605 50 POP 2606 60 PUSH1 0x01 2608 01 ADD 2609 61 PUSH2 0x25f5 260C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2604 storage[stack[-1]] = 0x00 // @2608 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x25f5 label_260D: // Incoming jump from 0x25FD, if !(stack[-2] > stack[-1]) // Incoming call from 0x25FD, returns to 0x2611, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @260F stack[-3] // @260F stack[-2] // } 260D 5B JUMPDEST 260E 50 POP 260F 90 SWAP1 2610 56 *JUMP // Stack delta = -2 // Outputs[1] { @260F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2611: // Incoming return from call to 0x260D at 0x25FD // Inputs[2] // { // @2612 stack[-1] // @2612 stack[-2] // } 2611 5B JUMPDEST 2612 90 SWAP1 2613 56 *JUMP // Stack delta = -1 // Outputs[1] { @2612 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] 2614 FE *ASSERT 2615 41 COINBASE 2616 63 PUSH4 0x636f6e75 261B 6E PUSH15 0x7420616c7265616479206861732061 262B 20 SHA3 262C 74 PUSH21 0x6f6b656e20666f72207468617420757269a165627a 2642 7A PUSH27 0x72305820f89c4205b3f58201878648e95046b1bbd81af35847a4dc 265E 9C SWAP13 265F B7 B7 2660 44 DIFFICULTY 2661 11 GT 2662 77 PUSH24 0x080eecfc0029