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 0x01c6 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01c6, 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 0x709e147a 0043 11 GT 0044 61 PUSH2 0x0116 0047 57 *JUMPI // Stack delta = +1 // Outputs[1] { @003C stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0116, if 0x709e147a > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0048: // Incoming jump from 0x0047, if not 0x709e147a > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0048 stack[-1] } 0048 80 DUP1 0049 63 PUSH4 0x95d89b41 004E 11 GT 004F 61 PUSH2 0x00b4 0052 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b4, if 0x95d89b41 > stack[-1] label_0053: // Incoming jump from 0x0052, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0053 stack[-1] } 0053 80 DUP1 0054 63 PUSH4 0xa9059cbb 0059 11 GT 005A 61 PUSH2 0x008e 005D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008e, if 0xa9059cbb > stack[-1] label_005E: // Incoming jump from 0x005D, if not 0xa9059cbb > stack[-1] // Inputs[1] { @005E stack[-1] } 005E 80 DUP1 005F 63 PUSH4 0xa9059cbb 0064 14 EQ 0065 61 PUSH2 0x099f 0068 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x099f, if 0xa9059cbb == stack[-1] label_0069: // Incoming jump from 0x0068, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0069 stack[-1] } 0069 80 DUP1 006A 63 PUSH4 0xc2876aa3 006F 14 EQ 0070 61 PUSH2 0x0a05 0073 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a05, if 0xc2876aa3 == stack[-1] label_0074: // Incoming jump from 0x0073, if not 0xc2876aa3 == stack[-1] // Inputs[1] { @0074 stack[-1] } 0074 80 DUP1 0075 63 PUSH4 0xce62cd4a 007A 14 EQ 007B 61 PUSH2 0x0a23 007E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a23, if 0xce62cd4a == stack[-1] label_007F: // Incoming jump from 0x007E, if not 0xce62cd4a == stack[-1] // Inputs[1] { @007F stack[-1] } 007F 80 DUP1 0080 63 PUSH4 0xdd62ed3e 0085 14 EQ 0086 61 PUSH2 0x0a7f 0089 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a7f, if 0xdd62ed3e == stack[-1] label_008A: // Incoming jump from 0x0089, if not 0xdd62ed3e == stack[-1] 008A 61 PUSH2 0x01c6 008D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c6 label_008E: // Incoming jump from 0x005D, if 0xa9059cbb > stack[-1] // Inputs[1] { @008F stack[-1] } 008E 5B JUMPDEST 008F 80 DUP1 0090 63 PUSH4 0x95d89b41 0095 14 EQ 0096 61 PUSH2 0x0898 0099 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0898, if 0x95d89b41 == stack[-1] label_009A: // Incoming jump from 0x0099, if not 0x95d89b41 == stack[-1] // Inputs[1] { @009A stack[-1] } 009A 80 DUP1 009B 63 PUSH4 0xa457c2d7 00A0 14 EQ 00A1 61 PUSH2 0x091b 00A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x091b, if 0xa457c2d7 == stack[-1] label_00A5: // Incoming jump from 0x00A4, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @00A5 stack[-1] } 00A5 80 DUP1 00A6 63 PUSH4 0xa7dfc363 00AB 14 EQ 00AC 61 PUSH2 0x0981 00AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0981, if 0xa7dfc363 == stack[-1] label_00B0: // Incoming jump from 0x00AF, if not 0xa7dfc363 == stack[-1] 00B0 61 PUSH2 0x01c6 00B3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c6 label_00B4: // Incoming jump from 0x0052, if 0x95d89b41 > stack[-1] // Inputs[1] { @00B5 stack[-1] } 00B4 5B JUMPDEST 00B5 80 DUP1 00B6 63 PUSH4 0x8e7543aa 00BB 11 GT 00BC 61 PUSH2 0x00f0 00BF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f0, if 0x8e7543aa > stack[-1] label_00C0: // Incoming jump from 0x00BF, if not 0x8e7543aa > stack[-1] // Inputs[1] { @00C0 stack[-1] } 00C0 80 DUP1 00C1 63 PUSH4 0x8e7543aa 00C6 14 EQ 00C7 61 PUSH2 0x0753 00CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0753, if 0x8e7543aa == stack[-1] label_00CB: // Incoming jump from 0x00CA, if not 0x8e7543aa == stack[-1] // Inputs[1] { @00CB stack[-1] } 00CB 80 DUP1 00CC 63 PUSH4 0x919884bf 00D1 14 EQ 00D2 61 PUSH2 0x07b2 00D5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07b2, if 0x919884bf == stack[-1] label_00D6: // Incoming jump from 0x00D5, if not 0x919884bf == stack[-1] // Inputs[1] { @00D6 stack[-1] } 00D6 80 DUP1 00D7 63 PUSH4 0x93c32e06 00DC 14 EQ 00DD 61 PUSH2 0x080a 00E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x080a, if 0x93c32e06 == stack[-1] label_00E1: // Incoming jump from 0x00E0, if not 0x93c32e06 == stack[-1] // Inputs[1] { @00E1 stack[-1] } 00E1 80 DUP1 00E2 63 PUSH4 0x946bcc30 00E7 14 EQ 00E8 61 PUSH2 0x084e 00EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x084e, if 0x946bcc30 == stack[-1] label_00EC: // Incoming jump from 0x00EB, if not 0x946bcc30 == stack[-1] 00EC 61 PUSH2 0x01c6 00EF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c6 label_00F0: // Incoming jump from 0x00BF, if 0x8e7543aa > stack[-1] // Inputs[1] { @00F1 stack[-1] } 00F0 5B JUMPDEST 00F1 80 DUP1 00F2 63 PUSH4 0x709e147a 00F7 14 EQ 00F8 61 PUSH2 0x0636 00FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0636, if 0x709e147a == stack[-1] label_00FC: // Incoming jump from 0x00FB, if not 0x709e147a == stack[-1] // Inputs[1] { @00FC stack[-1] } 00FC 80 DUP1 00FD 63 PUSH4 0x70a08231 0102 14 EQ 0103 61 PUSH2 0x069c 0106 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x069c, if 0x70a08231 == stack[-1] label_0107: // Incoming jump from 0x0106, if not 0x70a08231 == stack[-1] // Inputs[1] { @0107 stack[-1] } 0107 80 DUP1 0108 63 PUSH4 0x83c46f86 010D 14 EQ 010E 61 PUSH2 0x06f4 0111 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f4, if 0x83c46f86 == stack[-1] label_0112: // Incoming jump from 0x0111, if not 0x83c46f86 == stack[-1] 0112 61 PUSH2 0x01c6 0115 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c6 label_0116: // Incoming jump from 0x0047, if 0x709e147a > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0117 stack[-1] } 0116 5B JUMPDEST 0117 80 DUP1 0118 63 PUSH4 0x30e1e4e5 011D 11 GT 011E 61 PUSH2 0x0183 0121 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0183, if 0x30e1e4e5 > stack[-1] label_0122: // Incoming jump from 0x0121, if not 0x30e1e4e5 > stack[-1] // Inputs[1] { @0122 stack[-1] } 0122 80 DUP1 0123 63 PUSH4 0x45c8b1a6 0128 11 GT 0129 61 PUSH2 0x015d 012C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015d, if 0x45c8b1a6 > stack[-1] label_012D: // Incoming jump from 0x012C, if not 0x45c8b1a6 > stack[-1] // Inputs[1] { @012D stack[-1] } 012D 80 DUP1 012E 63 PUSH4 0x45c8b1a6 0133 14 EQ 0134 61 PUSH2 0x048e 0137 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048e, if 0x45c8b1a6 == stack[-1] label_0138: // Incoming jump from 0x0137, if not 0x45c8b1a6 == stack[-1] // Inputs[1] { @0138 stack[-1] } 0138 80 DUP1 0139 63 PUSH4 0x59d0e2cf 013E 14 EQ 013F 61 PUSH2 0x04ea 0142 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ea, if 0x59d0e2cf == stack[-1] label_0143: // Incoming jump from 0x0142, if not 0x59d0e2cf == stack[-1] // Inputs[1] { @0143 stack[-1] } 0143 80 DUP1 0144 63 PUSH4 0x5ddb82d5 0149 14 EQ 014A 61 PUSH2 0x0586 014D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0586, if 0x5ddb82d5 == stack[-1] label_014E: // Incoming jump from 0x014D, if not 0x5ddb82d5 == stack[-1] // Inputs[1] { @014E stack[-1] } 014E 80 DUP1 014F 63 PUSH4 0x6ebcf607 0154 14 EQ 0155 61 PUSH2 0x05de 0158 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05de, if 0x6ebcf607 == stack[-1] label_0159: // Incoming jump from 0x0158, if not 0x6ebcf607 == stack[-1] 0159 61 PUSH2 0x01c6 015C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c6 label_015D: // Incoming jump from 0x012C, if 0x45c8b1a6 > stack[-1] // Inputs[1] { @015E stack[-1] } 015D 5B JUMPDEST 015E 80 DUP1 015F 63 PUSH4 0x30e1e4e5 0164 14 EQ 0165 61 PUSH2 0x0394 0168 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0394, if 0x30e1e4e5 == stack[-1] label_0169: // Incoming jump from 0x0168, if not 0x30e1e4e5 == stack[-1] // Inputs[1] { @0169 stack[-1] } 0169 80 DUP1 016A 63 PUSH4 0x313ce567 016F 14 EQ 0170 61 PUSH2 0x0404 0173 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0404, if 0x313ce567 == stack[-1] label_0174: // Incoming jump from 0x0173, if not 0x313ce567 == stack[-1] // Inputs[1] { @0174 stack[-1] } 0174 80 DUP1 0175 63 PUSH4 0x39509351 017A 14 EQ 017B 61 PUSH2 0x0428 017E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0428, if 0x39509351 == stack[-1] label_017F: // Incoming jump from 0x017E, if not 0x39509351 == stack[-1] 017F 61 PUSH2 0x01c6 0182 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c6 label_0183: // Incoming jump from 0x0121, if 0x30e1e4e5 > stack[-1] // Inputs[1] { @0184 stack[-1] } 0183 5B JUMPDEST 0184 80 DUP1 0185 63 PUSH4 0x040e55f5 018A 14 EQ 018B 61 PUSH2 0x01cb 018E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cb, if 0x040e55f5 == stack[-1] label_018F: // Incoming jump from 0x018E, if not 0x040e55f5 == stack[-1] // Inputs[1] { @018F stack[-1] } 018F 80 DUP1 0190 63 PUSH4 0x06fdde03 0195 14 EQ 0196 61 PUSH2 0x01e9 0199 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e9, if 0x06fdde03 == stack[-1] label_019A: // Incoming jump from 0x0199, if not 0x06fdde03 == stack[-1] // Inputs[1] { @019A stack[-1] } 019A 80 DUP1 019B 63 PUSH4 0x095ea7b3 01A0 14 EQ 01A1 61 PUSH2 0x026c 01A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026c, if 0x095ea7b3 == stack[-1] label_01A5: // Incoming jump from 0x01A4, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01A5 stack[-1] } 01A5 80 DUP1 01A6 63 PUSH4 0x0f950ea6 01AB 14 EQ 01AC 61 PUSH2 0x02d2 01AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d2, if 0x0f950ea6 == stack[-1] label_01B0: // Incoming jump from 0x01AF, if not 0x0f950ea6 == stack[-1] // Inputs[1] { @01B0 stack[-1] } 01B0 80 DUP1 01B1 63 PUSH4 0x18160ddd 01B6 14 EQ 01B7 61 PUSH2 0x02f0 01BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f0, if 0x18160ddd == stack[-1] label_01BB: // Incoming jump from 0x01BA, if not 0x18160ddd == stack[-1] // Inputs[1] { @01BB stack[-1] } 01BB 80 DUP1 01BC 63 PUSH4 0x23b872dd 01C1 14 EQ 01C2 61 PUSH2 0x030e 01C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030e, if 0x23b872dd == stack[-1] label_01C6: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x015C // Incoming jump from 0x01C5, if not 0x23b872dd == stack[-1] // Incoming jump from 0x00B3 // Incoming jump from 0x0182 // Incoming jump from 0x0115 // Incoming jump from 0x00EF // Incoming jump from 0x008D // Inputs[1] { @01CA memory[0x00:0x00] } 01C6 5B JUMPDEST 01C7 60 PUSH1 0x00 01C9 80 DUP1 01CA FD *REVERT // Stack delta = +0 // Outputs[1] { @01CA revert(memory[0x00:0x00]); } // Block terminates label_01CB: // Incoming jump from 0x018E, if 0x040e55f5 == stack[-1] 01CB 5B JUMPDEST 01CC 61 PUSH2 0x01d3 01CF 61 PUSH2 0x0af7 01D2 56 *JUMP // Stack delta = +1 // Outputs[1] { @01CC stack[0] = 0x01d3 } // Block ends with call to 0x0af7, returns to 0x01D3 label_01D3: // Incoming return from call to 0x0AF7 at 0x01D2 // Inputs[4] // { // @01D6 memory[0x40:0x60] // @01D8 stack[-1] // @01E3 memory[0x40:0x60] // @01E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01D3 5B JUMPDEST 01D4 60 PUSH1 0x40 01D6 51 MLOAD 01D7 80 DUP1 01D8 82 DUP3 01D9 81 DUP2 01DA 52 MSTORE 01DB 60 PUSH1 0x20 01DD 01 ADD 01DE 91 SWAP2 01DF 50 POP 01E0 50 POP 01E1 60 PUSH1 0x40 01E3 51 MLOAD 01E4 80 DUP1 01E5 91 SWAP2 01E6 03 SUB 01E7 90 SWAP1 01E8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01E8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01E9: // Incoming jump from 0x0199, if 0x06fdde03 == stack[-1] 01E9 5B JUMPDEST 01EA 61 PUSH2 0x01f1 01ED 61 PUSH2 0x0b01 01F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @01EA stack[0] = 0x01f1 } // Block ends with call to 0x0b01, returns to 0x01F1 label_01F1: // Incoming return from call to 0x0B01 at 0x01F0 // Inputs[4] // { // @01F4 memory[0x40:0x60] // @01FF stack[-1] // @0202 memory[stack[-1]:stack[-1] + 0x20] // @020B memory[stack[-1]:stack[-1] + 0x20] // } 01F1 5B JUMPDEST 01F2 60 PUSH1 0x40 01F4 51 MLOAD 01F5 80 DUP1 01F6 80 DUP1 01F7 60 PUSH1 0x20 01F9 01 ADD 01FA 82 DUP3 01FB 81 DUP2 01FC 03 SUB 01FD 82 DUP3 01FE 52 MSTORE 01FF 83 DUP4 0200 81 DUP2 0201 81 DUP2 0202 51 MLOAD 0203 81 DUP2 0204 52 MSTORE 0205 60 PUSH1 0x20 0207 01 ADD 0208 91 SWAP2 0209 50 POP 020A 80 DUP1 020B 51 MLOAD 020C 90 SWAP1 020D 60 PUSH1 0x20 020F 01 ADD 0210 90 SWAP1 0211 80 DUP1 0212 83 DUP4 0213 83 DUP4 0214 60 PUSH1 0x00 0216 5B JUMPDEST 0217 83 DUP4 0218 81 DUP2 0219 10 LT 021A 15 ISZERO 021B 61 PUSH2 0x0231 021E 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01F4 stack[0] = memory[0x40:0x60] // @01F5 stack[1] = memory[0x40:0x60] // @01FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0204 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0208 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0210 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0210 stack[3] = 0x20 + stack[-1] // @0211 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0212 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0213 stack[7] = 0x20 + stack[-1] // @0214 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0231, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_021F: // Incoming jump from 0x021E, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x021E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @021F stack[-1] // @0220 stack[-2] // @0222 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0224 stack[-3] // } 021F 80 DUP1 0220 82 DUP3 0221 01 ADD 0222 51 MLOAD 0223 81 DUP2 0224 84 DUP5 0225 01 ADD 0226 52 MSTORE 0227 60 PUSH1 0x20 0229 81 DUP2 022A 01 ADD 022B 90 SWAP1 022C 50 POP 022D 61 PUSH2 0x0216 0230 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0226 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @022B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0216 label_0231: // Incoming jump from 0x021E, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x021E, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0236 stack[-5] // @0236 stack[-6] // @0238 stack[-7] // } 0231 5B JUMPDEST 0232 50 POP 0233 50 POP 0234 50 POP 0235 50 POP 0236 90 SWAP1 0237 50 POP 0238 90 SWAP1 0239 81 DUP2 023A 01 ADD 023B 90 SWAP1 023C 60 PUSH1 0x1f 023E 16 AND 023F 80 DUP1 0240 15 ISZERO 0241 61 PUSH2 0x025e 0244 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @023B stack[-7] = stack[-5] + stack[-7] // @023E stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x025e, if !(0x1f & stack[-5]) label_0245: // Incoming jump from 0x0244, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0245 stack[-1] // @0246 stack[-2] // @0249 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0260 stack[-5] // @0266 memory[0x40:0x60] // @026B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0245 80 DUP1 0246 82 DUP3 0247 03 SUB 0248 80 DUP1 0249 51 MLOAD 024A 60 PUSH1 0x01 024C 83 DUP4 024D 60 PUSH1 0x20 024F 03 SUB 0250 61 PUSH2 0x0100 0253 0A EXP 0254 03 SUB 0255 19 NOT 0256 16 AND 0257 81 DUP2 0258 52 MSTORE 0259 60 PUSH1 0x20 025B 01 ADD 025C 91 SWAP2 025D 50 POP 025E 5B JUMPDEST 025F 50 POP 0260 92 SWAP3 0261 50 POP 0262 50 POP 0263 50 POP 0264 60 PUSH1 0x40 0266 51 MLOAD 0267 80 DUP1 0268 91 SWAP2 0269 03 SUB 026A 90 SWAP1 026B F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0258 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] // @026B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_026C: // Incoming jump from 0x01A4, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0273 msg.data.length } 026C 5B JUMPDEST 026D 61 PUSH2 0x02b8 0270 60 PUSH1 0x04 0272 80 DUP1 0273 36 CALLDATASIZE 0274 03 SUB 0275 60 PUSH1 0x40 0277 81 DUP2 0278 10 LT 0279 15 ISZERO 027A 61 PUSH2 0x0282 027D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @026D stack[0] = 0x02b8 // @0270 stack[1] = 0x04 // @0274 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0282, returns to 0x02B8, if !(msg.data.length - 0x04 < 0x40) label_027E: // Incoming jump from 0x027D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0281 memory[0x00:0x00] } 027E 60 PUSH1 0x00 0280 80 DUP1 0281 FD *REVERT // Stack delta = +0 // Outputs[1] { @0281 revert(memory[0x00:0x00]); } // Block terminates label_0282: // Incoming call from 0x027D, returns to 0x02B8, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0283 stack[-2] // @0284 stack[-1] // @0288 msg.data[stack[-2]:stack[-2] + 0x20] // @02A8 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0282 5B JUMPDEST 0283 81 DUP2 0284 01 ADD 0285 90 SWAP1 0286 80 DUP1 0287 80 DUP1 0288 35 CALLDATALOAD 0289 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 029E 16 AND 029F 90 SWAP1 02A0 60 PUSH1 0x20 02A2 01 ADD 02A3 90 SWAP1 02A4 92 SWAP3 02A5 91 SWAP2 02A6 90 SWAP1 02A7 80 DUP1 02A8 35 CALLDATALOAD 02A9 90 SWAP1 02AA 60 PUSH1 0x20 02AC 01 ADD 02AD 90 SWAP1 02AE 92 SWAP3 02AF 91 SWAP2 02B0 90 SWAP1 02B1 50 POP 02B2 50 POP 02B3 50 POP 02B4 61 PUSH2 0x0ba3 02B7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02A4 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @02AE stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0ba3 label_02B8: // Incoming return from call to 0x0282 at 0x027D // Inputs[4] // { // @02BB memory[0x40:0x60] // @02BD stack[-1] // @02CC memory[0x40:0x60] // @02D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02B8 5B JUMPDEST 02B9 60 PUSH1 0x40 02BB 51 MLOAD 02BC 80 DUP1 02BD 82 DUP3 02BE 15 ISZERO 02BF 15 ISZERO 02C0 15 ISZERO 02C1 15 ISZERO 02C2 81 DUP2 02C3 52 MSTORE 02C4 60 PUSH1 0x20 02C6 01 ADD 02C7 91 SWAP2 02C8 50 POP 02C9 50 POP 02CA 60 PUSH1 0x40 02CC 51 MLOAD 02CD 80 DUP1 02CE 91 SWAP2 02CF 03 SUB 02D0 90 SWAP1 02D1 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @02D1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02D2: // Incoming jump from 0x01AF, if 0x0f950ea6 == stack[-1] 02D2 5B JUMPDEST 02D3 61 PUSH2 0x02da 02D6 61 PUSH2 0x0be2 02D9 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D3 stack[0] = 0x02da } // Block ends with call to 0x0be2, returns to 0x02DA label_02DA: // Incoming return from call to 0x0BE2 at 0x02D9 // Inputs[4] // { // @02DD memory[0x40:0x60] // @02DF stack[-1] // @02EA memory[0x40:0x60] // @02EF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02DA 5B JUMPDEST 02DB 60 PUSH1 0x40 02DD 51 MLOAD 02DE 80 DUP1 02DF 82 DUP3 02E0 81 DUP2 02E1 52 MSTORE 02E2 60 PUSH1 0x20 02E4 01 ADD 02E5 91 SWAP2 02E6 50 POP 02E7 50 POP 02E8 60 PUSH1 0x40 02EA 51 MLOAD 02EB 80 DUP1 02EC 91 SWAP2 02ED 03 SUB 02EE 90 SWAP1 02EF F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02EF return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02F0: // Incoming jump from 0x01BA, if 0x18160ddd == stack[-1] 02F0 5B JUMPDEST 02F1 61 PUSH2 0x02f8 02F4 61 PUSH2 0x0c4b 02F7 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F1 stack[0] = 0x02f8 } // Block ends with call to 0x0c4b, returns to 0x02F8 label_02F8: // Incoming return from call to 0x0C4B at 0x02F7 // Inputs[4] // { // @02FB memory[0x40:0x60] // @02FD stack[-1] // @0308 memory[0x40:0x60] // @030D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02F8 5B JUMPDEST 02F9 60 PUSH1 0x40 02FB 51 MLOAD 02FC 80 DUP1 02FD 82 DUP3 02FE 81 DUP2 02FF 52 MSTORE 0300 60 PUSH1 0x20 0302 01 ADD 0303 91 SWAP2 0304 50 POP 0305 50 POP 0306 60 PUSH1 0x40 0308 51 MLOAD 0309 80 DUP1 030A 91 SWAP2 030B 03 SUB 030C 90 SWAP1 030D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02FF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @030D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_030E: // Incoming jump from 0x01C5, if 0x23b872dd == stack[-1] // Inputs[1] { @0315 msg.data.length } 030E 5B JUMPDEST 030F 61 PUSH2 0x037a 0312 60 PUSH1 0x04 0314 80 DUP1 0315 36 CALLDATASIZE 0316 03 SUB 0317 60 PUSH1 0x60 0319 81 DUP2 031A 10 LT 031B 15 ISZERO 031C 61 PUSH2 0x0324 031F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @030F stack[0] = 0x037a // @0312 stack[1] = 0x04 // @0316 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0324, returns to 0x037A, if !(msg.data.length - 0x04 < 0x60) label_0320: // Incoming jump from 0x031F, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0323 memory[0x00:0x00] } 0320 60 PUSH1 0x00 0322 80 DUP1 0323 FD *REVERT // Stack delta = +0 // Outputs[1] { @0323 revert(memory[0x00:0x00]); } // Block terminates label_0324: // Incoming call from 0x031F, returns to 0x037A, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0325 stack[-2] // @0326 stack[-1] // @032A msg.data[stack[-2]:stack[-2] + 0x20] // @034A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @036A msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0324 5B JUMPDEST 0325 81 DUP2 0326 01 ADD 0327 90 SWAP1 0328 80 DUP1 0329 80 DUP1 032A 35 CALLDATALOAD 032B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0340 16 AND 0341 90 SWAP1 0342 60 PUSH1 0x20 0344 01 ADD 0345 90 SWAP1 0346 92 SWAP3 0347 91 SWAP2 0348 90 SWAP1 0349 80 DUP1 034A 35 CALLDATALOAD 034B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0360 16 AND 0361 90 SWAP1 0362 60 PUSH1 0x20 0364 01 ADD 0365 90 SWAP1 0366 92 SWAP3 0367 91 SWAP2 0368 90 SWAP1 0369 80 DUP1 036A 35 CALLDATALOAD 036B 90 SWAP1 036C 60 PUSH1 0x20 036E 01 ADD 036F 90 SWAP1 0370 92 SWAP3 0371 91 SWAP2 0372 90 SWAP1 0373 50 POP 0374 50 POP 0375 50 POP 0376 61 PUSH2 0x0c55 0379 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0346 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0366 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0370 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0c55 label_037A: // Incoming return from call to 0x0324 at 0x031F // Inputs[4] // { // @037D memory[0x40:0x60] // @037F stack[-1] // @038E memory[0x40:0x60] // @0393 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 037A 5B JUMPDEST 037B 60 PUSH1 0x40 037D 51 MLOAD 037E 80 DUP1 037F 82 DUP3 0380 15 ISZERO 0381 15 ISZERO 0382 15 ISZERO 0383 15 ISZERO 0384 81 DUP2 0385 52 MSTORE 0386 60 PUSH1 0x20 0388 01 ADD 0389 91 SWAP2 038A 50 POP 038B 50 POP 038C 60 PUSH1 0x40 038E 51 MLOAD 038F 80 DUP1 0390 91 SWAP2 0391 03 SUB 0392 90 SWAP1 0393 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0385 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0393 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0394: // Incoming jump from 0x0168, if 0x30e1e4e5 == stack[-1] // Inputs[1] { @039B msg.data.length } 0394 5B JUMPDEST 0395 61 PUSH2 0x03ea 0398 60 PUSH1 0x04 039A 80 DUP1 039B 36 CALLDATASIZE 039C 03 SUB 039D 60 PUSH1 0x60 039F 81 DUP2 03A0 10 LT 03A1 15 ISZERO 03A2 61 PUSH2 0x03aa 03A5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0395 stack[0] = 0x03ea // @0398 stack[1] = 0x04 // @039C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03aa, returns to 0x03EA, if !(msg.data.length - 0x04 < 0x60) label_03A6: // Incoming jump from 0x03A5, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @03A9 memory[0x00:0x00] } 03A6 60 PUSH1 0x00 03A8 80 DUP1 03A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A9 revert(memory[0x00:0x00]); } // Block terminates label_03AA: // Incoming call from 0x03A5, returns to 0x03EA, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @03AB stack[-2] // @03AC stack[-1] // @03B0 msg.data[stack[-2]:stack[-2] + 0x20] // @03D0 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @03DA msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 03AA 5B JUMPDEST 03AB 81 DUP2 03AC 01 ADD 03AD 90 SWAP1 03AE 80 DUP1 03AF 80 DUP1 03B0 35 CALLDATALOAD 03B1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03C6 16 AND 03C7 90 SWAP1 03C8 60 PUSH1 0x20 03CA 01 ADD 03CB 90 SWAP1 03CC 92 SWAP3 03CD 91 SWAP2 03CE 90 SWAP1 03CF 80 DUP1 03D0 35 CALLDATALOAD 03D1 90 SWAP1 03D2 60 PUSH1 0x20 03D4 01 ADD 03D5 90 SWAP1 03D6 92 SWAP3 03D7 91 SWAP2 03D8 90 SWAP1 03D9 80 DUP1 03DA 35 CALLDATALOAD 03DB 90 SWAP1 03DC 60 PUSH1 0x20 03DE 01 ADD 03DF 90 SWAP1 03E0 92 SWAP3 03E1 91 SWAP2 03E2 90 SWAP1 03E3 50 POP 03E4 50 POP 03E5 50 POP 03E6 61 PUSH2 0x0d06 03E9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03CC stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @03D6 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @03E0 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0d06 label_03EA: // Incoming return from call to 0x03AA at 0x03A5 // Inputs[4] // { // @03ED memory[0x40:0x60] // @03EF stack[-1] // @03FE memory[0x40:0x60] // @0403 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03EA 5B JUMPDEST 03EB 60 PUSH1 0x40 03ED 51 MLOAD 03EE 80 DUP1 03EF 82 DUP3 03F0 15 ISZERO 03F1 15 ISZERO 03F2 15 ISZERO 03F3 15 ISZERO 03F4 81 DUP2 03F5 52 MSTORE 03F6 60 PUSH1 0x20 03F8 01 ADD 03F9 91 SWAP2 03FA 50 POP 03FB 50 POP 03FC 60 PUSH1 0x40 03FE 51 MLOAD 03FF 80 DUP1 0400 91 SWAP2 0401 03 SUB 0402 90 SWAP1 0403 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0403 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0404: // Incoming jump from 0x0173, if 0x313ce567 == stack[-1] 0404 5B JUMPDEST 0405 61 PUSH2 0x040c 0408 61 PUSH2 0x0faa 040B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0405 stack[0] = 0x040c } // Block ends with call to 0x0faa, returns to 0x040C label_040C: // Incoming return from call to 0x0FAA at 0x040B // Inputs[4] // { // @040F memory[0x40:0x60] // @0411 stack[-1] // @0422 memory[0x40:0x60] // @0427 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 040C 5B JUMPDEST 040D 60 PUSH1 0x40 040F 51 MLOAD 0410 80 DUP1 0411 82 DUP3 0412 60 PUSH1 0xff 0414 16 AND 0415 60 PUSH1 0xff 0417 16 AND 0418 81 DUP2 0419 52 MSTORE 041A 60 PUSH1 0x20 041C 01 ADD 041D 91 SWAP2 041E 50 POP 041F 50 POP 0420 60 PUSH1 0x40 0422 51 MLOAD 0423 80 DUP1 0424 91 SWAP2 0425 03 SUB 0426 90 SWAP1 0427 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0419 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @0427 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0428: // Incoming jump from 0x017E, if 0x39509351 == stack[-1] // Inputs[1] { @042F msg.data.length } 0428 5B JUMPDEST 0429 61 PUSH2 0x0474 042C 60 PUSH1 0x04 042E 80 DUP1 042F 36 CALLDATASIZE 0430 03 SUB 0431 60 PUSH1 0x40 0433 81 DUP2 0434 10 LT 0435 15 ISZERO 0436 61 PUSH2 0x043e 0439 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0429 stack[0] = 0x0474 // @042C stack[1] = 0x04 // @0430 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x043e, returns to 0x0474, if !(msg.data.length - 0x04 < 0x40) label_043A: // Incoming jump from 0x0439, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @043D memory[0x00:0x00] } 043A 60 PUSH1 0x00 043C 80 DUP1 043D FD *REVERT // Stack delta = +0 // Outputs[1] { @043D revert(memory[0x00:0x00]); } // Block terminates label_043E: // Incoming call from 0x0439, returns to 0x0474, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @043F stack[-2] // @0440 stack[-1] // @0444 msg.data[stack[-2]:stack[-2] + 0x20] // @0464 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 043E 5B JUMPDEST 043F 81 DUP2 0440 01 ADD 0441 90 SWAP1 0442 80 DUP1 0443 80 DUP1 0444 35 CALLDATALOAD 0445 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 045A 16 AND 045B 90 SWAP1 045C 60 PUSH1 0x20 045E 01 ADD 045F 90 SWAP1 0460 92 SWAP3 0461 91 SWAP2 0462 90 SWAP1 0463 80 DUP1 0464 35 CALLDATALOAD 0465 90 SWAP1 0466 60 PUSH1 0x20 0468 01 ADD 0469 90 SWAP1 046A 92 SWAP3 046B 91 SWAP2 046C 90 SWAP1 046D 50 POP 046E 50 POP 046F 50 POP 0470 61 PUSH2 0x0fc1 0473 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0460 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @046A stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0fc1 label_0474: // Incoming return from call to 0x043E at 0x0439 // Inputs[4] // { // @0477 memory[0x40:0x60] // @0479 stack[-1] // @0488 memory[0x40:0x60] // @048D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0474 5B JUMPDEST 0475 60 PUSH1 0x40 0477 51 MLOAD 0478 80 DUP1 0479 82 DUP3 047A 15 ISZERO 047B 15 ISZERO 047C 15 ISZERO 047D 15 ISZERO 047E 81 DUP2 047F 52 MSTORE 0480 60 PUSH1 0x20 0482 01 ADD 0483 91 SWAP2 0484 50 POP 0485 50 POP 0486 60 PUSH1 0x40 0488 51 MLOAD 0489 80 DUP1 048A 91 SWAP2 048B 03 SUB 048C 90 SWAP1 048D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @047F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @048D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_048E: // Incoming jump from 0x0137, if 0x45c8b1a6 == stack[-1] // Inputs[1] { @0495 msg.data.length } 048E 5B JUMPDEST 048F 61 PUSH2 0x04d0 0492 60 PUSH1 0x04 0494 80 DUP1 0495 36 CALLDATASIZE 0496 03 SUB 0497 60 PUSH1 0x20 0499 81 DUP2 049A 10 LT 049B 15 ISZERO 049C 61 PUSH2 0x04a4 049F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @048F stack[0] = 0x04d0 // @0492 stack[1] = 0x04 // @0496 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04a4, returns to 0x04D0, if !(msg.data.length - 0x04 < 0x20) label_04A0: // Incoming jump from 0x049F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04A3 memory[0x00:0x00] } 04A0 60 PUSH1 0x00 04A2 80 DUP1 04A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A3 revert(memory[0x00:0x00]); } // Block terminates label_04A4: // Incoming call from 0x049F, returns to 0x04D0, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @04A5 stack[-2] // @04A6 stack[-1] // @04AA msg.data[stack[-2]:stack[-2] + 0x20] // } 04A4 5B JUMPDEST 04A5 81 DUP2 04A6 01 ADD 04A7 90 SWAP1 04A8 80 DUP1 04A9 80 DUP1 04AA 35 CALLDATALOAD 04AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C0 16 AND 04C1 90 SWAP1 04C2 60 PUSH1 0x20 04C4 01 ADD 04C5 90 SWAP1 04C6 92 SWAP3 04C7 91 SWAP2 04C8 90 SWAP1 04C9 50 POP 04CA 50 POP 04CB 50 POP 04CC 61 PUSH2 0x1066 04CF 56 *JUMP // Stack delta = -1 // Outputs[1] { @04C6 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1066 label_04D0: // Incoming return from call to 0x04A4 at 0x049F // Inputs[4] // { // @04D3 memory[0x40:0x60] // @04D5 stack[-1] // @04E4 memory[0x40:0x60] // @04E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04D0 5B JUMPDEST 04D1 60 PUSH1 0x40 04D3 51 MLOAD 04D4 80 DUP1 04D5 82 DUP3 04D6 15 ISZERO 04D7 15 ISZERO 04D8 15 ISZERO 04D9 15 ISZERO 04DA 81 DUP2 04DB 52 MSTORE 04DC 60 PUSH1 0x20 04DE 01 ADD 04DF 91 SWAP2 04E0 50 POP 04E1 50 POP 04E2 60 PUSH1 0x40 04E4 51 MLOAD 04E5 80 DUP1 04E6 91 SWAP2 04E7 03 SUB 04E8 90 SWAP1 04E9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @04E9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04EA: // Incoming jump from 0x0142, if 0x59d0e2cf == stack[-1] // Inputs[1] { @04F1 msg.data.length } 04EA 5B JUMPDEST 04EB 61 PUSH2 0x0536 04EE 60 PUSH1 0x04 04F0 80 DUP1 04F1 36 CALLDATASIZE 04F2 03 SUB 04F3 60 PUSH1 0x40 04F5 81 DUP2 04F6 10 LT 04F7 15 ISZERO 04F8 61 PUSH2 0x0500 04FB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04EB stack[0] = 0x0536 // @04EE stack[1] = 0x04 // @04F2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0500, returns to 0x0536, if !(msg.data.length - 0x04 < 0x40) label_04FC: // Incoming jump from 0x04FB, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04FF memory[0x00:0x00] } 04FC 60 PUSH1 0x00 04FE 80 DUP1 04FF FD *REVERT // Stack delta = +0 // Outputs[1] { @04FF revert(memory[0x00:0x00]); } // Block terminates label_0500: // Incoming call from 0x04FB, returns to 0x0536, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0501 stack[-2] // @0502 stack[-1] // @0506 msg.data[stack[-2]:stack[-2] + 0x20] // @0526 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0500 5B JUMPDEST 0501 81 DUP2 0502 01 ADD 0503 90 SWAP1 0504 80 DUP1 0505 80 DUP1 0506 35 CALLDATALOAD 0507 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 051C 16 AND 051D 90 SWAP1 051E 60 PUSH1 0x20 0520 01 ADD 0521 90 SWAP1 0522 92 SWAP3 0523 91 SWAP2 0524 90 SWAP1 0525 80 DUP1 0526 35 CALLDATALOAD 0527 90 SWAP1 0528 60 PUSH1 0x20 052A 01 ADD 052B 90 SWAP1 052C 92 SWAP3 052D 91 SWAP2 052E 90 SWAP1 052F 50 POP 0530 50 POP 0531 50 POP 0532 61 PUSH2 0x133a 0535 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0522 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @052C stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x133a label_0536: // Incoming return from call to 0x0500 at 0x04FB // Inputs[6] // { // @0539 memory[0x40:0x60] // @053B stack[-3] // @056D stack[-2] // @0573 stack[-1] // @0580 memory[0x40:0x60] // @0585 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0536 5B JUMPDEST 0537 60 PUSH1 0x40 0539 51 MLOAD 053A 80 DUP1 053B 84 DUP5 053C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0551 16 AND 0552 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0567 16 AND 0568 81 DUP2 0569 52 MSTORE 056A 60 PUSH1 0x20 056C 01 ADD 056D 83 DUP4 056E 81 DUP2 056F 52 MSTORE 0570 60 PUSH1 0x20 0572 01 ADD 0573 82 DUP3 0574 81 DUP2 0575 52 MSTORE 0576 60 PUSH1 0x20 0578 01 ADD 0579 93 SWAP4 057A 50 POP 057B 50 POP 057C 50 POP 057D 50 POP 057E 60 PUSH1 0x40 0580 51 MLOAD 0581 80 DUP1 0582 91 SWAP2 0583 03 SUB 0584 90 SWAP1 0585 F3 *RETURN // Stack delta = -3 // Outputs[4] // { // @0569 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @056F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-2] // @0575 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @0585 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0586: // Incoming jump from 0x014D, if 0x5ddb82d5 == stack[-1] // Inputs[1] { @058D msg.data.length } 0586 5B JUMPDEST 0587 61 PUSH2 0x05c8 058A 60 PUSH1 0x04 058C 80 DUP1 058D 36 CALLDATASIZE 058E 03 SUB 058F 60 PUSH1 0x20 0591 81 DUP2 0592 10 LT 0593 15 ISZERO 0594 61 PUSH2 0x059c 0597 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0587 stack[0] = 0x05c8 // @058A stack[1] = 0x04 // @058E stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x059c, returns to 0x05C8, if !(msg.data.length - 0x04 < 0x20) label_0598: // Incoming jump from 0x0597, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @059B memory[0x00:0x00] } 0598 60 PUSH1 0x00 059A 80 DUP1 059B FD *REVERT // Stack delta = +0 // Outputs[1] { @059B revert(memory[0x00:0x00]); } // Block terminates label_059C: // Incoming call from 0x0597, returns to 0x05C8, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @059D stack[-2] // @059E stack[-1] // @05A2 msg.data[stack[-2]:stack[-2] + 0x20] // } 059C 5B JUMPDEST 059D 81 DUP2 059E 01 ADD 059F 90 SWAP1 05A0 80 DUP1 05A1 80 DUP1 05A2 35 CALLDATALOAD 05A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05B8 16 AND 05B9 90 SWAP1 05BA 60 PUSH1 0x20 05BC 01 ADD 05BD 90 SWAP1 05BE 92 SWAP3 05BF 91 SWAP2 05C0 90 SWAP1 05C1 50 POP 05C2 50 POP 05C3 50 POP 05C4 61 PUSH2 0x1436 05C7 56 *JUMP // Stack delta = -1 // Outputs[1] { @05BE stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1436 label_05C8: // Incoming return from call to 0x059C at 0x0597 // Inputs[4] // { // @05CB memory[0x40:0x60] // @05CD stack[-1] // @05D8 memory[0x40:0x60] // @05DD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05C8 5B JUMPDEST 05C9 60 PUSH1 0x40 05CB 51 MLOAD 05CC 80 DUP1 05CD 82 DUP3 05CE 81 DUP2 05CF 52 MSTORE 05D0 60 PUSH1 0x20 05D2 01 ADD 05D3 91 SWAP2 05D4 50 POP 05D5 50 POP 05D6 60 PUSH1 0x40 05D8 51 MLOAD 05D9 80 DUP1 05DA 91 SWAP2 05DB 03 SUB 05DC 90 SWAP1 05DD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05DD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05DE: // Incoming jump from 0x0158, if 0x6ebcf607 == stack[-1] // Inputs[1] { @05E5 msg.data.length } 05DE 5B JUMPDEST 05DF 61 PUSH2 0x0620 05E2 60 PUSH1 0x04 05E4 80 DUP1 05E5 36 CALLDATASIZE 05E6 03 SUB 05E7 60 PUSH1 0x20 05E9 81 DUP2 05EA 10 LT 05EB 15 ISZERO 05EC 61 PUSH2 0x05f4 05EF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05DF stack[0] = 0x0620 // @05E2 stack[1] = 0x04 // @05E6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05f4, returns to 0x0620, if !(msg.data.length - 0x04 < 0x20) label_05F0: // Incoming jump from 0x05EF, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05F3 memory[0x00:0x00] } 05F0 60 PUSH1 0x00 05F2 80 DUP1 05F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F3 revert(memory[0x00:0x00]); } // Block terminates label_05F4: // Incoming call from 0x05EF, returns to 0x0620, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @05F5 stack[-2] // @05F6 stack[-1] // @05FA msg.data[stack[-2]:stack[-2] + 0x20] // } 05F4 5B JUMPDEST 05F5 81 DUP2 05F6 01 ADD 05F7 90 SWAP1 05F8 80 DUP1 05F9 80 DUP1 05FA 35 CALLDATALOAD 05FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0610 16 AND 0611 90 SWAP1 0612 60 PUSH1 0x20 0614 01 ADD 0615 90 SWAP1 0616 92 SWAP3 0617 91 SWAP2 0618 90 SWAP1 0619 50 POP 061A 50 POP 061B 50 POP 061C 61 PUSH2 0x1482 061F 56 *JUMP // Stack delta = -1 // Outputs[1] { @0616 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1482 label_0620: // Incoming return from call to 0x05F4 at 0x05EF // Inputs[4] // { // @0623 memory[0x40:0x60] // @0625 stack[-1] // @0630 memory[0x40:0x60] // @0635 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0620 5B JUMPDEST 0621 60 PUSH1 0x40 0623 51 MLOAD 0624 80 DUP1 0625 82 DUP3 0626 81 DUP2 0627 52 MSTORE 0628 60 PUSH1 0x20 062A 01 ADD 062B 91 SWAP2 062C 50 POP 062D 50 POP 062E 60 PUSH1 0x40 0630 51 MLOAD 0631 80 DUP1 0632 91 SWAP2 0633 03 SUB 0634 90 SWAP1 0635 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0627 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0635 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0636: // Incoming jump from 0x00FB, if 0x709e147a == stack[-1] // Inputs[1] { @063D msg.data.length } 0636 5B JUMPDEST 0637 61 PUSH2 0x0682 063A 60 PUSH1 0x04 063C 80 DUP1 063D 36 CALLDATASIZE 063E 03 SUB 063F 60 PUSH1 0x40 0641 81 DUP2 0642 10 LT 0643 15 ISZERO 0644 61 PUSH2 0x064c 0647 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0637 stack[0] = 0x0682 // @063A stack[1] = 0x04 // @063E stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x064c, returns to 0x0682, if !(msg.data.length - 0x04 < 0x40) label_0648: // Incoming jump from 0x0647, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @064B memory[0x00:0x00] } 0648 60 PUSH1 0x00 064A 80 DUP1 064B FD *REVERT // Stack delta = +0 // Outputs[1] { @064B revert(memory[0x00:0x00]); } // Block terminates label_064C: // Incoming call from 0x0647, returns to 0x0682, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @064D stack[-2] // @064E stack[-1] // @0652 msg.data[stack[-2]:stack[-2] + 0x20] // @0672 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 064C 5B JUMPDEST 064D 81 DUP2 064E 01 ADD 064F 90 SWAP1 0650 80 DUP1 0651 80 DUP1 0652 35 CALLDATALOAD 0653 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0668 16 AND 0669 90 SWAP1 066A 60 PUSH1 0x20 066C 01 ADD 066D 90 SWAP1 066E 92 SWAP3 066F 91 SWAP2 0670 90 SWAP1 0671 80 DUP1 0672 35 CALLDATALOAD 0673 90 SWAP1 0674 60 PUSH1 0x20 0676 01 ADD 0677 90 SWAP1 0678 92 SWAP3 0679 91 SWAP2 067A 90 SWAP1 067B 50 POP 067C 50 POP 067D 50 POP 067E 61 PUSH2 0x149a 0681 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @066E stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0678 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x149a label_0682: // Incoming return from call to 0x064C at 0x0647 // Inputs[4] // { // @0685 memory[0x40:0x60] // @0687 stack[-1] // @0696 memory[0x40:0x60] // @069B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0682 5B JUMPDEST 0683 60 PUSH1 0x40 0685 51 MLOAD 0686 80 DUP1 0687 82 DUP3 0688 15 ISZERO 0689 15 ISZERO 068A 15 ISZERO 068B 15 ISZERO 068C 81 DUP2 068D 52 MSTORE 068E 60 PUSH1 0x20 0690 01 ADD 0691 91 SWAP2 0692 50 POP 0693 50 POP 0694 60 PUSH1 0x40 0696 51 MLOAD 0697 80 DUP1 0698 91 SWAP2 0699 03 SUB 069A 90 SWAP1 069B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @068D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @069B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_069C: // Incoming jump from 0x0106, if 0x70a08231 == stack[-1] // Inputs[1] { @06A3 msg.data.length } 069C 5B JUMPDEST 069D 61 PUSH2 0x06de 06A0 60 PUSH1 0x04 06A2 80 DUP1 06A3 36 CALLDATASIZE 06A4 03 SUB 06A5 60 PUSH1 0x20 06A7 81 DUP2 06A8 10 LT 06A9 15 ISZERO 06AA 61 PUSH2 0x06b2 06AD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @069D stack[0] = 0x06de // @06A0 stack[1] = 0x04 // @06A4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06b2, returns to 0x06DE, if !(msg.data.length - 0x04 < 0x20) label_06AE: // Incoming jump from 0x06AD, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06B1 memory[0x00:0x00] } 06AE 60 PUSH1 0x00 06B0 80 DUP1 06B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B1 revert(memory[0x00:0x00]); } // Block terminates label_06B2: // Incoming call from 0x06AD, returns to 0x06DE, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @06B3 stack[-2] // @06B4 stack[-1] // @06B8 msg.data[stack[-2]:stack[-2] + 0x20] // } 06B2 5B JUMPDEST 06B3 81 DUP2 06B4 01 ADD 06B5 90 SWAP1 06B6 80 DUP1 06B7 80 DUP1 06B8 35 CALLDATALOAD 06B9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06CE 16 AND 06CF 90 SWAP1 06D0 60 PUSH1 0x20 06D2 01 ADD 06D3 90 SWAP1 06D4 92 SWAP3 06D5 91 SWAP2 06D6 90 SWAP1 06D7 50 POP 06D8 50 POP 06D9 50 POP 06DA 61 PUSH2 0x1644 06DD 56 *JUMP // Stack delta = -1 // Outputs[1] { @06D4 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1644 label_06DE: // Incoming return from call to 0x06B2 at 0x06AD // Inputs[4] // { // @06E1 memory[0x40:0x60] // @06E3 stack[-1] // @06EE memory[0x40:0x60] // @06F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06DE 5B JUMPDEST 06DF 60 PUSH1 0x40 06E1 51 MLOAD 06E2 80 DUP1 06E3 82 DUP3 06E4 81 DUP2 06E5 52 MSTORE 06E6 60 PUSH1 0x20 06E8 01 ADD 06E9 91 SWAP2 06EA 50 POP 06EB 50 POP 06EC 60 PUSH1 0x40 06EE 51 MLOAD 06EF 80 DUP1 06F0 91 SWAP2 06F1 03 SUB 06F2 90 SWAP1 06F3 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @06E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06F3 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06F4: // Incoming jump from 0x0111, if 0x83c46f86 == stack[-1] 06F4 5B JUMPDEST 06F5 61 PUSH2 0x06fc 06F8 61 PUSH2 0x168c 06FB 56 *JUMP // Stack delta = +1 // Outputs[1] { @06F5 stack[0] = 0x06fc } // Block ends with call to 0x168c, returns to 0x06FC label_06FC: // Incoming return from call to 0x168C at 0x06FB // Inputs[4] // { // @06FF memory[0x40:0x60] // @070A stack[-1] // @070D memory[stack[-1]:stack[-1] + 0x20] // @0716 memory[stack[-1]:stack[-1] + 0x20] // } 06FC 5B JUMPDEST 06FD 60 PUSH1 0x40 06FF 51 MLOAD 0700 80 DUP1 0701 80 DUP1 0702 60 PUSH1 0x20 0704 01 ADD 0705 82 DUP3 0706 81 DUP2 0707 03 SUB 0708 82 DUP3 0709 52 MSTORE 070A 83 DUP4 070B 81 DUP2 070C 81 DUP2 070D 51 MLOAD 070E 81 DUP2 070F 52 MSTORE 0710 60 PUSH1 0x20 0712 01 ADD 0713 91 SWAP2 0714 50 POP 0715 80 DUP1 0716 51 MLOAD 0717 90 SWAP1 0718 60 PUSH1 0x20 071A 01 ADD 071B 90 SWAP1 071C 60 PUSH1 0x20 071E 02 MUL 071F 80 DUP1 0720 83 DUP4 0721 83 DUP4 0722 60 PUSH1 0x00 0724 5B JUMPDEST 0725 83 DUP4 0726 81 DUP2 0727 10 LT 0728 15 ISZERO 0729 61 PUSH2 0x073f 072C 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @06FF stack[0] = memory[0x40:0x60] // @0700 stack[1] = memory[0x40:0x60] // @0709 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @070F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0713 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @071B stack[3] = 0x20 + stack[-1] // @071E stack[4] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @071F stack[5] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @0720 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0721 stack[7] = 0x20 + stack[-1] // @0722 stack[8] = 0x00 // } // Block ends with conditional jump to 0x073f, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) label_072D: // Incoming jump from 0x072C, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x072C, if not !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @072D stack[-1] // @072E stack[-2] // @0730 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0732 stack[-3] // } 072D 80 DUP1 072E 82 DUP3 072F 01 ADD 0730 51 MLOAD 0731 81 DUP2 0732 84 DUP5 0733 01 ADD 0734 52 MSTORE 0735 60 PUSH1 0x20 0737 81 DUP2 0738 01 ADD 0739 90 SWAP1 073A 50 POP 073B 61 PUSH2 0x0724 073E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0734 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0739 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0724 label_073F: // Incoming jump from 0x072C, if !(stack[-1] < stack[-4]) // Incoming jump from 0x072C, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Inputs[6] // { // @0744 stack[-6] // @0744 stack[-5] // @0746 stack[-7] // @0747 stack[-10] // @074D memory[0x40:0x60] // @0752 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 073F 5B JUMPDEST 0740 50 POP 0741 50 POP 0742 50 POP 0743 50 POP 0744 90 SWAP1 0745 50 POP 0746 01 ADD 0747 92 SWAP3 0748 50 POP 0749 50 POP 074A 50 POP 074B 60 PUSH1 0x40 074D 51 MLOAD 074E 80 DUP1 074F 91 SWAP2 0750 03 SUB 0751 90 SWAP1 0752 F3 *RETURN // Stack delta = -10 // Outputs[1] { @0752 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_0753: // Incoming jump from 0x00CA, if 0x8e7543aa == stack[-1] 0753 5B JUMPDEST 0754 61 PUSH2 0x075b 0757 61 PUSH2 0x1776 075A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0754 stack[0] = 0x075b } // Block ends with call to 0x1776, returns to 0x075B label_075B: // Incoming return from call to 0x1776 at 0x075A // Inputs[4] // { // @075E memory[0x40:0x60] // @0769 stack[-1] // @076C memory[stack[-1]:stack[-1] + 0x20] // @0775 memory[stack[-1]:stack[-1] + 0x20] // } 075B 5B JUMPDEST 075C 60 PUSH1 0x40 075E 51 MLOAD 075F 80 DUP1 0760 80 DUP1 0761 60 PUSH1 0x20 0763 01 ADD 0764 82 DUP3 0765 81 DUP2 0766 03 SUB 0767 82 DUP3 0768 52 MSTORE 0769 83 DUP4 076A 81 DUP2 076B 81 DUP2 076C 51 MLOAD 076D 81 DUP2 076E 52 MSTORE 076F 60 PUSH1 0x20 0771 01 ADD 0772 91 SWAP2 0773 50 POP 0774 80 DUP1 0775 51 MLOAD 0776 90 SWAP1 0777 60 PUSH1 0x20 0779 01 ADD 077A 90 SWAP1 077B 60 PUSH1 0x20 077D 02 MUL 077E 80 DUP1 077F 83 DUP4 0780 83 DUP4 0781 60 PUSH1 0x00 0783 5B JUMPDEST 0784 83 DUP4 0785 81 DUP2 0786 10 LT 0787 15 ISZERO 0788 61 PUSH2 0x079e 078B 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @075E stack[0] = memory[0x40:0x60] // @075F stack[1] = memory[0x40:0x60] // @0768 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @076E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0772 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @077A stack[3] = 0x20 + stack[-1] // @077D stack[4] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @077E stack[5] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @077F stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0780 stack[7] = 0x20 + stack[-1] // @0781 stack[8] = 0x00 // } // Block ends with conditional jump to 0x079e, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) label_078C: // Incoming jump from 0x078B, if not !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x078B, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @078C stack[-1] // @078D stack[-2] // @078F memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0791 stack[-3] // } 078C 80 DUP1 078D 82 DUP3 078E 01 ADD 078F 51 MLOAD 0790 81 DUP2 0791 84 DUP5 0792 01 ADD 0793 52 MSTORE 0794 60 PUSH1 0x20 0796 81 DUP2 0797 01 ADD 0798 90 SWAP1 0799 50 POP 079A 61 PUSH2 0x0783 079D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0793 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0798 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0783 label_079E: // Incoming jump from 0x078B, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x078B, if !(stack[-1] < stack[-4]) // Inputs[6] // { // @07A3 stack[-6] // @07A3 stack[-5] // @07A5 stack[-7] // @07A6 stack[-10] // @07AC memory[0x40:0x60] // @07B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 079E 5B JUMPDEST 079F 50 POP 07A0 50 POP 07A1 50 POP 07A2 50 POP 07A3 90 SWAP1 07A4 50 POP 07A5 01 ADD 07A6 92 SWAP3 07A7 50 POP 07A8 50 POP 07A9 50 POP 07AA 60 PUSH1 0x40 07AC 51 MLOAD 07AD 80 DUP1 07AE 91 SWAP2 07AF 03 SUB 07B0 90 SWAP1 07B1 F3 *RETURN // Stack delta = -10 // Outputs[1] { @07B1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_07B2: // Incoming jump from 0x00D5, if 0x919884bf == stack[-1] // Inputs[1] { @07B9 msg.data.length } 07B2 5B JUMPDEST 07B3 61 PUSH2 0x07f4 07B6 60 PUSH1 0x04 07B8 80 DUP1 07B9 36 CALLDATASIZE 07BA 03 SUB 07BB 60 PUSH1 0x20 07BD 81 DUP2 07BE 10 LT 07BF 15 ISZERO 07C0 61 PUSH2 0x07c8 07C3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07B3 stack[0] = 0x07f4 // @07B6 stack[1] = 0x04 // @07BA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x07c8, returns to 0x07F4, if !(msg.data.length - 0x04 < 0x20) label_07C4: // Incoming jump from 0x07C3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @07C7 memory[0x00:0x00] } 07C4 60 PUSH1 0x00 07C6 80 DUP1 07C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C7 revert(memory[0x00:0x00]); } // Block terminates label_07C8: // Incoming call from 0x07C3, returns to 0x07F4, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @07C9 stack[-2] // @07CA stack[-1] // @07CE msg.data[stack[-2]:stack[-2] + 0x20] // } 07C8 5B JUMPDEST 07C9 81 DUP2 07CA 01 ADD 07CB 90 SWAP1 07CC 80 DUP1 07CD 80 DUP1 07CE 35 CALLDATALOAD 07CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07E4 16 AND 07E5 90 SWAP1 07E6 60 PUSH1 0x20 07E8 01 ADD 07E9 90 SWAP1 07EA 92 SWAP3 07EB 91 SWAP2 07EC 90 SWAP1 07ED 50 POP 07EE 50 POP 07EF 50 POP 07F0 61 PUSH2 0x1860 07F3 56 *JUMP // Stack delta = -1 // Outputs[1] { @07EA stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1860 label_07F4: // Incoming return from call to 0x07C8 at 0x07C3 // Inputs[4] // { // @07F7 memory[0x40:0x60] // @07F9 stack[-1] // @0804 memory[0x40:0x60] // @0809 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07F4 5B JUMPDEST 07F5 60 PUSH1 0x40 07F7 51 MLOAD 07F8 80 DUP1 07F9 82 DUP3 07FA 81 DUP2 07FB 52 MSTORE 07FC 60 PUSH1 0x20 07FE 01 ADD 07FF 91 SWAP2 0800 50 POP 0801 50 POP 0802 60 PUSH1 0x40 0804 51 MLOAD 0805 80 DUP1 0806 91 SWAP2 0807 03 SUB 0808 90 SWAP1 0809 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @07FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0809 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_080A: // Incoming jump from 0x00E0, if 0x93c32e06 == stack[-1] // Inputs[1] { @0811 msg.data.length } 080A 5B JUMPDEST 080B 61 PUSH2 0x084c 080E 60 PUSH1 0x04 0810 80 DUP1 0811 36 CALLDATASIZE 0812 03 SUB 0813 60 PUSH1 0x20 0815 81 DUP2 0816 10 LT 0817 15 ISZERO 0818 61 PUSH2 0x0820 081B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @080B stack[0] = 0x084c // @080E stack[1] = 0x04 // @0812 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0820, returns to 0x084C, if !(msg.data.length - 0x04 < 0x20) label_081C: // Incoming jump from 0x081B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @081F memory[0x00:0x00] } 081C 60 PUSH1 0x00 081E 80 DUP1 081F FD *REVERT // Stack delta = +0 // Outputs[1] { @081F revert(memory[0x00:0x00]); } // Block terminates label_0820: // Incoming call from 0x081B, returns to 0x084C, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0821 stack[-2] // @0822 stack[-1] // @0826 msg.data[stack[-2]:stack[-2] + 0x20] // } 0820 5B JUMPDEST 0821 81 DUP2 0822 01 ADD 0823 90 SWAP1 0824 80 DUP1 0825 80 DUP1 0826 35 CALLDATALOAD 0827 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 083C 16 AND 083D 90 SWAP1 083E 60 PUSH1 0x20 0840 01 ADD 0841 90 SWAP1 0842 92 SWAP3 0843 91 SWAP2 0844 90 SWAP1 0845 50 POP 0846 50 POP 0847 50 POP 0848 61 PUSH2 0x18a9 084B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0842 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x18a9 label_084C: // Incoming return from call to 0x0820 at 0x081B 084C 5B JUMPDEST 084D 00 *STOP // Stack delta = +0 // Outputs[1] { @084D stop(); } // Block terminates label_084E: // Incoming jump from 0x00EB, if 0x946bcc30 == stack[-1] 084E 5B JUMPDEST 084F 61 PUSH2 0x0856 0852 61 PUSH2 0x1a23 0855 56 *JUMP // Stack delta = +1 // Outputs[1] { @084F stack[0] = 0x0856 } // Block ends with call to 0x1a23, returns to 0x0856 label_0856: // Incoming return from call to 0x1A23 at 0x0855 // Inputs[4] // { // @0859 memory[0x40:0x60] // @085B stack[-1] // @0892 memory[0x40:0x60] // @0897 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0856 5B JUMPDEST 0857 60 PUSH1 0x40 0859 51 MLOAD 085A 80 DUP1 085B 82 DUP3 085C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0871 16 AND 0872 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0887 16 AND 0888 81 DUP2 0889 52 MSTORE 088A 60 PUSH1 0x20 088C 01 ADD 088D 91 SWAP2 088E 50 POP 088F 50 POP 0890 60 PUSH1 0x40 0892 51 MLOAD 0893 80 DUP1 0894 91 SWAP2 0895 03 SUB 0896 90 SWAP1 0897 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0889 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0897 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0898: // Incoming jump from 0x0099, if 0x95d89b41 == stack[-1] 0898 5B JUMPDEST 0899 61 PUSH2 0x08a0 089C 61 PUSH2 0x1a4d 089F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0899 stack[0] = 0x08a0 } // Block ends with call to 0x1a4d, returns to 0x08A0 label_08A0: // Incoming return from call to 0x1A4D at 0x089F // Inputs[4] // { // @08A3 memory[0x40:0x60] // @08AE stack[-1] // @08B1 memory[stack[-1]:stack[-1] + 0x20] // @08BA memory[stack[-1]:stack[-1] + 0x20] // } 08A0 5B JUMPDEST 08A1 60 PUSH1 0x40 08A3 51 MLOAD 08A4 80 DUP1 08A5 80 DUP1 08A6 60 PUSH1 0x20 08A8 01 ADD 08A9 82 DUP3 08AA 81 DUP2 08AB 03 SUB 08AC 82 DUP3 08AD 52 MSTORE 08AE 83 DUP4 08AF 81 DUP2 08B0 81 DUP2 08B1 51 MLOAD 08B2 81 DUP2 08B3 52 MSTORE 08B4 60 PUSH1 0x20 08B6 01 ADD 08B7 91 SWAP2 08B8 50 POP 08B9 80 DUP1 08BA 51 MLOAD 08BB 90 SWAP1 08BC 60 PUSH1 0x20 08BE 01 ADD 08BF 90 SWAP1 08C0 80 DUP1 08C1 83 DUP4 08C2 83 DUP4 08C3 60 PUSH1 0x00 08C5 5B JUMPDEST 08C6 83 DUP4 08C7 81 DUP2 08C8 10 LT 08C9 15 ISZERO 08CA 61 PUSH2 0x08e0 08CD 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @08A3 stack[0] = memory[0x40:0x60] // @08A4 stack[1] = memory[0x40:0x60] // @08AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @08B3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @08B7 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @08BF stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @08BF stack[3] = 0x20 + stack[-1] // @08C0 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @08C1 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @08C2 stack[7] = 0x20 + stack[-1] // @08C3 stack[8] = 0x00 // } // Block ends with conditional jump to 0x08e0, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_08CE: // Incoming jump from 0x08CD, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x08CD, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @08CE stack[-1] // @08CF stack[-2] // @08D1 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @08D3 stack[-3] // } 08CE 80 DUP1 08CF 82 DUP3 08D0 01 ADD 08D1 51 MLOAD 08D2 81 DUP2 08D3 84 DUP5 08D4 01 ADD 08D5 52 MSTORE 08D6 60 PUSH1 0x20 08D8 81 DUP2 08D9 01 ADD 08DA 90 SWAP1 08DB 50 POP 08DC 61 PUSH2 0x08c5 08DF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08D5 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @08DA stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x08c5 label_08E0: // Incoming jump from 0x08CD, if !(stack[-1] < stack[-4]) // Incoming jump from 0x08CD, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @08E5 stack[-6] // @08E5 stack[-5] // @08E7 stack[-7] // } 08E0 5B JUMPDEST 08E1 50 POP 08E2 50 POP 08E3 50 POP 08E4 50 POP 08E5 90 SWAP1 08E6 50 POP 08E7 90 SWAP1 08E8 81 DUP2 08E9 01 ADD 08EA 90 SWAP1 08EB 60 PUSH1 0x1f 08ED 16 AND 08EE 80 DUP1 08EF 15 ISZERO 08F0 61 PUSH2 0x090d 08F3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @08EA stack[-7] = stack[-5] + stack[-7] // @08ED stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x090d, if !(0x1f & stack[-5]) label_08F4: // Incoming jump from 0x08F3, if not !(0x1f & stack[-5]) // Inputs[6] // { // @08F4 stack[-1] // @08F5 stack[-2] // @08F8 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @090F stack[-5] // @0915 memory[0x40:0x60] // @091A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 08F4 80 DUP1 08F5 82 DUP3 08F6 03 SUB 08F7 80 DUP1 08F8 51 MLOAD 08F9 60 PUSH1 0x01 08FB 83 DUP4 08FC 60 PUSH1 0x20 08FE 03 SUB 08FF 61 PUSH2 0x0100 0902 0A EXP 0903 03 SUB 0904 19 NOT 0905 16 AND 0906 81 DUP2 0907 52 MSTORE 0908 60 PUSH1 0x20 090A 01 ADD 090B 91 SWAP2 090C 50 POP 090D 5B JUMPDEST 090E 50 POP 090F 92 SWAP3 0910 50 POP 0911 50 POP 0912 50 POP 0913 60 PUSH1 0x40 0915 51 MLOAD 0916 80 DUP1 0917 91 SWAP2 0918 03 SUB 0919 90 SWAP1 091A F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0907 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] // @091A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_091B: // Incoming jump from 0x00A4, if 0xa457c2d7 == stack[-1] // Inputs[1] { @0922 msg.data.length } 091B 5B JUMPDEST 091C 61 PUSH2 0x0967 091F 60 PUSH1 0x04 0921 80 DUP1 0922 36 CALLDATASIZE 0923 03 SUB 0924 60 PUSH1 0x40 0926 81 DUP2 0927 10 LT 0928 15 ISZERO 0929 61 PUSH2 0x0931 092C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @091C stack[0] = 0x0967 // @091F stack[1] = 0x04 // @0923 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0931, returns to 0x0967, if !(msg.data.length - 0x04 < 0x40) label_092D: // Incoming jump from 0x092C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0930 memory[0x00:0x00] } 092D 60 PUSH1 0x00 092F 80 DUP1 0930 FD *REVERT // Stack delta = +0 // Outputs[1] { @0930 revert(memory[0x00:0x00]); } // Block terminates label_0931: // Incoming call from 0x092C, returns to 0x0967, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0932 stack[-2] // @0933 stack[-1] // @0937 msg.data[stack[-2]:stack[-2] + 0x20] // @0957 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0931 5B JUMPDEST 0932 81 DUP2 0933 01 ADD 0934 90 SWAP1 0935 80 DUP1 0936 80 DUP1 0937 35 CALLDATALOAD 0938 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 094D 16 AND 094E 90 SWAP1 094F 60 PUSH1 0x20 0951 01 ADD 0952 90 SWAP1 0953 92 SWAP3 0954 91 SWAP2 0955 90 SWAP1 0956 80 DUP1 0957 35 CALLDATALOAD 0958 90 SWAP1 0959 60 PUSH1 0x20 095B 01 ADD 095C 90 SWAP1 095D 92 SWAP3 095E 91 SWAP2 095F 90 SWAP1 0960 50 POP 0961 50 POP 0962 50 POP 0963 61 PUSH2 0x1aef 0966 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0953 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @095D stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1aef label_0967: // Incoming return from call to 0x0931 at 0x092C // Inputs[4] // { // @096A memory[0x40:0x60] // @096C stack[-1] // @097B memory[0x40:0x60] // @0980 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0967 5B JUMPDEST 0968 60 PUSH1 0x40 096A 51 MLOAD 096B 80 DUP1 096C 82 DUP3 096D 15 ISZERO 096E 15 ISZERO 096F 15 ISZERO 0970 15 ISZERO 0971 81 DUP2 0972 52 MSTORE 0973 60 PUSH1 0x20 0975 01 ADD 0976 91 SWAP2 0977 50 POP 0978 50 POP 0979 60 PUSH1 0x40 097B 51 MLOAD 097C 80 DUP1 097D 91 SWAP2 097E 03 SUB 097F 90 SWAP1 0980 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0972 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0980 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0981: // Incoming jump from 0x00AF, if 0xa7dfc363 == stack[-1] 0981 5B JUMPDEST 0982 61 PUSH2 0x0989 0985 61 PUSH2 0x1b94 0988 56 *JUMP // Stack delta = +1 // Outputs[1] { @0982 stack[0] = 0x0989 } // Block ends with call to 0x1b94, returns to 0x0989 label_0989: // Incoming return from call to 0x1B94 at 0x0988 // Inputs[4] // { // @098C memory[0x40:0x60] // @098E stack[-1] // @0999 memory[0x40:0x60] // @099E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0989 5B JUMPDEST 098A 60 PUSH1 0x40 098C 51 MLOAD 098D 80 DUP1 098E 82 DUP3 098F 81 DUP2 0990 52 MSTORE 0991 60 PUSH1 0x20 0993 01 ADD 0994 91 SWAP2 0995 50 POP 0996 50 POP 0997 60 PUSH1 0x40 0999 51 MLOAD 099A 80 DUP1 099B 91 SWAP2 099C 03 SUB 099D 90 SWAP1 099E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0990 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @099E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_099F: // Incoming jump from 0x0068, if 0xa9059cbb == stack[-1] // Inputs[1] { @09A6 msg.data.length } 099F 5B JUMPDEST 09A0 61 PUSH2 0x09eb 09A3 60 PUSH1 0x04 09A5 80 DUP1 09A6 36 CALLDATASIZE 09A7 03 SUB 09A8 60 PUSH1 0x40 09AA 81 DUP2 09AB 10 LT 09AC 15 ISZERO 09AD 61 PUSH2 0x09b5 09B0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09A0 stack[0] = 0x09eb // @09A3 stack[1] = 0x04 // @09A7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09b5, returns to 0x09EB, if !(msg.data.length - 0x04 < 0x40) label_09B1: // Incoming jump from 0x09B0, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @09B4 memory[0x00:0x00] } 09B1 60 PUSH1 0x00 09B3 80 DUP1 09B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @09B4 revert(memory[0x00:0x00]); } // Block terminates label_09B5: // Incoming call from 0x09B0, returns to 0x09EB, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @09B6 stack[-2] // @09B7 stack[-1] // @09BB msg.data[stack[-2]:stack[-2] + 0x20] // @09DB msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 09B5 5B JUMPDEST 09B6 81 DUP2 09B7 01 ADD 09B8 90 SWAP1 09B9 80 DUP1 09BA 80 DUP1 09BB 35 CALLDATALOAD 09BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09D1 16 AND 09D2 90 SWAP1 09D3 60 PUSH1 0x20 09D5 01 ADD 09D6 90 SWAP1 09D7 92 SWAP3 09D8 91 SWAP2 09D9 90 SWAP1 09DA 80 DUP1 09DB 35 CALLDATALOAD 09DC 90 SWAP1 09DD 60 PUSH1 0x20 09DF 01 ADD 09E0 90 SWAP1 09E1 92 SWAP3 09E2 91 SWAP2 09E3 90 SWAP1 09E4 50 POP 09E5 50 POP 09E6 50 POP 09E7 61 PUSH2 0x1b9e 09EA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @09D7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @09E1 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1b9e label_09EB: // Incoming return from call to 0x09B5 at 0x09B0 // Inputs[4] // { // @09EE memory[0x40:0x60] // @09F0 stack[-1] // @09FF memory[0x40:0x60] // @0A04 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09EB 5B JUMPDEST 09EC 60 PUSH1 0x40 09EE 51 MLOAD 09EF 80 DUP1 09F0 82 DUP3 09F1 15 ISZERO 09F2 15 ISZERO 09F3 15 ISZERO 09F4 15 ISZERO 09F5 81 DUP2 09F6 52 MSTORE 09F7 60 PUSH1 0x20 09F9 01 ADD 09FA 91 SWAP2 09FB 50 POP 09FC 50 POP 09FD 60 PUSH1 0x40 09FF 51 MLOAD 0A00 80 DUP1 0A01 91 SWAP2 0A02 03 SUB 0A03 90 SWAP1 0A04 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @09F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0A04 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A05: // Incoming jump from 0x0073, if 0xc2876aa3 == stack[-1] 0A05 5B JUMPDEST 0A06 61 PUSH2 0x0a0d 0A09 61 PUSH2 0x1bdd 0A0C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A06 stack[0] = 0x0a0d } // Block ends with call to 0x1bdd, returns to 0x0A0D label_0A0D: // Incoming return from call to 0x1BDD at 0x0A0C // Inputs[4] // { // @0A10 memory[0x40:0x60] // @0A12 stack[-1] // @0A1D memory[0x40:0x60] // @0A22 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 81 DUP2 0A14 52 MSTORE 0A15 60 PUSH1 0x20 0A17 01 ADD 0A18 91 SWAP2 0A19 50 POP 0A1A 50 POP 0A1B 60 PUSH1 0x40 0A1D 51 MLOAD 0A1E 80 DUP1 0A1F 91 SWAP2 0A20 03 SUB 0A21 90 SWAP1 0A22 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0A22 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A23: // Incoming jump from 0x007E, if 0xce62cd4a == stack[-1] // Inputs[1] { @0A2A msg.data.length } 0A23 5B JUMPDEST 0A24 61 PUSH2 0x0a65 0A27 60 PUSH1 0x04 0A29 80 DUP1 0A2A 36 CALLDATASIZE 0A2B 03 SUB 0A2C 60 PUSH1 0x20 0A2E 81 DUP2 0A2F 10 LT 0A30 15 ISZERO 0A31 61 PUSH2 0x0a39 0A34 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A24 stack[0] = 0x0a65 // @0A27 stack[1] = 0x04 // @0A2B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a39, returns to 0x0A65, if !(msg.data.length - 0x04 < 0x20) label_0A35: // Incoming jump from 0x0A34, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0A38 memory[0x00:0x00] } 0A35 60 PUSH1 0x00 0A37 80 DUP1 0A38 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A38 revert(memory[0x00:0x00]); } // Block terminates label_0A39: // Incoming call from 0x0A34, returns to 0x0A65, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0A3A stack[-2] // @0A3B stack[-1] // @0A3F msg.data[stack[-2]:stack[-2] + 0x20] // } 0A39 5B JUMPDEST 0A3A 81 DUP2 0A3B 01 ADD 0A3C 90 SWAP1 0A3D 80 DUP1 0A3E 80 DUP1 0A3F 35 CALLDATALOAD 0A40 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A55 16 AND 0A56 90 SWAP1 0A57 60 PUSH1 0x20 0A59 01 ADD 0A5A 90 SWAP1 0A5B 92 SWAP3 0A5C 91 SWAP2 0A5D 90 SWAP1 0A5E 50 POP 0A5F 50 POP 0A60 50 POP 0A61 61 PUSH2 0x1c46 0A64 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A5B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1c46 label_0A65: // Incoming return from call to 0x0A39 at 0x0A34 // Inputs[4] // { // @0A68 memory[0x40:0x60] // @0A6A stack[-1] // @0A79 memory[0x40:0x60] // @0A7E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A65 5B JUMPDEST 0A66 60 PUSH1 0x40 0A68 51 MLOAD 0A69 80 DUP1 0A6A 82 DUP3 0A6B 15 ISZERO 0A6C 15 ISZERO 0A6D 15 ISZERO 0A6E 15 ISZERO 0A6F 81 DUP2 0A70 52 MSTORE 0A71 60 PUSH1 0x20 0A73 01 ADD 0A74 91 SWAP2 0A75 50 POP 0A76 50 POP 0A77 60 PUSH1 0x40 0A79 51 MLOAD 0A7A 80 DUP1 0A7B 91 SWAP2 0A7C 03 SUB 0A7D 90 SWAP1 0A7E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0A7E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A7F: // Incoming jump from 0x0089, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0A86 msg.data.length } 0A7F 5B JUMPDEST 0A80 61 PUSH2 0x0ae1 0A83 60 PUSH1 0x04 0A85 80 DUP1 0A86 36 CALLDATASIZE 0A87 03 SUB 0A88 60 PUSH1 0x40 0A8A 81 DUP2 0A8B 10 LT 0A8C 15 ISZERO 0A8D 61 PUSH2 0x0a95 0A90 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A80 stack[0] = 0x0ae1 // @0A83 stack[1] = 0x04 // @0A87 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a95, returns to 0x0AE1, if !(msg.data.length - 0x04 < 0x40) label_0A91: // Incoming jump from 0x0A90, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0A94 memory[0x00:0x00] } 0A91 60 PUSH1 0x00 0A93 80 DUP1 0A94 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A94 revert(memory[0x00:0x00]); } // Block terminates label_0A95: // Incoming call from 0x0A90, returns to 0x0AE1, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0A96 stack[-2] // @0A97 stack[-1] // @0A9B msg.data[stack[-2]:stack[-2] + 0x20] // @0ABB msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0A95 5B JUMPDEST 0A96 81 DUP2 0A97 01 ADD 0A98 90 SWAP1 0A99 80 DUP1 0A9A 80 DUP1 0A9B 35 CALLDATALOAD 0A9C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AB1 16 AND 0AB2 90 SWAP1 0AB3 60 PUSH1 0x20 0AB5 01 ADD 0AB6 90 SWAP1 0AB7 92 SWAP3 0AB8 91 SWAP2 0AB9 90 SWAP1 0ABA 80 DUP1 0ABB 35 CALLDATALOAD 0ABC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AD1 16 AND 0AD2 90 SWAP1 0AD3 60 PUSH1 0x20 0AD5 01 ADD 0AD6 90 SWAP1 0AD7 92 SWAP3 0AD8 91 SWAP2 0AD9 90 SWAP1 0ADA 50 POP 0ADB 50 POP 0ADC 50 POP 0ADD 61 PUSH2 0x1d09 0AE0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0AB7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0AD7 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1d09 label_0AE1: // Incoming return from call to 0x0A95 at 0x0A90 // Inputs[4] // { // @0AE4 memory[0x40:0x60] // @0AE6 stack[-1] // @0AF1 memory[0x40:0x60] // @0AF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0AE1 5B JUMPDEST 0AE2 60 PUSH1 0x40 0AE4 51 MLOAD 0AE5 80 DUP1 0AE6 82 DUP3 0AE7 81 DUP2 0AE8 52 MSTORE 0AE9 60 PUSH1 0x20 0AEB 01 ADD 0AEC 91 SWAP2 0AED 50 POP 0AEE 50 POP 0AEF 60 PUSH1 0x40 0AF1 51 MLOAD 0AF2 80 DUP1 0AF3 91 SWAP2 0AF4 03 SUB 0AF5 90 SWAP1 0AF6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0AE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AF6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0AF7: // Incoming call from 0x01D2, returns to 0x01D3 // Inputs[2] // { // @0AFC storage[0x09] // @0AFF stack[-1] // } 0AF7 5B JUMPDEST 0AF8 60 PUSH1 0x00 0AFA 60 PUSH1 0x09 0AFC 54 SLOAD 0AFD 90 SWAP1 0AFE 50 POP 0AFF 90 SWAP1 0B00 56 *JUMP // Stack delta = +0 // Outputs[1] { @0AFF stack[-1] = storage[0x09] } // Block ends with unconditional jump to stack[-1] label_0B01: // Incoming call from 0x01F0, returns to 0x01F1 // Inputs[3] // { // @0B07 storage[0x03] // @0B28 memory[0x40:0x60] // @0B3B storage[0x03] // } 0B01 5B JUMPDEST 0B02 60 PUSH1 0x60 0B04 60 PUSH1 0x03 0B06 80 DUP1 0B07 54 SLOAD 0B08 60 PUSH1 0x01 0B0A 81 DUP2 0B0B 60 PUSH1 0x01 0B0D 16 AND 0B0E 15 ISZERO 0B0F 61 PUSH2 0x0100 0B12 02 MUL 0B13 03 SUB 0B14 16 AND 0B15 60 PUSH1 0x02 0B17 90 SWAP1 0B18 04 DIV 0B19 80 DUP1 0B1A 60 PUSH1 0x1f 0B1C 01 ADD 0B1D 60 PUSH1 0x20 0B1F 80 DUP1 0B20 91 SWAP2 0B21 04 DIV 0B22 02 MUL 0B23 60 PUSH1 0x20 0B25 01 ADD 0B26 60 PUSH1 0x40 0B28 51 MLOAD 0B29 90 SWAP1 0B2A 81 DUP2 0B2B 01 ADD 0B2C 60 PUSH1 0x40 0B2E 52 MSTORE 0B2F 80 DUP1 0B30 92 SWAP3 0B31 91 SWAP2 0B32 90 SWAP1 0B33 81 DUP2 0B34 81 DUP2 0B35 52 MSTORE 0B36 60 PUSH1 0x20 0B38 01 ADD 0B39 82 DUP3 0B3A 80 DUP1 0B3B 54 SLOAD 0B3C 60 PUSH1 0x01 0B3E 81 DUP2 0B3F 60 PUSH1 0x01 0B41 16 AND 0B42 15 ISZERO 0B43 61 PUSH2 0x0100 0B46 02 MUL 0B47 03 SUB 0B48 16 AND 0B49 60 PUSH1 0x02 0B4B 90 SWAP1 0B4C 04 DIV 0B4D 80 DUP1 0B4E 15 ISZERO 0B4F 61 PUSH2 0x0b99 0B52 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0B02 stack[0] = 0x60 // @0B2E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x03]) - 0x01 & storage[0x03]) / 0x02) / 0x20 * 0x20 // @0B30 stack[1] = memory[0x40:0x60] // @0B31 stack[2] = 0x03 // @0B32 stack[3] = (0x0100 * !(0x01 & storage[0x03]) - 0x01 & storage[0x03]) / 0x02 // @0B35 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x03]) - 0x01 & storage[0x03]) / 0x02 // @0B38 stack[4] = 0x20 + memory[0x40:0x60] // @0B39 stack[5] = 0x03 // @0B4C stack[6] = (0x0100 * !(0x01 & storage[0x03]) - 0x01 & storage[0x03]) / 0x02 // } // Block ends with conditional jump to 0x0b99, if !((0x0100 * !(0x01 & storage[0x03]) - 0x01 & storage[0x03]) / 0x02) label_0B53: // Incoming jump from 0x0B52, if not !((0x0100 * !(0x01 & storage[0x03]) - 0x01 & storage[0x03]) / 0x02) // Inputs[1] { @0B53 stack[-1] } 0B53 80 DUP1 0B54 60 PUSH1 0x1f 0B56 10 LT 0B57 61 PUSH2 0x0b6e 0B5A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b6e, if 0x1f < stack[-1] label_0B5B: // Incoming jump from 0x0B5A, if not 0x1f < stack[-1] // Inputs[4] // { // @0B5F stack[-2] // @0B60 storage[stack[-2]] // @0B63 stack[-3] // @0B65 stack[-1] // } 0B5B 61 PUSH2 0x0100 0B5E 80 DUP1 0B5F 83 DUP4 0B60 54 SLOAD 0B61 04 DIV 0B62 02 MUL 0B63 83 DUP4 0B64 52 MSTORE 0B65 91 SWAP2 0B66 60 PUSH1 0x20 0B68 01 ADD 0B69 91 SWAP2 0B6A 61 PUSH2 0x0b99 0B6D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B64 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B69 stack[-1] = stack[-1] // @0B69 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b99 label_0B6E: // Incoming jump from 0x0B5A, if 0x1f < stack[-1] // Inputs[5] // { // @0B6F stack[-3] // @0B70 stack[-1] // @0B72 stack[-2] // @0B7A memory[0x00:0x20] // @0B7E storage[keccak256(memory[0x00:0x20])] // } 0B6E 5B JUMPDEST 0B6F 82 DUP3 0B70 01 ADD 0B71 91 SWAP2 0B72 90 SWAP1 0B73 60 PUSH1 0x00 0B75 52 MSTORE 0B76 60 PUSH1 0x20 0B78 60 PUSH1 0x00 0B7A 20 SHA3 0B7B 90 SWAP1 0B7C 5B JUMPDEST 0B7D 81 DUP2 0B7E 54 SLOAD 0B7F 81 DUP2 0B80 52 MSTORE 0B81 90 SWAP1 0B82 60 PUSH1 0x01 0B84 01 ADD 0B85 90 SWAP1 0B86 60 PUSH1 0x20 0B88 01 ADD 0B89 80 DUP1 0B8A 83 DUP4 0B8B 11 GT 0B8C 61 PUSH2 0x0b7c 0B8F 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0B71 stack[-3] = stack[-3] + stack[-1] // @0B75 memory[0x00:0x20] = stack[-2] // @0B80 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B85 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B88 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b7c, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B90: // Incoming jump from 0x0B8F, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0B8F, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0B90 stack[-3] // @0B91 stack[-1] // } 0B90 82 DUP3 0B91 90 SWAP1 0B92 03 SUB 0B93 60 PUSH1 0x1f 0B95 16 AND 0B96 82 DUP3 0B97 01 ADD 0B98 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B98 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B98 stack[-1] = stack[-3] // } // Block continues label_0B99: // Incoming jump from 0x0B98 // Incoming jump from 0x0B52, if !((0x0100 * !(0x01 & storage[0x03]) - 0x01 & storage[0x03]) / 0x02) // Incoming jump from 0x0B6D // Inputs[3] // { // @0B9F stack[-7] // @0B9F stack[-6] // @0BA1 stack[-8] // } 0B99 5B JUMPDEST 0B9A 50 POP 0B9B 50 POP 0B9C 50 POP 0B9D 50 POP 0B9E 50 POP 0B9F 90 SWAP1 0BA0 50 POP 0BA1 90 SWAP1 0BA2 56 *JUMP // Stack delta = -7 // Outputs[1] { @0BA1 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0BA3: // Incoming jump from 0x02B7 // Inputs[2] // { // @0BA6 block.timestamp // @0BAA msg.sender // } 0BA3 5B JUMPDEST 0BA4 60 PUSH1 0x00 0BA6 42 TIMESTAMP 0BA7 61 PUSH2 0x0baf 0BAA 33 CALLER 0BAB 61 PUSH2 0x1860 0BAE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BA4 stack[0] = 0x00 // @0BA6 stack[1] = block.timestamp // @0BA7 stack[2] = 0x0baf // @0BAA stack[3] = msg.sender // } // Block ends with call to 0x1860, returns to 0x0BAF label_0BAF: // Incoming return from call to 0x1860 at 0x0BAE // Inputs[2] // { // @0BB0 stack[-1] // @0BB0 stack[-2] // } 0BAF 5B JUMPDEST 0BB0 10 LT 0BB1 15 ISZERO 0BB2 15 ISZERO 0BB3 61 PUSH2 0x0bbb 0BB6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0bbb, if !!(stack[-1] < stack[-2]) label_0BB7: // Incoming jump from 0x0BB6, if not !!(stack[-1] < stack[-2]) // Inputs[1] { @0BBA memory[0x00:0x00] } 0BB7 60 PUSH1 0x00 0BB9 80 DUP1 0BBA FD *REVERT // Stack delta = +0 // Outputs[1] { @0BBA revert(memory[0x00:0x00]); } // Block terminates label_0BBB: // Incoming jump from 0x0BB6, if !!(stack[-1] < stack[-2]) // Inputs[3] // { // @0BBF msg.sender // @0BC0 stack[-3] // @0BC1 stack[-2] // } 0BBB 5B JUMPDEST 0BBC 61 PUSH2 0x0bc6 0BBF 33 CALLER 0BC0 84 DUP5 0BC1 84 DUP5 0BC2 61 PUSH2 0x1d90 0BC5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BBC stack[0] = 0x0bc6 // @0BBF stack[1] = msg.sender // @0BC0 stack[2] = stack[-3] // @0BC1 stack[3] = stack[-2] // } // Block ends with call to 0x1d90, returns to 0x0BC6 label_0BC6: // Incoming return from call to 0x1D90 at 0x0BC5 // Inputs[4] // { // @0BCC storage[0x0a] // @0BDB stack[-1] // @0BDD stack[-4] // @0BDE stack[-3] // } 0BC6 5B JUMPDEST 0BC7 60 PUSH1 0x0a 0BC9 60 PUSH1 0x00 0BCB 81 DUP2 0BCC 54 SLOAD 0BCD 80 DUP1 0BCE 92 SWAP3 0BCF 91 SWAP2 0BD0 90 SWAP1 0BD1 60 PUSH1 0x01 0BD3 01 ADD 0BD4 91 SWAP2 0BD5 90 SWAP1 0BD6 50 POP 0BD7 55 SSTORE 0BD8 50 POP 0BD9 60 PUSH1 0x01 0BDB 90 SWAP1 0BDC 50 POP 0BDD 92 SWAP3 0BDE 91 SWAP2 0BDF 50 POP 0BE0 50 POP 0BE1 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0BD7 storage[0x0a] = 0x01 + storage[0x0a] // @0BDD stack[-4] = 0x01 // } // Block ends with unconditional jump to stack[-4] label_0BE2: // Incoming call from 0x02D9, returns to 0x02DA // Inputs[2] // { // @0BEA storage[0x05] // @0C1E msg.sender // } 0BE2 5B JUMPDEST 0BE3 60 PUSH1 0x00 0BE5 60 PUSH1 0x05 0BE7 60 PUSH1 0x01 0BE9 90 SWAP1 0BEA 54 SLOAD 0BEB 90 SWAP1 0BEC 61 PUSH2 0x0100 0BEF 0A EXP 0BF0 90 SWAP1 0BF1 04 DIV 0BF2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C07 16 AND 0C08 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C1D 16 AND 0C1E 33 CALLER 0C1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C34 16 AND 0C35 14 EQ 0C36 15 ISZERO 0C37 15 ISZERO 0C38 61 PUSH2 0x0c40 0C3B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BE3 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c40, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) label_0C3C: // Incoming jump from 0x0C3B, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @0C3F memory[0x00:0x00] } 0C3C 60 PUSH1 0x00 0C3E 80 DUP1 0C3F FD *REVERT // Stack delta = +0 // Outputs[1] { @0C3F revert(memory[0x00:0x00]); } // Block terminates label_0C40: // Incoming jump from 0x0C3B, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[3] // { // @0C44 storage[0x07] // @0C47 stack[-1] // @0C49 stack[-2] // } 0C40 5B JUMPDEST 0C41 60 PUSH1 0x07 0C43 80 DUP1 0C44 54 SLOAD 0C45 90 SWAP1 0C46 50 POP 0C47 90 SWAP1 0C48 50 POP 0C49 90 SWAP1 0C4A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0C49 stack[-2] = storage[0x07] } // Block ends with unconditional jump to stack[-2] label_0C4B: // Incoming call from 0x02F7, returns to 0x02F8 // Inputs[2] // { // @0C50 storage[0x02] // @0C53 stack[-1] // } 0C4B 5B JUMPDEST 0C4C 60 PUSH1 0x00 0C4E 60 PUSH1 0x02 0C50 54 SLOAD 0C51 90 SWAP1 0C52 50 POP 0C53 90 SWAP1 0C54 56 *JUMP // Stack delta = +0 // Outputs[1] { @0C53 stack[-1] = storage[0x02] } // Block ends with unconditional jump to stack[-1] label_0C55: // Incoming jump from 0x0379 // Inputs[3] // { // @0C5B stack[-3] // @0C5C stack[-2] // @0C5D stack[-1] // } 0C55 5B JUMPDEST 0C56 60 PUSH1 0x00 0C58 61 PUSH2 0x0c62 0C5B 84 DUP5 0C5C 84 DUP5 0C5D 84 DUP5 0C5E 61 PUSH2 0x1ef3 0C61 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0C56 stack[0] = 0x00 // @0C58 stack[1] = 0x0c62 // @0C5B stack[2] = stack[-3] // @0C5C stack[3] = stack[-2] // @0C5D stack[4] = stack[-1] // } // Block ends with call to 0x1ef3, returns to 0x0C62 label_0C62: // Incoming return from call to 0x1EF3 at 0x0C61 // Inputs[7] // { // @0C66 stack[-4] // @0C67 msg.sender // @0C6B stack[-2] // @0CAA memory[0x00:0x40] // @0CAD msg.sender // @0CE7 memory[0x00:0x40] // @0CE8 storage[keccak256(memory[0x00:0x40])] // } 0C62 5B JUMPDEST 0C63 61 PUSH2 0x0cfb 0C66 84 DUP5 0C67 33 CALLER 0C68 61 PUSH2 0x0cf6 0C6B 85 DUP6 0C6C 60 PUSH1 0x01 0C6E 60 PUSH1 0x00 0C70 8A DUP11 0C71 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C86 16 AND 0C87 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C9C 16 AND 0C9D 81 DUP2 0C9E 52 MSTORE 0C9F 60 PUSH1 0x20 0CA1 01 ADD 0CA2 90 SWAP1 0CA3 81 DUP2 0CA4 52 MSTORE 0CA5 60 PUSH1 0x20 0CA7 01 ADD 0CA8 60 PUSH1 0x00 0CAA 20 SHA3 0CAB 60 PUSH1 0x00 0CAD 33 CALLER 0CAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CC3 16 AND 0CC4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CD9 16 AND 0CDA 81 DUP2 0CDB 52 MSTORE 0CDC 60 PUSH1 0x20 0CDE 01 ADD 0CDF 90 SWAP1 0CE0 81 DUP2 0CE1 52 MSTORE 0CE2 60 PUSH1 0x20 0CE4 01 ADD 0CE5 60 PUSH1 0x00 0CE7 20 SHA3 0CE8 54 SLOAD 0CE9 61 PUSH2 0x20bf 0CEC 90 SWAP1 0CED 91 SWAP2 0CEE 90 SWAP1 0CEF 63 PUSH4 0xffffffff 0CF4 16 AND 0CF5 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @0C63 stack[0] = 0x0cfb // @0C66 stack[1] = stack[-4] // @0C67 stack[2] = msg.sender // @0C68 stack[3] = 0x0cf6 // @0C9E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0CA4 memory[0x20:0x40] = 0x01 // @0CDB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0CE1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0CED stack[4] = storage[keccak256(memory[0x00:0x40])] // @0CEE stack[5] = stack[-2] // } // Block ends with call to 0xffffffff & 0x20bf, returns to 0x0CF6 label_0CF6: // Incoming return from call to 0x20BF at 0x0CF5 0CF6 5B JUMPDEST 0CF7 61 PUSH2 0x1d90 0CFA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d90 label_0CFB: // Incoming return from call to 0x0CF6 at 0x0CF5 // Inputs[3] // { // @0CFE stack[-1] // @0D00 stack[-5] // @0D01 stack[-4] // } 0CFB 5B JUMPDEST 0CFC 60 PUSH1 0x01 0CFE 90 SWAP1 0CFF 50 POP 0D00 93 SWAP4 0D01 92 SWAP3 0D02 50 POP 0D03 50 POP 0D04 50 POP 0D05 56 *JUMP // Stack delta = -4 // Outputs[1] { @0D00 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0D06: // Incoming jump from 0x03E9 // Inputs[2] // { // @0D09 stack[-3] // @0D20 msg.sender // } 0D06 5B JUMPDEST 0D07 60 PUSH1 0x00 0D09 83 DUP4 0D0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D1F 16 AND 0D20 33 CALLER 0D21 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D36 16 AND 0D37 14 EQ 0D38 15 ISZERO 0D39 15 ISZERO 0D3A 15 ISZERO 0D3B 61 PUSH2 0x0d43 0D3E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D07 stack[0] = 0x00 } // Block ends with conditional jump to 0x0d43, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) label_0D3F: // Incoming jump from 0x0D3E, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[1] { @0D42 memory[0x00:0x00] } 0D3F 60 PUSH1 0x00 0D41 80 DUP1 0D42 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D42 revert(memory[0x00:0x00]); } // Block terminates label_0D43: // Incoming jump from 0x0D3E, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[1] { @0D44 stack[-4] } 0D43 5B JUMPDEST 0D44 83 DUP4 0D45 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D5A 16 AND 0D5B 60 PUSH1 0x00 0D5D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D72 16 AND 0D73 14 EQ 0D74 15 ISZERO 0D75 15 ISZERO 0D76 15 ISZERO 0D77 61 PUSH2 0x0d7f 0D7A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d7f, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) label_0D7B: // Incoming jump from 0x0D7A, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) // Inputs[1] { @0D7E memory[0x00:0x00] } 0D7B 60 PUSH1 0x00 0D7D 80 DUP1 0D7E FD *REVERT // Stack delta = +0 // Outputs[1] { @0D7E revert(memory[0x00:0x00]); } // Block terminates label_0D7F: // Incoming jump from 0x0D7A, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) // Inputs[1] { @0D80 stack[-2] } 0D7F 5B JUMPDEST 0D80 81 DUP2 0D81 60 PUSH1 0x00 0D83 10 LT 0D84 15 ISZERO 0D85 15 ISZERO 0D86 61 PUSH2 0x0d8e 0D89 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d8e, if !!(0x00 < stack[-2]) label_0D8A: // Incoming jump from 0x0D89, if not !!(0x00 < stack[-2]) // Inputs[1] { @0D8D memory[0x00:0x00] } 0D8A 60 PUSH1 0x00 0D8C 80 DUP1 0D8D FD *REVERT // Stack delta = +0 // Outputs[1] { @0D8D revert(memory[0x00:0x00]); } // Block terminates label_0D8E: // Incoming jump from 0x0D89, if !!(0x00 < stack[-2]) // Inputs[1] { @0D92 stack[-4] } 0D8E 5B JUMPDEST 0D8F 61 PUSH2 0x0d97 0D92 84 DUP5 0D93 61 PUSH2 0x1436 0D96 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D8F stack[0] = 0x0d97 // @0D92 stack[1] = stack[-4] // } // Block ends with call to 0x1436, returns to 0x0D97 label_0D97: // Incoming return from call to 0x1436 at 0x0D96 // Inputs[1] { @0D9A stack[-1] } 0D97 5B JUMPDEST 0D98 60 PUSH1 0x01 0D9A 11 GT 0D9B 15 ISZERO 0D9C 61 PUSH2 0x0e06 0D9F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e06, if !(0x01 > stack[-1]) label_0DA0: // Incoming jump from 0x0D9F, if not !(0x01 > stack[-1]) // Inputs[8] // { // @0DA2 stack[-4] // @0DA8 storage[0x0c] // @0DBE memory[0x00:0x20] // @0DCE storage[keccak256(memory[0x00:0x20]) + ((storage[0x0c] + 0x01) - 0x01)] // @0E0A stack[-2] // @0E0E msg.sender // @0E48 memory[0x00:0x40] // @0E49 storage[keccak256(memory[0x00:0x40])] // } 0DA0 60 PUSH1 0x0c 0DA2 84 DUP5 0DA3 90 SWAP1 0DA4 80 DUP1 0DA5 60 PUSH1 0x01 0DA7 81 DUP2 0DA8 54 SLOAD 0DA9 01 ADD 0DAA 80 DUP1 0DAB 82 DUP3 0DAC 55 SSTORE 0DAD 80 DUP1 0DAE 91 SWAP2 0DAF 50 POP 0DB0 50 POP 0DB1 90 SWAP1 0DB2 60 PUSH1 0x01 0DB4 82 DUP3 0DB5 03 SUB 0DB6 90 SWAP1 0DB7 60 PUSH1 0x00 0DB9 52 MSTORE 0DBA 60 PUSH1 0x20 0DBC 60 PUSH1 0x00 0DBE 20 SHA3 0DBF 01 ADD 0DC0 60 PUSH1 0x00 0DC2 90 SWAP1 0DC3 91 SWAP2 0DC4 92 SWAP3 0DC5 90 SWAP1 0DC6 91 SWAP2 0DC7 90 SWAP1 0DC8 91 SWAP2 0DC9 61 PUSH2 0x0100 0DCC 0A EXP 0DCD 81 DUP2 0DCE 54 SLOAD 0DCF 81 DUP2 0DD0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DE5 02 MUL 0DE6 19 NOT 0DE7 16 AND 0DE8 90 SWAP1 0DE9 83 DUP4 0DEA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DFF 16 AND 0E00 02 MUL 0E01 17 OR 0E02 90 SWAP1 0E03 55 SSTORE 0E04 50 POP 0E05 50 POP 0E06 5B JUMPDEST 0E07 61 PUSH2 0x0e57 0E0A 82 DUP3 0E0B 60 PUSH1 0x00 0E0D 80 DUP1 0E0E 33 CALLER 0E0F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E24 16 AND 0E25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E3A 16 AND 0E3B 81 DUP2 0E3C 52 MSTORE 0E3D 60 PUSH1 0x20 0E3F 01 ADD 0E40 90 SWAP1 0E41 81 DUP2 0E42 52 MSTORE 0E43 60 PUSH1 0x20 0E45 01 ADD 0E46 60 PUSH1 0x00 0E48 20 SHA3 0E49 54 SLOAD 0E4A 61 PUSH2 0x20bf 0E4D 90 SWAP1 0E4E 91 SWAP2 0E4F 90 SWAP1 0E50 63 PUSH4 0xffffffff 0E55 16 AND 0E56 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @0DAC storage[0x0c] = storage[0x0c] + 0x01 // @0DB9 memory[0x00:0x20] = 0x0c // @0E03 storage[keccak256(memory[0x00:0x20]) + ((storage[0x0c] + 0x01) - 0x01)] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x20]) + ((storage[0x0c] + 0x01) - 0x01)]) // @0E07 stack[0] = 0x0e57 // @0E3C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0E42 memory[0x20:0x40] = 0x00 // @0E4E stack[1] = storage[keccak256(memory[0x00:0x40])] // @0E4F stack[2] = stack[-2] // } // Block ends with call to 0xffffffff & 0x20bf, returns to 0x0E57 label_0E57: // Incoming return from call to 0x20BF at 0x0E56 // Incoming return from call to 0x20BF at 0x0E56 // Inputs[3] // { // @0E5B msg.sender // @0E95 memory[0x00:0x40] // @0E96 stack[-1] // } 0E57 5B JUMPDEST 0E58 60 PUSH1 0x00 0E5A 80 DUP1 0E5B 33 CALLER 0E5C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E71 16 AND 0E72 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E87 16 AND 0E88 81 DUP2 0E89 52 MSTORE 0E8A 60 PUSH1 0x20 0E8C 01 ADD 0E8D 90 SWAP1 0E8E 81 DUP2 0E8F 52 MSTORE 0E90 60 PUSH1 0x20 0E92 01 ADD 0E93 60 PUSH1 0x00 0E95 20 SHA3 0E96 81 DUP2 0E97 90 SWAP1 0E98 55 SSTORE 0E99 50 POP 0E9A 61 PUSH2 0x0ea1 0E9D 61 PUSH2 0x2102 0EA0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0E89 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0E8F memory[0x20:0x40] = 0x00 // @0E98 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0E9A stack[-1] = 0x0ea1 // } // Block ends with call to 0x2102, returns to 0x0EA1 label_0EA1: // Incoming return from call to 0x2102 at 0x0EA0 // Inputs[15] // { // @0EA6 memory[0x40:0x60] // @0EAE msg.sender // @0ECA stack[-4] // @0ED0 stack[-3] // @0ED4 stack[-1] // @0EDA stack[-5] // @0F14 memory[0x00:0x40] // @0F1B storage[keccak256(memory[0x00:0x40])] // @0F31 memory[0x00:0x20] // @0F45 memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @0F51 storage[0x00 + 0x03 * ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] // @0F8C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0F96 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] // @0FA1 stack[-2] // @0FA4 stack[-6] // } 0EA1 5B JUMPDEST 0EA2 60 PUSH1 0x60 0EA4 60 PUSH1 0x40 0EA6 51 MLOAD 0EA7 90 SWAP1 0EA8 81 DUP2 0EA9 01 ADD 0EAA 60 PUSH1 0x40 0EAC 52 MSTORE 0EAD 80 DUP1 0EAE 33 CALLER 0EAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EC4 16 AND 0EC5 81 DUP2 0EC6 52 MSTORE 0EC7 60 PUSH1 0x20 0EC9 01 ADD 0ECA 85 DUP6 0ECB 81 DUP2 0ECC 52 MSTORE 0ECD 60 PUSH1 0x20 0ECF 01 ADD 0ED0 84 DUP5 0ED1 81 DUP2 0ED2 52 MSTORE 0ED3 50 POP 0ED4 90 SWAP1 0ED5 50 POP 0ED6 60 PUSH1 0x0b 0ED8 60 PUSH1 0x00 0EDA 86 DUP7 0EDB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF0 16 AND 0EF1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F06 16 AND 0F07 81 DUP2 0F08 52 MSTORE 0F09 60 PUSH1 0x20 0F0B 01 ADD 0F0C 90 SWAP1 0F0D 81 DUP2 0F0E 52 MSTORE 0F0F 60 PUSH1 0x20 0F11 01 ADD 0F12 60 PUSH1 0x00 0F14 20 SHA3 0F15 81 DUP2 0F16 90 SWAP1 0F17 80 DUP1 0F18 60 PUSH1 0x01 0F1A 81 DUP2 0F1B 54 SLOAD 0F1C 01 ADD 0F1D 80 DUP1 0F1E 82 DUP3 0F1F 55 SSTORE 0F20 80 DUP1 0F21 91 SWAP2 0F22 50 POP 0F23 50 POP 0F24 90 SWAP1 0F25 60 PUSH1 0x01 0F27 82 DUP3 0F28 03 SUB 0F29 90 SWAP1 0F2A 60 PUSH1 0x00 0F2C 52 MSTORE 0F2D 60 PUSH1 0x20 0F2F 60 PUSH1 0x00 0F31 20 SHA3 0F32 90 SWAP1 0F33 60 PUSH1 0x03 0F35 02 MUL 0F36 01 ADD 0F37 60 PUSH1 0x00 0F39 90 SWAP1 0F3A 91 SWAP2 0F3B 92 SWAP3 0F3C 90 SWAP1 0F3D 91 SWAP2 0F3E 90 SWAP1 0F3F 91 SWAP2 0F40 50 POP 0F41 60 PUSH1 0x00 0F43 82 DUP3 0F44 01 ADD 0F45 51 MLOAD 0F46 81 DUP2 0F47 60 PUSH1 0x00 0F49 01 ADD 0F4A 60 PUSH1 0x00 0F4C 61 PUSH2 0x0100 0F4F 0A EXP 0F50 81 DUP2 0F51 54 SLOAD 0F52 81 DUP2 0F53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F68 02 MUL 0F69 19 NOT 0F6A 16 AND 0F6B 90 SWAP1 0F6C 83 DUP4 0F6D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F82 16 AND 0F83 02 MUL 0F84 17 OR 0F85 90 SWAP1 0F86 55 SSTORE 0F87 50 POP 0F88 60 PUSH1 0x20 0F8A 82 DUP3 0F8B 01 ADD 0F8C 51 MLOAD 0F8D 81 DUP2 0F8E 60 PUSH1 0x01 0F90 01 ADD 0F91 55 SSTORE 0F92 60 PUSH1 0x40 0F94 82 DUP3 0F95 01 ADD 0F96 51 MLOAD 0F97 81 DUP2 0F98 60 PUSH1 0x02 0F9A 01 ADD 0F9B 55 SSTORE 0F9C 50 POP 0F9D 50 POP 0F9E 50 POP 0F9F 60 PUSH1 0x01 0FA1 91 SWAP2 0FA2 50 POP 0FA3 50 POP 0FA4 93 SWAP4 0FA5 92 SWAP3 0FA6 50 POP 0FA7 50 POP 0FA8 50 POP 0FA9 56 *JUMP // Stack delta = -5 // Outputs[12] // { // @0EAC memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0EC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0ECC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-4] // @0ED2 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-3] // @0F08 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0F0E memory[0x20:0x40] = 0x0b // @0F1F storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @0F2C memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @0F86 storage[0x00 + 0x03 * ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = (0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00 + 0x03 * ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])]) // @0F91 storage[0x01 + 0x03 * ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0F9B storage[0x02 + 0x03 * ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] // @0FA4 stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_0FAA: // Incoming call from 0x040B, returns to 0x040C // Inputs[2] // { // @0FB2 storage[0x05] // @0FBF stack[-1] // } 0FAA 5B JUMPDEST 0FAB 60 PUSH1 0x00 0FAD 60 PUSH1 0x05 0FAF 60 PUSH1 0x00 0FB1 90 SWAP1 0FB2 54 SLOAD 0FB3 90 SWAP1 0FB4 61 PUSH2 0x0100 0FB7 0A EXP 0FB8 90 SWAP1 0FB9 04 DIV 0FBA 60 PUSH1 0xff 0FBC 16 AND 0FBD 90 SWAP1 0FBE 50 POP 0FBF 90 SWAP1 0FC0 56 *JUMP // Stack delta = +0 // Outputs[1] { @0FBF stack[-1] = 0xff & storage[0x05] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0FC1: // Incoming jump from 0x0473 // Inputs[7] // { // @0FC7 msg.sender // @0FC8 stack[-2] // @0FCC stack[-1] // @0FD1 msg.sender // @100B memory[0x00:0x40] // @1048 memory[0x00:0x40] // @1049 storage[keccak256(memory[0x00:0x40])] // } 0FC1 5B JUMPDEST 0FC2 60 PUSH1 0x00 0FC4 61 PUSH2 0x105c 0FC7 33 CALLER 0FC8 84 DUP5 0FC9 61 PUSH2 0x1057 0FCC 85 DUP6 0FCD 60 PUSH1 0x01 0FCF 60 PUSH1 0x00 0FD1 33 CALLER 0FD2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FE7 16 AND 0FE8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FFD 16 AND 0FFE 81 DUP2 0FFF 52 MSTORE 1000 60 PUSH1 0x20 1002 01 ADD 1003 90 SWAP1 1004 81 DUP2 1005 52 MSTORE 1006 60 PUSH1 0x20 1008 01 ADD 1009 60 PUSH1 0x00 100B 20 SHA3 100C 60 PUSH1 0x00 100E 89 DUP10 100F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1024 16 AND 1025 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 103A 16 AND 103B 81 DUP2 103C 52 MSTORE 103D 60 PUSH1 0x20 103F 01 ADD 1040 90 SWAP1 1041 81 DUP2 1042 52 MSTORE 1043 60 PUSH1 0x20 1045 01 ADD 1046 60 PUSH1 0x00 1048 20 SHA3 1049 54 SLOAD 104A 61 PUSH2 0x20e1 104D 90 SWAP1 104E 91 SWAP2 104F 90 SWAP1 1050 63 PUSH4 0xffffffff 1055 16 AND 1056 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @0FC2 stack[0] = 0x00 // @0FC4 stack[1] = 0x105c // @0FC7 stack[2] = msg.sender // @0FC8 stack[3] = stack[-2] // @0FC9 stack[4] = 0x1057 // @0FFF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1005 memory[0x20:0x40] = 0x01 // @103C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1042 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @104E stack[5] = storage[keccak256(memory[0x00:0x40])] // @104F stack[6] = stack[-1] // } // Block ends with call to 0xffffffff & 0x20e1, returns to 0x1057 label_1057: // Incoming return from call to 0x20E1 at 0x1056 1057 5B JUMPDEST 1058 61 PUSH2 0x1d90 105B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d90 label_105C: // Incoming return from call to 0x1057 at 0x1056 // Inputs[3] // { // @105F stack[-1] // @1061 stack[-4] // @1062 stack[-3] // } 105C 5B JUMPDEST 105D 60 PUSH1 0x01 105F 90 SWAP1 1060 50 POP 1061 92 SWAP3 1062 91 SWAP2 1063 50 POP 1064 50 POP 1065 56 *JUMP // Stack delta = -3 // Outputs[1] { @1061 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_1066: // Incoming jump from 0x04CF // Inputs[1] { @1069 stack[-1] } 1066 5B JUMPDEST 1067 60 PUSH1 0x00 1069 81 DUP2 106A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 107F 16 AND 1080 60 PUSH1 0x00 1082 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1097 16 AND 1098 14 EQ 1099 15 ISZERO 109A 15 ISZERO 109B 15 ISZERO 109C 61 PUSH2 0x10a4 109F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1067 stack[0] = 0x00 } // Block ends with conditional jump to 0x10a4, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_10A0: // Incoming jump from 0x109F, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @10A3 memory[0x00:0x00] } 10A0 60 PUSH1 0x00 10A2 80 DUP1 10A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @10A3 revert(memory[0x00:0x00]); } // Block terminates label_10A4: // Incoming jump from 0x109F, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[4] // { // @10AB stack[-2] // @10E5 memory[0x00:0x40] // @10E7 storage[keccak256(memory[0x00:0x40])] // @10F1 memory[0x40:0x60] // } 10A4 5B JUMPDEST 10A5 60 PUSH1 0x60 10A7 60 PUSH1 0x0b 10A9 60 PUSH1 0x00 10AB 84 DUP5 10AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10C1 16 AND 10C2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10D7 16 AND 10D8 81 DUP2 10D9 52 MSTORE 10DA 60 PUSH1 0x20 10DC 01 ADD 10DD 90 SWAP1 10DE 81 DUP2 10DF 52 MSTORE 10E0 60 PUSH1 0x20 10E2 01 ADD 10E3 60 PUSH1 0x00 10E5 20 SHA3 10E6 80 DUP1 10E7 54 SLOAD 10E8 80 DUP1 10E9 60 PUSH1 0x20 10EB 02 MUL 10EC 60 PUSH1 0x20 10EE 01 ADD 10EF 60 PUSH1 0x40 10F1 51 MLOAD 10F2 90 SWAP1 10F3 81 DUP2 10F4 01 ADD 10F5 60 PUSH1 0x40 10F7 52 MSTORE 10F8 80 DUP1 10F9 92 SWAP3 10FA 91 SWAP2 10FB 90 SWAP1 10FC 81 DUP2 10FD 81 DUP2 10FE 52 MSTORE 10FF 60 PUSH1 0x20 1101 01 ADD 1102 60 PUSH1 0x00 1104 90 SWAP1 1105 5B JUMPDEST 1106 82 DUP3 1107 82 DUP3 1108 10 LT 1109 15 ISZERO 110A 61 PUSH2 0x11a2 110D 57 *JUMPI // Stack delta = +6 // Outputs[10] // { // @10A5 stack[0] = 0x60 // @10D9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @10DF memory[0x20:0x40] = 0x0b // @10F7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[keccak256(memory[0x00:0x40])] // @10F9 stack[1] = memory[0x40:0x60] // @10FA stack[2] = keccak256(memory[0x00:0x40]) // @10FB stack[3] = storage[keccak256(memory[0x00:0x40])] // @10FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1104 stack[4] = 0x00 // @1104 stack[5] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x11a2, if !(0x00 < storage[keccak256(memory[0x00:0x40])]) label_110E: // Incoming jump from 0x110D, if not !(0x00 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x110D, if not !(stack[-2] < stack[-3]) // Inputs[8] // { // @110E stack[-4] // @110F stack[-2] // @1118 memory[0x00:0x20] // @1122 memory[0x40:0x60] // @1132 storage[0x03 * stack[-2] + keccak256(memory[0x00:0x20]) + 0x00] // @1185 storage[0x03 * stack[-2] + keccak256(memory[0x00:0x20]) + 0x01] // @118F storage[0x03 * stack[-2] + keccak256(memory[0x00:0x20]) + 0x02] // @1194 stack[-1] // } 110E 83 DUP4 110F 82 DUP3 1110 90 SWAP1 1111 60 PUSH1 0x00 1113 52 MSTORE 1114 60 PUSH1 0x20 1116 60 PUSH1 0x00 1118 20 SHA3 1119 90 SWAP1 111A 60 PUSH1 0x03 111C 02 MUL 111D 01 ADD 111E 60 PUSH1 0x60 1120 60 PUSH1 0x40 1122 51 MLOAD 1123 90 SWAP1 1124 81 DUP2 1125 01 ADD 1126 60 PUSH1 0x40 1128 52 MSTORE 1129 90 SWAP1 112A 81 DUP2 112B 60 PUSH1 0x00 112D 82 DUP3 112E 01 ADD 112F 60 PUSH1 0x00 1131 90 SWAP1 1132 54 SLOAD 1133 90 SWAP1 1134 61 PUSH2 0x0100 1137 0A EXP 1138 90 SWAP1 1139 04 DIV 113A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 114F 16 AND 1150 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1165 16 AND 1166 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 117B 16 AND 117C 81 DUP2 117D 52 MSTORE 117E 60 PUSH1 0x20 1180 01 ADD 1181 60 PUSH1 0x01 1183 82 DUP3 1184 01 ADD 1185 54 SLOAD 1186 81 DUP2 1187 52 MSTORE 1188 60 PUSH1 0x20 118A 01 ADD 118B 60 PUSH1 0x02 118D 82 DUP3 118E 01 ADD 118F 54 SLOAD 1190 81 DUP2 1191 52 MSTORE 1192 50 POP 1193 50 POP 1194 81 DUP2 1195 52 MSTORE 1196 60 PUSH1 0x20 1198 01 ADD 1199 90 SWAP1 119A 60 PUSH1 0x01 119C 01 ADD 119D 90 SWAP1 119E 61 PUSH2 0x1105 11A1 56 *JUMP // Stack delta = +0 // Outputs[8] // { // @1113 memory[0x00:0x20] = stack[-4] // @1128 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @117D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03 * stack[-2] + keccak256(memory[0x00:0x20]) + 0x00] / 0x0100 ** 0x00 // @1187 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = storage[0x03 * stack[-2] + keccak256(memory[0x00:0x20]) + 0x01] // @1191 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = storage[0x03 * stack[-2] + keccak256(memory[0x00:0x20]) + 0x02] // @1195 memory[stack[-1]:stack[-1] + 0x20] = memory[0x40:0x60] // @119D stack[-1] = 0x20 + stack[-1] // @119D stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x1105 label_11A2: // Incoming jump from 0x110D, if !(0x00 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x110D, if !(stack[-2] < stack[-3]) // Inputs[3] // { // @11A7 stack[-6] // @11A7 stack[-5] // @11B0 memory[stack[-5]:stack[-5] + 0x20] // } 11A2 5B JUMPDEST 11A3 50 POP 11A4 50 POP 11A5 50 POP 11A6 50 POP 11A7 90 SWAP1 11A8 50 POP 11A9 60 PUSH1 0x00 11AB 80 DUP1 11AC 90 SWAP1 11AD 50 POP 11AE 5B JUMPDEST 11AF 81 DUP2 11B0 51 MLOAD 11B1 81 DUP2 11B2 10 LT 11B3 15 ISZERO 11B4 61 PUSH2 0x132f 11B7 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @11A7 stack[-6] = stack[-5] // @11AC stack[-5] = 0x00 // } // Block ends with conditional jump to 0x132f, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) label_11B8: // Incoming jump from 0x11B7, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x11B7, if not !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) 11B8 61 PUSH2 0x11bf 11BB 61 PUSH2 0x2102 11BE 56 *JUMP // Stack delta = +1 // Outputs[1] { @11B8 stack[0] = 0x11bf } // Block ends with call to 0x2102, returns to 0x11BF label_11BF: // Incoming return from call to 0x2102 at 0x11BE // Inputs[3] // { // @11C0 stack[-3] // @11C1 stack[-2] // @11C3 memory[stack[-3]:stack[-3] + 0x20] // } 11BF 5B JUMPDEST 11C0 82 DUP3 11C1 82 DUP3 11C2 81 DUP2 11C3 51 MLOAD 11C4 81 DUP2 11C5 10 LT 11C6 15 ISZERO 11C7 15 ISZERO 11C8 61 PUSH2 0x11cd 11CB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @11C0 stack[0] = stack[-3] // @11C1 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x11cd, if !!(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) label_11CC: // Incoming jump from 0x11CB, if not !!(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) 11CC FE *ASSERT // Stack delta = +0 // Outputs[1] { @11CC assert(); } // Block terminates label_11CD: // Incoming jump from 0x11CB, if !!(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[5] // { // @11CE stack[-1] // @11CE stack[-2] // @11D7 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @11D8 stack[-3] // @11DE memory[0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]:0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] + 0x20] // } 11CD 5B JUMPDEST 11CE 90 SWAP1 11CF 60 PUSH1 0x20 11D1 01 ADD 11D2 90 SWAP1 11D3 60 PUSH1 0x20 11D5 02 MUL 11D6 01 ADD 11D7 51 MLOAD 11D8 90 SWAP1 11D9 50 POP 11DA 80 DUP1 11DB 60 PUSH1 0x40 11DD 01 ADD 11DE 51 MLOAD 11DF 60 PUSH1 0x00 11E1 10 LT 11E2 80 DUP1 11E3 15 ISZERO 11E4 61 PUSH2 0x11f0 11E7 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @11D8 stack[-3] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @11E1 stack[-2] = 0x00 < memory[0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]:0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] + 0x20] // } // Block ends with conditional jump to 0x11f0, if !(0x00 < memory[0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]:0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] + 0x20]) label_11E8: // Incoming jump from 0x11E7, if not !(0x00 < memory[0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]:0x40 + memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] + 0x20]) // Inputs[3] // { // @11E9 block.timestamp // @11EA stack[-2] // @11EE memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 11E8 50 POP 11E9 42 TIMESTAMP 11EA 81 DUP2 11EB 60 PUSH1 0x20 11ED 01 ADD 11EE 51 MLOAD 11EF 10 LT 11F0 5B JUMPDEST 11F1 15 ISZERO 11F2 61 PUSH2 0x1321 11F5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1321, if !(memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] < block.timestamp) label_11F6: // Incoming jump from 0x11F5, if not !stack[-1] // Incoming jump from 0x11F5, if not !(memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] < block.timestamp) // Inputs[5] // { // @11F9 stack[-1] // @11FD memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @1201 stack[-5] // @123B memory[0x00:0x40] // @123C storage[keccak256(memory[0x00:0x40])] // } 11F6 61 PUSH2 0x124a 11F9 81 DUP2 11FA 60 PUSH1 0x40 11FC 01 ADD 11FD 51 MLOAD 11FE 60 PUSH1 0x00 1200 80 DUP1 1201 88 DUP9 1202 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1217 16 AND 1218 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 122D 16 AND 122E 81 DUP2 122F 52 MSTORE 1230 60 PUSH1 0x20 1232 01 ADD 1233 90 SWAP1 1234 81 DUP2 1235 52 MSTORE 1236 60 PUSH1 0x20 1238 01 ADD 1239 60 PUSH1 0x00 123B 20 SHA3 123C 54 SLOAD 123D 61 PUSH2 0x20e1 1240 90 SWAP1 1241 91 SWAP2 1242 90 SWAP1 1243 63 PUSH4 0xffffffff 1248 16 AND 1249 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @11F6 stack[0] = 0x124a // @122F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1235 memory[0x20:0x40] = 0x00 // @1241 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1242 stack[2] = memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } // Block ends with call to 0xffffffff & 0x20e1, returns to 0x124A label_124A: // Incoming return from call to 0x20E1 at 0x1249 // Inputs[6] // { // @124E stack[-6] // @1288 memory[0x00:0x40] // @1289 stack[-1] // @12CB memory[0x00:0x40] // @12CC stack[-3] // @12CE storage[keccak256(memory[0x00:0x40])] // } 124A 5B JUMPDEST 124B 60 PUSH1 0x00 124D 80 DUP1 124E 87 DUP8 124F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1264 16 AND 1265 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 127A 16 AND 127B 81 DUP2 127C 52 MSTORE 127D 60 PUSH1 0x20 127F 01 ADD 1280 90 SWAP1 1281 81 DUP2 1282 52 MSTORE 1283 60 PUSH1 0x20 1285 01 ADD 1286 60 PUSH1 0x00 1288 20 SHA3 1289 81 DUP2 128A 90 SWAP1 128B 55 SSTORE 128C 50 POP 128D 60 PUSH1 0x0b 128F 60 PUSH1 0x00 1291 86 DUP7 1292 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12A7 16 AND 12A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12BD 16 AND 12BE 81 DUP2 12BF 52 MSTORE 12C0 60 PUSH1 0x20 12C2 01 ADD 12C3 90 SWAP1 12C4 81 DUP2 12C5 52 MSTORE 12C6 60 PUSH1 0x20 12C8 01 ADD 12C9 60 PUSH1 0x00 12CB 20 SHA3 12CC 82 DUP3 12CD 81 DUP2 12CE 54 SLOAD 12CF 81 DUP2 12D0 10 LT 12D1 15 ISZERO 12D2 15 ISZERO 12D3 61 PUSH2 0x12d8 12D6 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @127C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1282 memory[0x20:0x40] = 0x00 // @128B storage[keccak256(memory[0x00:0x40])] = stack[-1] // @12BF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @12C5 memory[0x20:0x40] = 0x0b // @12CB stack[-1] = keccak256(memory[0x00:0x40]) // @12CC stack[0] = stack[-3] // } // Block ends with conditional jump to 0x12d8, if !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) label_12D7: // Incoming jump from 0x12D6, if not !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) 12D7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @12D7 assert(); } // Block terminates label_12D8: // Incoming jump from 0x12D6, if !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @12D9 stack[-2] // @12D9 stack[-1] // @12E1 memory[0x00:0x20] // @12F3 storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x00] // } 12D8 5B JUMPDEST 12D9 90 SWAP1 12DA 60 PUSH1 0x00 12DC 52 MSTORE 12DD 60 PUSH1 0x20 12DF 60 PUSH1 0x00 12E1 20 SHA3 12E2 90 SWAP1 12E3 60 PUSH1 0x03 12E5 02 MUL 12E6 01 ADD 12E7 60 PUSH1 0x00 12E9 80 DUP1 12EA 82 DUP3 12EB 01 ADD 12EC 60 PUSH1 0x00 12EE 61 PUSH2 0x0100 12F1 0A EXP 12F2 81 DUP2 12F3 54 SLOAD 12F4 90 SWAP1 12F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 130A 02 MUL 130B 19 NOT 130C 16 AND 130D 90 SWAP1 130E 55 SSTORE 130F 60 PUSH1 0x01 1311 82 DUP3 1312 01 ADD 1313 60 PUSH1 0x00 1315 90 SWAP1 1316 55 SSTORE 1317 60 PUSH1 0x02 1319 82 DUP3 131A 01 ADD 131B 60 PUSH1 0x00 131D 90 SWAP1 131E 55 SSTORE 131F 50 POP 1320 50 POP // Stack delta = -2 // Outputs[4] // { // @12DC memory[0x00:0x20] = stack[-2] // @130E storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x00] = ~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x00] // @1316 storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x01] = 0x00 // @131E storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x02] = 0x00 // } // Block continues label_1321: // Incoming jump from 0x11F5, if !stack[-1] // Incoming jump from 0x1320 // Incoming jump from 0x11F5, if !(memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] < block.timestamp) // Inputs[1] { @1323 stack[-2] } 1321 5B JUMPDEST 1322 50 POP 1323 80 DUP1 1324 80 DUP1 1325 60 PUSH1 0x01 1327 01 ADD 1328 91 SWAP2 1329 50 POP 132A 50 POP 132B 61 PUSH2 0x11ae 132E 56 *JUMP // Stack delta = -1 // Outputs[1] { @1328 stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x11ae label_132F: // Incoming jump from 0x11B7, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x11B7, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @1333 stack[-3] // @1336 stack[-5] // @1337 stack[-4] // } 132F 5B JUMPDEST 1330 50 POP 1331 60 PUSH1 0x01 1333 91 SWAP2 1334 50 POP 1335 50 POP 1336 91 SWAP2 1337 90 SWAP1 1338 50 POP 1339 56 *JUMP // Stack delta = -4 // Outputs[1] { @1336 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_133A: // Incoming jump from 0x0535 133A 5B JUMPDEST 133B 60 PUSH1 0x00 133D 80 DUP1 133E 60 PUSH1 0x00 1340 61 PUSH2 0x1347 1343 61 PUSH2 0x2102 1346 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @133B stack[0] = 0x00 // @133D stack[1] = 0x00 // @133E stack[2] = 0x00 // @1340 stack[3] = 0x1347 // } // Block ends with call to 0x2102, returns to 0x1347 label_1347: // Incoming return from call to 0x2102 at 0x1346 // Inputs[4] // { // @134C stack[-6] // @1386 memory[0x00:0x40] // @1387 stack[-5] // @1389 storage[keccak256(memory[0x00:0x40])] // } 1347 5B JUMPDEST 1348 60 PUSH1 0x0b 134A 60 PUSH1 0x00 134C 87 DUP8 134D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1362 16 AND 1363 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1378 16 AND 1379 81 DUP2 137A 52 MSTORE 137B 60 PUSH1 0x20 137D 01 ADD 137E 90 SWAP1 137F 81 DUP2 1380 52 MSTORE 1381 60 PUSH1 0x20 1383 01 ADD 1384 60 PUSH1 0x00 1386 20 SHA3 1387 85 DUP6 1388 81 DUP2 1389 54 SLOAD 138A 81 DUP2 138B 10 LT 138C 15 ISZERO 138D 15 ISZERO 138E 61 PUSH2 0x1393 1391 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @137A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1380 memory[0x20:0x40] = 0x0b // @1386 stack[0] = keccak256(memory[0x00:0x40]) // @1387 stack[1] = stack[-5] // } // Block ends with conditional jump to 0x1393, if !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) label_1392: // Incoming jump from 0x1391, if not !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) 1392 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1392 assert(); } // Block terminates label_1393: // Incoming jump from 0x1391, if !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) // Inputs[17] // { // @1394 stack[-2] // @1394 stack[-1] // @139C memory[0x00:0x20] // @13A6 memory[0x40:0x60] // @13B6 storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x00] // @1409 storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x01] // @1413 storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x02] // @1418 stack[-3] // @141E memory[0x00 + memory[0x40:0x60]:0x00 + memory[0x40:0x60] + 0x20] // @1423 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] // @1428 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] // @1429 stack[-4] // @142B stack[-5] // @142D stack[-6] // @1430 stack[-7] // @1432 stack[-8] // @1434 stack[-9] // } 1393 5B JUMPDEST 1394 90 SWAP1 1395 60 PUSH1 0x00 1397 52 MSTORE 1398 60 PUSH1 0x20 139A 60 PUSH1 0x00 139C 20 SHA3 139D 90 SWAP1 139E 60 PUSH1 0x03 13A0 02 MUL 13A1 01 ADD 13A2 60 PUSH1 0x60 13A4 60 PUSH1 0x40 13A6 51 MLOAD 13A7 90 SWAP1 13A8 81 DUP2 13A9 01 ADD 13AA 60 PUSH1 0x40 13AC 52 MSTORE 13AD 90 SWAP1 13AE 81 DUP2 13AF 60 PUSH1 0x00 13B1 82 DUP3 13B2 01 ADD 13B3 60 PUSH1 0x00 13B5 90 SWAP1 13B6 54 SLOAD 13B7 90 SWAP1 13B8 61 PUSH2 0x0100 13BB 0A EXP 13BC 90 SWAP1 13BD 04 DIV 13BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13D3 16 AND 13D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13E9 16 AND 13EA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13FF 16 AND 1400 81 DUP2 1401 52 MSTORE 1402 60 PUSH1 0x20 1404 01 ADD 1405 60 PUSH1 0x01 1407 82 DUP3 1408 01 ADD 1409 54 SLOAD 140A 81 DUP2 140B 52 MSTORE 140C 60 PUSH1 0x20 140E 01 ADD 140F 60 PUSH1 0x02 1411 82 DUP3 1412 01 ADD 1413 54 SLOAD 1414 81 DUP2 1415 52 MSTORE 1416 50 POP 1417 50 POP 1418 90 SWAP1 1419 50 POP 141A 80 DUP1 141B 60 PUSH1 0x00 141D 01 ADD 141E 51 MLOAD 141F 81 DUP2 1420 60 PUSH1 0x20 1422 01 ADD 1423 51 MLOAD 1424 82 DUP3 1425 60 PUSH1 0x40 1427 01 ADD 1428 51 MLOAD 1429 93 SWAP4 142A 50 POP 142B 93 SWAP4 142C 50 POP 142D 93 SWAP4 142E 50 POP 142F 50 POP 1430 92 SWAP3 1431 50 POP 1432 92 SWAP3 1433 50 POP 1434 92 SWAP3 1435 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @1397 memory[0x00:0x20] = stack[-2] // @13AC memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1401 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x00] / 0x0100 ** 0x00 // @140B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x01] // @1415 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = storage[0x03 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x02] // @1430 stack[-7] = memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] // @1432 stack[-8] = memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] // @1434 stack[-9] = memory[0x00 + memory[0x40:0x60]:0x00 + memory[0x40:0x60] + 0x20] // } // Block ends with unconditional jump to stack[-9] label_1436: // Incoming jump from 0x05C7 // Incoming call from 0x0D96, returns to 0x0D97 // Inputs[4] // { // @143D stack[-1] // @1477 memory[0x00:0x40] // @1479 storage[keccak256(memory[0x00:0x40])] // @147E stack[-2] // } 1436 5B JUMPDEST 1437 60 PUSH1 0x00 1439 60 PUSH1 0x0b 143B 60 PUSH1 0x00 143D 83 DUP4 143E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1453 16 AND 1454 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1469 16 AND 146A 81 DUP2 146B 52 MSTORE 146C 60 PUSH1 0x20 146E 01 ADD 146F 90 SWAP1 1470 81 DUP2 1471 52 MSTORE 1472 60 PUSH1 0x20 1474 01 ADD 1475 60 PUSH1 0x00 1477 20 SHA3 1478 80 DUP1 1479 54 SLOAD 147A 90 SWAP1 147B 50 POP 147C 90 SWAP1 147D 50 POP 147E 91 SWAP2 147F 90 SWAP1 1480 50 POP 1481 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @146B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1471 memory[0x20:0x40] = 0x0b // @147E stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1482: // Incoming jump from 0x061F // Inputs[4] // { // @1488 stack[-1] // @1490 memory[0x00:0x40] // @1497 storage[keccak256(memory[0x00:0x40])] // @1498 stack[-2] // } 1482 5B JUMPDEST 1483 60 PUSH1 0x00 1485 60 PUSH1 0x20 1487 52 MSTORE 1488 80 DUP1 1489 60 PUSH1 0x00 148B 52 MSTORE 148C 60 PUSH1 0x40 148E 60 PUSH1 0x00 1490 20 SHA3 1491 60 PUSH1 0x00 1493 91 SWAP2 1494 50 POP 1495 90 SWAP1 1496 50 POP 1497 54 SLOAD 1498 81 DUP2 1499 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1487 memory[0x20:0x40] = 0x00 // @148B memory[0x00:0x20] = stack[-1] // @1497 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_149A: // Incoming jump from 0x0681 // Inputs[2] // { // @14A2 storage[0x05] // @14D6 msg.sender // } 149A 5B JUMPDEST 149B 60 PUSH1 0x00 149D 60 PUSH1 0x05 149F 60 PUSH1 0x01 14A1 90 SWAP1 14A2 54 SLOAD 14A3 90 SWAP1 14A4 61 PUSH2 0x0100 14A7 0A EXP 14A8 90 SWAP1 14A9 04 DIV 14AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14BF 16 AND 14C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14D5 16 AND 14D6 33 CALLER 14D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14EC 16 AND 14ED 14 EQ 14EE 15 ISZERO 14EF 15 ISZERO 14F0 61 PUSH2 0x14f8 14F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @149B stack[0] = 0x00 } // Block ends with conditional jump to 0x14f8, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) label_14F4: // Incoming jump from 0x14F3, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @14F7 memory[0x00:0x00] } 14F4 60 PUSH1 0x00 14F6 80 DUP1 14F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @14F7 revert(memory[0x00:0x00]); } // Block terminates label_14F8: // Incoming jump from 0x14F3, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[2] // { // @14F9 stack[-3] // @1510 msg.sender // } 14F8 5B JUMPDEST 14F9 82 DUP3 14FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 150F 16 AND 1510 33 CALLER 1511 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1526 16 AND 1527 14 EQ 1528 15 ISZERO 1529 15 ISZERO 152A 15 ISZERO 152B 61 PUSH2 0x1533 152E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1533, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) label_152F: // Incoming jump from 0x152E, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[1] { @1532 memory[0x00:0x00] } 152F 60 PUSH1 0x00 1531 80 DUP1 1532 FD *REVERT // Stack delta = +0 // Outputs[1] { @1532 revert(memory[0x00:0x00]); } // Block terminates label_1533: // Incoming jump from 0x152E, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[1] { @1534 stack[-3] } 1533 5B JUMPDEST 1534 82 DUP3 1535 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 154A 16 AND 154B 60 PUSH1 0x00 154D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1562 16 AND 1563 14 EQ 1564 15 ISZERO 1565 15 ISZERO 1566 15 ISZERO 1567 61 PUSH2 0x156f 156A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x156f, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) label_156B: // Incoming jump from 0x156A, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[1] { @156E memory[0x00:0x00] } 156B 60 PUSH1 0x00 156D 80 DUP1 156E FD *REVERT // Stack delta = +0 // Outputs[1] { @156E revert(memory[0x00:0x00]); } // Block terminates label_156F: // Incoming jump from 0x156A, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[1] { @1570 stack[-2] } 156F 5B JUMPDEST 1570 81 DUP2 1571 60 PUSH1 0x00 1573 10 LT 1574 15 ISZERO 1575 15 ISZERO 1576 61 PUSH2 0x157e 1579 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x157e, if !!(0x00 < stack[-2]) label_157A: // Incoming jump from 0x1579, if not !!(0x00 < stack[-2]) // Inputs[1] { @157D memory[0x00:0x00] } 157A 60 PUSH1 0x00 157C 80 DUP1 157D FD *REVERT // Stack delta = +0 // Outputs[1] { @157D revert(memory[0x00:0x00]); } // Block terminates label_157E: // Incoming jump from 0x1579, if !!(0x00 < stack[-2]) // Inputs[1] { @1582 stack[-3] } 157E 5B JUMPDEST 157F 61 PUSH2 0x1587 1582 83 DUP4 1583 61 PUSH2 0x1860 1586 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @157F stack[0] = 0x1587 // @1582 stack[1] = stack[-3] // } // Block ends with call to 0x1860, returns to 0x1587 label_1587: // Incoming return from call to 0x1860 at 0x1586 // Inputs[1] { @158A stack[-1] } 1587 5B JUMPDEST 1588 60 PUSH1 0x01 158A 11 GT 158B 15 ISZERO 158C 61 PUSH2 0x15f6 158F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15f6, if !(0x01 > stack[-1]) label_1590: // Incoming jump from 0x158F, if not !(0x01 > stack[-1]) // Inputs[8] // { // @1592 stack[-3] // @1598 storage[0x07] // @15AE memory[0x00:0x20] // @15BE storage[keccak256(memory[0x00:0x20]) + ((storage[0x07] + 0x01) - 0x01)] // @15F7 stack[-2] // @1636 memory[0x00:0x40] // @163D stack[-1] // @163F stack[-4] // } 1590 60 PUSH1 0x07 1592 83 DUP4 1593 90 SWAP1 1594 80 DUP1 1595 60 PUSH1 0x01 1597 81 DUP2 1598 54 SLOAD 1599 01 ADD 159A 80 DUP1 159B 82 DUP3 159C 55 SSTORE 159D 80 DUP1 159E 91 SWAP2 159F 50 POP 15A0 50 POP 15A1 90 SWAP1 15A2 60 PUSH1 0x01 15A4 82 DUP3 15A5 03 SUB 15A6 90 SWAP1 15A7 60 PUSH1 0x00 15A9 52 MSTORE 15AA 60 PUSH1 0x20 15AC 60 PUSH1 0x00 15AE 20 SHA3 15AF 01 ADD 15B0 60 PUSH1 0x00 15B2 90 SWAP1 15B3 91 SWAP2 15B4 92 SWAP3 15B5 90 SWAP1 15B6 91 SWAP2 15B7 90 SWAP1 15B8 91 SWAP2 15B9 61 PUSH2 0x0100 15BC 0A EXP 15BD 81 DUP2 15BE 54 SLOAD 15BF 81 DUP2 15C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15D5 02 MUL 15D6 19 NOT 15D7 16 AND 15D8 90 SWAP1 15D9 83 DUP4 15DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15EF 16 AND 15F0 02 MUL 15F1 17 OR 15F2 90 SWAP1 15F3 55 SSTORE 15F4 50 POP 15F5 50 POP 15F6 5B JUMPDEST 15F7 81 DUP2 15F8 60 PUSH1 0x06 15FA 60 PUSH1 0x00 15FC 85 DUP6 15FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1612 16 AND 1613 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1628 16 AND 1629 81 DUP2 162A 52 MSTORE 162B 60 PUSH1 0x20 162D 01 ADD 162E 90 SWAP1 162F 81 DUP2 1630 52 MSTORE 1631 60 PUSH1 0x20 1633 01 ADD 1634 60 PUSH1 0x00 1636 20 SHA3 1637 81 DUP2 1638 90 SWAP1 1639 55 SSTORE 163A 50 POP 163B 60 PUSH1 0x01 163D 90 SWAP1 163E 50 POP 163F 92 SWAP3 1640 91 SWAP2 1641 50 POP 1642 50 POP 1643 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @159C storage[0x07] = storage[0x07] + 0x01 // @15A9 memory[0x00:0x20] = 0x07 // @15F3 storage[keccak256(memory[0x00:0x20]) + ((storage[0x07] + 0x01) - 0x01)] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x20]) + ((storage[0x07] + 0x01) - 0x01)]) // @162A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1630 memory[0x20:0x40] = 0x06 // @1639 storage[keccak256(memory[0x00:0x40])] = stack[-2] // @163F stack[-4] = 0x01 // } // Block ends with unconditional jump to stack[-4] label_1644: // Incoming jump from 0x06DD // Inputs[4] // { // @164A stack[-1] // @1684 memory[0x00:0x40] // @1685 storage[keccak256(memory[0x00:0x40])] // @1688 stack[-2] // } 1644 5B JUMPDEST 1645 60 PUSH1 0x00 1647 80 DUP1 1648 60 PUSH1 0x00 164A 83 DUP4 164B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1660 16 AND 1661 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1676 16 AND 1677 81 DUP2 1678 52 MSTORE 1679 60 PUSH1 0x20 167B 01 ADD 167C 90 SWAP1 167D 81 DUP2 167E 52 MSTORE 167F 60 PUSH1 0x20 1681 01 ADD 1682 60 PUSH1 0x00 1684 20 SHA3 1685 54 SLOAD 1686 90 SWAP1 1687 50 POP 1688 91 SWAP2 1689 90 SWAP1 168A 50 POP 168B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1678 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @167E memory[0x20:0x40] = 0x00 // @1688 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_168C: // Incoming call from 0x06FB, returns to 0x06FC // Inputs[2] // { // @1694 storage[0x05] // @16C8 msg.sender // } 168C 5B JUMPDEST 168D 60 PUSH1 0x60 168F 60 PUSH1 0x05 1691 60 PUSH1 0x01 1693 90 SWAP1 1694 54 SLOAD 1695 90 SWAP1 1696 61 PUSH2 0x0100 1699 0A EXP 169A 90 SWAP1 169B 04 DIV 169C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16B1 16 AND 16B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16C7 16 AND 16C8 33 CALLER 16C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16DE 16 AND 16DF 14 EQ 16E0 15 ISZERO 16E1 15 ISZERO 16E2 61 PUSH2 0x16ea 16E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @168D stack[0] = 0x60 } // Block ends with conditional jump to 0x16ea, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) label_16E6: // Incoming jump from 0x16E5, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @16E9 memory[0x00:0x00] } 16E6 60 PUSH1 0x00 16E8 80 DUP1 16E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @16E9 revert(memory[0x00:0x00]); } // Block terminates label_16EA: // Incoming jump from 0x16E5, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[3] // { // @16EE storage[0x0c] // @16F8 memory[0x40:0x60] // @170B storage[0x0c] // } 16EA 5B JUMPDEST 16EB 60 PUSH1 0x0c 16ED 80 DUP1 16EE 54 SLOAD 16EF 80 DUP1 16F0 60 PUSH1 0x20 16F2 02 MUL 16F3 60 PUSH1 0x20 16F5 01 ADD 16F6 60 PUSH1 0x40 16F8 51 MLOAD 16F9 90 SWAP1 16FA 81 DUP2 16FB 01 ADD 16FC 60 PUSH1 0x40 16FE 52 MSTORE 16FF 80 DUP1 1700 92 SWAP3 1701 91 SWAP2 1702 90 SWAP1 1703 81 DUP2 1704 81 DUP2 1705 52 MSTORE 1706 60 PUSH1 0x20 1708 01 ADD 1709 82 DUP3 170A 80 DUP1 170B 54 SLOAD 170C 80 DUP1 170D 15 ISZERO 170E 61 PUSH2 0x176c 1711 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @16FE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x0c] // @1700 stack[0] = memory[0x40:0x60] // @1701 stack[1] = 0x0c // @1702 stack[2] = storage[0x0c] // @1705 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0c] // @1708 stack[3] = 0x20 + memory[0x40:0x60] // @1709 stack[4] = 0x0c // @170B stack[5] = storage[0x0c] // } // Block ends with conditional jump to 0x176c, if !storage[0x0c] label_1712: // Incoming jump from 0x1711, if not !storage[0x0c] // Inputs[5] // { // @1714 stack[-1] // @1715 stack[-3] // @1718 stack[-2] // @1720 memory[0x00:0x20] // @1727 storage[keccak256(memory[0x00:0x20])] // } 1712 60 PUSH1 0x20 1714 02 MUL 1715 82 DUP3 1716 01 ADD 1717 91 SWAP2 1718 90 SWAP1 1719 60 PUSH1 0x00 171B 52 MSTORE 171C 60 PUSH1 0x20 171E 60 PUSH1 0x00 1720 20 SHA3 1721 90 SWAP1 1722 5B JUMPDEST 1723 81 DUP2 1724 60 PUSH1 0x00 1726 90 SWAP1 1727 54 SLOAD 1728 90 SWAP1 1729 61 PUSH2 0x0100 172C 0A EXP 172D 90 SWAP1 172E 04 DIV 172F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1744 16 AND 1745 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 175A 16 AND 175B 81 DUP2 175C 52 MSTORE 175D 60 PUSH1 0x20 175F 01 ADD 1760 90 SWAP1 1761 60 PUSH1 0x01 1763 01 ADD 1764 90 SWAP1 1765 80 DUP1 1766 83 DUP4 1767 11 GT 1768 61 PUSH2 0x1722 176B 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1717 stack[-3] = stack[-3] + 0x20 * stack[-1] // @171B memory[0x00:0x20] = stack[-2] // @175C memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20])] / 0x0100 ** 0x00 // @1764 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1764 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1722, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_176C: // Incoming jump from 0x176B, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x176B, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1711, if !storage[0x0c] // Inputs[3] // { // @1772 stack[-7] // @1772 stack[-6] // @1774 stack[-8] // } 176C 5B JUMPDEST 176D 50 POP 176E 50 POP 176F 50 POP 1770 50 POP 1771 50 POP 1772 90 SWAP1 1773 50 POP 1774 90 SWAP1 1775 56 *JUMP // Stack delta = -7 // Outputs[1] { @1774 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1776: // Incoming call from 0x075A, returns to 0x075B // Inputs[2] // { // @177E storage[0x05] // @17B2 msg.sender // } 1776 5B JUMPDEST 1777 60 PUSH1 0x60 1779 60 PUSH1 0x05 177B 60 PUSH1 0x01 177D 90 SWAP1 177E 54 SLOAD 177F 90 SWAP1 1780 61 PUSH2 0x0100 1783 0A EXP 1784 90 SWAP1 1785 04 DIV 1786 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 179B 16 AND 179C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17B1 16 AND 17B2 33 CALLER 17B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17C8 16 AND 17C9 14 EQ 17CA 15 ISZERO 17CB 15 ISZERO 17CC 61 PUSH2 0x17d4 17CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1777 stack[0] = 0x60 } // Block ends with conditional jump to 0x17d4, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) label_17D0: // Incoming jump from 0x17CF, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @17D3 memory[0x00:0x00] } 17D0 60 PUSH1 0x00 17D2 80 DUP1 17D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @17D3 revert(memory[0x00:0x00]); } // Block terminates label_17D4: // Incoming jump from 0x17CF, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[3] // { // @17D8 storage[0x07] // @17E2 memory[0x40:0x60] // @17F5 storage[0x07] // } 17D4 5B JUMPDEST 17D5 60 PUSH1 0x07 17D7 80 DUP1 17D8 54 SLOAD 17D9 80 DUP1 17DA 60 PUSH1 0x20 17DC 02 MUL 17DD 60 PUSH1 0x20 17DF 01 ADD 17E0 60 PUSH1 0x40 17E2 51 MLOAD 17E3 90 SWAP1 17E4 81 DUP2 17E5 01 ADD 17E6 60 PUSH1 0x40 17E8 52 MSTORE 17E9 80 DUP1 17EA 92 SWAP3 17EB 91 SWAP2 17EC 90 SWAP1 17ED 81 DUP2 17EE 81 DUP2 17EF 52 MSTORE 17F0 60 PUSH1 0x20 17F2 01 ADD 17F3 82 DUP3 17F4 80 DUP1 17F5 54 SLOAD 17F6 80 DUP1 17F7 15 ISZERO 17F8 61 PUSH2 0x1856 17FB 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @17E8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x07] // @17EA stack[0] = memory[0x40:0x60] // @17EB stack[1] = 0x07 // @17EC stack[2] = storage[0x07] // @17EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x07] // @17F2 stack[3] = 0x20 + memory[0x40:0x60] // @17F3 stack[4] = 0x07 // @17F5 stack[5] = storage[0x07] // } // Block ends with conditional jump to 0x1856, if !storage[0x07] label_17FC: // Incoming jump from 0x17FB, if not !storage[0x07] // Inputs[5] // { // @17FE stack[-1] // @17FF stack[-3] // @1802 stack[-2] // @180A memory[0x00:0x20] // @1811 storage[keccak256(memory[0x00:0x20])] // } 17FC 60 PUSH1 0x20 17FE 02 MUL 17FF 82 DUP3 1800 01 ADD 1801 91 SWAP2 1802 90 SWAP1 1803 60 PUSH1 0x00 1805 52 MSTORE 1806 60 PUSH1 0x20 1808 60 PUSH1 0x00 180A 20 SHA3 180B 90 SWAP1 180C 5B JUMPDEST 180D 81 DUP2 180E 60 PUSH1 0x00 1810 90 SWAP1 1811 54 SLOAD 1812 90 SWAP1 1813 61 PUSH2 0x0100 1816 0A EXP 1817 90 SWAP1 1818 04 DIV 1819 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 182E 16 AND 182F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1844 16 AND 1845 81 DUP2 1846 52 MSTORE 1847 60 PUSH1 0x20 1849 01 ADD 184A 90 SWAP1 184B 60 PUSH1 0x01 184D 01 ADD 184E 90 SWAP1 184F 80 DUP1 1850 83 DUP4 1851 11 GT 1852 61 PUSH2 0x180c 1855 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1801 stack[-3] = stack[-3] + 0x20 * stack[-1] // @1805 memory[0x00:0x20] = stack[-2] // @1846 memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20])] / 0x0100 ** 0x00 // @184E stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @184E stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x180c, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_1856: // Incoming jump from 0x1855, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1855, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x17FB, if !storage[0x07] // Inputs[3] // { // @185C stack[-7] // @185C stack[-6] // @185E stack[-8] // } 1856 5B JUMPDEST 1857 50 POP 1858 50 POP 1859 50 POP 185A 50 POP 185B 50 POP 185C 90 SWAP1 185D 50 POP 185E 90 SWAP1 185F 56 *JUMP // Stack delta = -7 // Outputs[1] { @185E stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1860: // Incoming call from 0x1BA9, returns to 0x1BAA // Incoming call from 0x0BAE, returns to 0x0BAF // Incoming call from 0x1CAE, returns to 0x1CAF // Incoming call from 0x1586, returns to 0x1587 // Incoming jump from 0x07F3 // Inputs[4] // { // @1867 stack[-1] // @18A1 memory[0x00:0x40] // @18A2 storage[keccak256(memory[0x00:0x40])] // @18A5 stack[-2] // } 1860 5B JUMPDEST 1861 60 PUSH1 0x00 1863 60 PUSH1 0x06 1865 60 PUSH1 0x00 1867 83 DUP4 1868 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 187D 16 AND 187E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1893 16 AND 1894 81 DUP2 1895 52 MSTORE 1896 60 PUSH1 0x20 1898 01 ADD 1899 90 SWAP1 189A 81 DUP2 189B 52 MSTORE 189C 60 PUSH1 0x20 189E 01 ADD 189F 60 PUSH1 0x00 18A1 20 SHA3 18A2 54 SLOAD 18A3 90 SWAP1 18A4 50 POP 18A5 91 SWAP2 18A6 90 SWAP1 18A7 50 POP 18A8 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1895 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @189B memory[0x20:0x40] = 0x06 // @18A5 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_18A9: // Incoming jump from 0x084B // Inputs[2] // { // @18AF storage[0x05] // @18E3 msg.sender // } 18A9 5B JUMPDEST 18AA 60 PUSH1 0x05 18AC 60 PUSH1 0x01 18AE 90 SWAP1 18AF 54 SLOAD 18B0 90 SWAP1 18B1 61 PUSH2 0x0100 18B4 0A EXP 18B5 90 SWAP1 18B6 04 DIV 18B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18CC 16 AND 18CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18E2 16 AND 18E3 33 CALLER 18E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18F9 16 AND 18FA 14 EQ 18FB 15 ISZERO 18FC 15 ISZERO 18FD 61 PUSH2 0x1905 1900 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1905, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) label_1901: // Incoming jump from 0x1900, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @1904 memory[0x00:0x00] } 1901 60 PUSH1 0x00 1903 80 DUP1 1904 FD *REVERT // Stack delta = +0 // Outputs[1] { @1904 revert(memory[0x00:0x00]); } // Block terminates label_1905: // Incoming jump from 0x1900, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[2] // { // @1906 stack[-1] // @191D msg.sender // } 1905 5B JUMPDEST 1906 80 DUP1 1907 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 191C 16 AND 191D 33 CALLER 191E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1933 16 AND 1934 14 EQ 1935 15 ISZERO 1936 15 ISZERO 1937 15 ISZERO 1938 61 PUSH2 0x1940 193B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1940, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_193C: // Incoming jump from 0x193B, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @193F memory[0x00:0x00] } 193C 60 PUSH1 0x00 193E 80 DUP1 193F FD *REVERT // Stack delta = +0 // Outputs[1] { @193F revert(memory[0x00:0x00]); } // Block terminates label_1940: // Incoming jump from 0x193B, if !!!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @1941 stack[-1] } 1940 5B JUMPDEST 1941 80 DUP1 1942 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1957 16 AND 1958 60 PUSH1 0x00 195A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 196F 16 AND 1970 14 EQ 1971 15 ISZERO 1972 15 ISZERO 1973 15 ISZERO 1974 61 PUSH2 0x197c 1977 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x197c, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_1978: // Incoming jump from 0x1977, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @197B memory[0x00:0x00] } 1978 60 PUSH1 0x00 197A 80 DUP1 197B FD *REVERT // Stack delta = +0 // Outputs[1] { @197B revert(memory[0x00:0x00]); } // Block terminates label_197C: // Incoming jump from 0x1977, if !!!(0xffffffffffffffffffffffffffffffffffffffff & 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[6] // { // @197D stack[-1] // @1987 storage[0x05] // @19E2 memory[0x40:0x60] // @1A1B memory[0x40:0x60] // @1A20 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1A22 stack[-2] // } 197C 5B JUMPDEST 197D 80 DUP1 197E 60 PUSH1 0x05 1980 60 PUSH1 0x01 1982 61 PUSH2 0x0100 1985 0A EXP 1986 81 DUP2 1987 54 SLOAD 1988 81 DUP2 1989 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 199E 02 MUL 199F 19 NOT 19A0 16 AND 19A1 90 SWAP1 19A2 83 DUP4 19A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19B8 16 AND 19B9 02 MUL 19BA 17 OR 19BB 90 SWAP1 19BC 55 SSTORE 19BD 50 POP 19BE 7F PUSH32 0x3cbdef563ce1381bd9b3eb27e4fc91d44b519ea35424a4df785a525de1cb0280 19DF 81 DUP2 19E0 60 PUSH1 0x40 19E2 51 MLOAD 19E3 80 DUP1 19E4 82 DUP3 19E5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19FA 16 AND 19FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A10 16 AND 1A11 81 DUP2 1A12 52 MSTORE 1A13 60 PUSH1 0x20 1A15 01 ADD 1A16 91 SWAP2 1A17 50 POP 1A18 50 POP 1A19 60 PUSH1 0x40 1A1B 51 MLOAD 1A1C 80 DUP1 1A1D 91 SWAP2 1A1E 03 SUB 1A1F 90 SWAP1 1A20 A1 LOG1 1A21 50 POP 1A22 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @19BC storage[0x05] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x01 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x01) & storage[0x05]) // @1A12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1A20 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x3cbdef563ce1381bd9b3eb27e4fc91d44b519ea35424a4df785a525de1cb0280]); // } // Block ends with unconditional jump to stack[-2] label_1A23: // Incoming call from 0x0855, returns to 0x0856 // Inputs[2] // { // @1A2B storage[0x05] // @1A4B stack[-1] // } 1A23 5B JUMPDEST 1A24 60 PUSH1 0x00 1A26 60 PUSH1 0x05 1A28 60 PUSH1 0x01 1A2A 90 SWAP1 1A2B 54 SLOAD 1A2C 90 SWAP1 1A2D 61 PUSH2 0x0100 1A30 0A EXP 1A31 90 SWAP1 1A32 04 DIV 1A33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A48 16 AND 1A49 90 SWAP1 1A4A 50 POP 1A4B 90 SWAP1 1A4C 56 *JUMP // Stack delta = +0 // Outputs[1] { @1A4B stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01 } // Block ends with unconditional jump to stack[-1] label_1A4D: // Incoming call from 0x089F, returns to 0x08A0 // Inputs[3] // { // @1A53 storage[0x04] // @1A74 memory[0x40:0x60] // @1A87 storage[0x04] // } 1A4D 5B JUMPDEST 1A4E 60 PUSH1 0x60 1A50 60 PUSH1 0x04 1A52 80 DUP1 1A53 54 SLOAD 1A54 60 PUSH1 0x01 1A56 81 DUP2 1A57 60 PUSH1 0x01 1A59 16 AND 1A5A 15 ISZERO 1A5B 61 PUSH2 0x0100 1A5E 02 MUL 1A5F 03 SUB 1A60 16 AND 1A61 60 PUSH1 0x02 1A63 90 SWAP1 1A64 04 DIV 1A65 80 DUP1 1A66 60 PUSH1 0x1f 1A68 01 ADD 1A69 60 PUSH1 0x20 1A6B 80 DUP1 1A6C 91 SWAP2 1A6D 04 DIV 1A6E 02 MUL 1A6F 60 PUSH1 0x20 1A71 01 ADD 1A72 60 PUSH1 0x40 1A74 51 MLOAD 1A75 90 SWAP1 1A76 81 DUP2 1A77 01 ADD 1A78 60 PUSH1 0x40 1A7A 52 MSTORE 1A7B 80 DUP1 1A7C 92 SWAP3 1A7D 91 SWAP2 1A7E 90 SWAP1 1A7F 81 DUP2 1A80 81 DUP2 1A81 52 MSTORE 1A82 60 PUSH1 0x20 1A84 01 ADD 1A85 82 DUP3 1A86 80 DUP1 1A87 54 SLOAD 1A88 60 PUSH1 0x01 1A8A 81 DUP2 1A8B 60 PUSH1 0x01 1A8D 16 AND 1A8E 15 ISZERO 1A8F 61 PUSH2 0x0100 1A92 02 MUL 1A93 03 SUB 1A94 16 AND 1A95 60 PUSH1 0x02 1A97 90 SWAP1 1A98 04 DIV 1A99 80 DUP1 1A9A 15 ISZERO 1A9B 61 PUSH2 0x1ae5 1A9E 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1A4E stack[0] = 0x60 // @1A7A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) / 0x20 * 0x20 // @1A7C stack[1] = memory[0x40:0x60] // @1A7D stack[2] = 0x04 // @1A7E stack[3] = (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02 // @1A81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02 // @1A84 stack[4] = 0x20 + memory[0x40:0x60] // @1A85 stack[5] = 0x04 // @1A98 stack[6] = (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02 // } // Block ends with conditional jump to 0x1ae5, if !((0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) label_1A9F: // Incoming jump from 0x1A9E, if not !((0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) // Inputs[1] { @1A9F stack[-1] } 1A9F 80 DUP1 1AA0 60 PUSH1 0x1f 1AA2 10 LT 1AA3 61 PUSH2 0x1aba 1AA6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1aba, if 0x1f < stack[-1] label_1AA7: // Incoming jump from 0x1AA6, if not 0x1f < stack[-1] // Inputs[4] // { // @1AAB stack[-2] // @1AAC storage[stack[-2]] // @1AAF stack[-3] // @1AB1 stack[-1] // } 1AA7 61 PUSH2 0x0100 1AAA 80 DUP1 1AAB 83 DUP4 1AAC 54 SLOAD 1AAD 04 DIV 1AAE 02 MUL 1AAF 83 DUP4 1AB0 52 MSTORE 1AB1 91 SWAP2 1AB2 60 PUSH1 0x20 1AB4 01 ADD 1AB5 91 SWAP2 1AB6 61 PUSH2 0x1ae5 1AB9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1AB0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1AB5 stack[-1] = stack[-1] // @1AB5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1ae5 label_1ABA: // Incoming jump from 0x1AA6, if 0x1f < stack[-1] // Inputs[5] // { // @1ABB stack[-3] // @1ABC stack[-1] // @1ABE stack[-2] // @1AC6 memory[0x00:0x20] // @1ACA storage[keccak256(memory[0x00:0x20])] // } 1ABA 5B JUMPDEST 1ABB 82 DUP3 1ABC 01 ADD 1ABD 91 SWAP2 1ABE 90 SWAP1 1ABF 60 PUSH1 0x00 1AC1 52 MSTORE 1AC2 60 PUSH1 0x20 1AC4 60 PUSH1 0x00 1AC6 20 SHA3 1AC7 90 SWAP1 1AC8 5B JUMPDEST 1AC9 81 DUP2 1ACA 54 SLOAD 1ACB 81 DUP2 1ACC 52 MSTORE 1ACD 90 SWAP1 1ACE 60 PUSH1 0x01 1AD0 01 ADD 1AD1 90 SWAP1 1AD2 60 PUSH1 0x20 1AD4 01 ADD 1AD5 80 DUP1 1AD6 83 DUP4 1AD7 11 GT 1AD8 61 PUSH2 0x1ac8 1ADB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1ABD stack[-3] = stack[-3] + stack[-1] // @1AC1 memory[0x00:0x20] = stack[-2] // @1ACC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1AD1 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1AD4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1ac8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1ADC: // Incoming jump from 0x1ADB, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1ADB, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1ADC stack[-3] // @1ADD stack[-1] // } 1ADC 82 DUP3 1ADD 90 SWAP1 1ADE 03 SUB 1ADF 60 PUSH1 0x1f 1AE1 16 AND 1AE2 82 DUP3 1AE3 01 ADD 1AE4 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1AE4 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1AE4 stack[-1] = stack[-3] // } // Block continues label_1AE5: // Incoming jump from 0x1AB9 // Incoming jump from 0x1A9E, if !((0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) // Incoming jump from 0x1AE4 // Inputs[3] // { // @1AEB stack[-7] // @1AEB stack[-6] // @1AED stack[-8] // } 1AE5 5B JUMPDEST 1AE6 50 POP 1AE7 50 POP 1AE8 50 POP 1AE9 50 POP 1AEA 50 POP 1AEB 90 SWAP1 1AEC 50 POP 1AED 90 SWAP1 1AEE 56 *JUMP // Stack delta = -7 // Outputs[1] { @1AED stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1AEF: // Incoming jump from 0x0966 // Inputs[7] // { // @1AF5 msg.sender // @1AF6 stack[-2] // @1AFA stack[-1] // @1AFF msg.sender // @1B39 memory[0x00:0x40] // @1B76 memory[0x00:0x40] // @1B77 storage[keccak256(memory[0x00:0x40])] // } 1AEF 5B JUMPDEST 1AF0 60 PUSH1 0x00 1AF2 61 PUSH2 0x1b8a 1AF5 33 CALLER 1AF6 84 DUP5 1AF7 61 PUSH2 0x1b85 1AFA 85 DUP6 1AFB 60 PUSH1 0x01 1AFD 60 PUSH1 0x00 1AFF 33 CALLER 1B00 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B15 16 AND 1B16 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B2B 16 AND 1B2C 81 DUP2 1B2D 52 MSTORE 1B2E 60 PUSH1 0x20 1B30 01 ADD 1B31 90 SWAP1 1B32 81 DUP2 1B33 52 MSTORE 1B34 60 PUSH1 0x20 1B36 01 ADD 1B37 60 PUSH1 0x00 1B39 20 SHA3 1B3A 60 PUSH1 0x00 1B3C 89 DUP10 1B3D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B52 16 AND 1B53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B68 16 AND 1B69 81 DUP2 1B6A 52 MSTORE 1B6B 60 PUSH1 0x20 1B6D 01 ADD 1B6E 90 SWAP1 1B6F 81 DUP2 1B70 52 MSTORE 1B71 60 PUSH1 0x20 1B73 01 ADD 1B74 60 PUSH1 0x00 1B76 20 SHA3 1B77 54 SLOAD 1B78 61 PUSH2 0x20bf 1B7B 90 SWAP1 1B7C 91 SWAP2 1B7D 90 SWAP1 1B7E 63 PUSH4 0xffffffff 1B83 16 AND 1B84 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @1AF0 stack[0] = 0x00 // @1AF2 stack[1] = 0x1b8a // @1AF5 stack[2] = msg.sender // @1AF6 stack[3] = stack[-2] // @1AF7 stack[4] = 0x1b85 // @1B2D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1B33 memory[0x20:0x40] = 0x01 // @1B6A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1B70 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1B7C stack[5] = storage[keccak256(memory[0x00:0x40])] // @1B7D stack[6] = stack[-1] // } // Block ends with call to 0xffffffff & 0x20bf, returns to 0x1B85 label_1B85: // Incoming return from call to 0x20BF at 0x1B84 1B85 5B JUMPDEST 1B86 61 PUSH2 0x1d90 1B89 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d90 label_1B8A: // Incoming return from call to 0x1B85 at 0x1B84 // Inputs[3] // { // @1B8D stack[-1] // @1B8F stack[-4] // @1B90 stack[-3] // } 1B8A 5B JUMPDEST 1B8B 60 PUSH1 0x01 1B8D 90 SWAP1 1B8E 50 POP 1B8F 92 SWAP3 1B90 91 SWAP2 1B91 50 POP 1B92 50 POP 1B93 56 *JUMP // Stack delta = -3 // Outputs[1] { @1B8F stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_1B94: // Incoming call from 0x0988, returns to 0x0989 // Inputs[2] // { // @1B99 storage[0x0a] // @1B9C stack[-1] // } 1B94 5B JUMPDEST 1B95 60 PUSH1 0x00 1B97 60 PUSH1 0x0a 1B99 54 SLOAD 1B9A 90 SWAP1 1B9B 50 POP 1B9C 90 SWAP1 1B9D 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B9C stack[-1] = storage[0x0a] } // Block ends with unconditional jump to stack[-1] label_1B9E: // Incoming jump from 0x09EA // Inputs[2] // { // @1BA1 block.timestamp // @1BA5 msg.sender // } 1B9E 5B JUMPDEST 1B9F 60 PUSH1 0x00 1BA1 42 TIMESTAMP 1BA2 61 PUSH2 0x1baa 1BA5 33 CALLER 1BA6 61 PUSH2 0x1860 1BA9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B9F stack[0] = 0x00 // @1BA1 stack[1] = block.timestamp // @1BA2 stack[2] = 0x1baa // @1BA5 stack[3] = msg.sender // } // Block ends with call to 0x1860, returns to 0x1BAA label_1BAA: // Incoming return from call to 0x1860 at 0x1BA9 // Inputs[2] // { // @1BAB stack[-1] // @1BAB stack[-2] // } 1BAA 5B JUMPDEST 1BAB 10 LT 1BAC 15 ISZERO 1BAD 15 ISZERO 1BAE 61 PUSH2 0x1bb6 1BB1 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1bb6, if !!(stack[-1] < stack[-2]) label_1BB2: // Incoming jump from 0x1BB1, if not !!(stack[-1] < stack[-2]) // Inputs[1] { @1BB5 memory[0x00:0x00] } 1BB2 60 PUSH1 0x00 1BB4 80 DUP1 1BB5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BB5 revert(memory[0x00:0x00]); } // Block terminates label_1BB6: // Incoming jump from 0x1BB1, if !!(stack[-1] < stack[-2]) // Inputs[3] // { // @1BBA msg.sender // @1BBB stack[-3] // @1BBC stack[-2] // } 1BB6 5B JUMPDEST 1BB7 61 PUSH2 0x1bc1 1BBA 33 CALLER 1BBB 84 DUP5 1BBC 84 DUP5 1BBD 61 PUSH2 0x1ef3 1BC0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BB7 stack[0] = 0x1bc1 // @1BBA stack[1] = msg.sender // @1BBB stack[2] = stack[-3] // @1BBC stack[3] = stack[-2] // } // Block ends with call to 0x1ef3, returns to 0x1BC1 label_1BC1: // Incoming return from call to 0x1EF3 at 0x1BC0 // Inputs[4] // { // @1BC7 storage[0x09] // @1BD6 stack[-1] // @1BD8 stack[-4] // @1BD9 stack[-3] // } 1BC1 5B JUMPDEST 1BC2 60 PUSH1 0x09 1BC4 60 PUSH1 0x00 1BC6 81 DUP2 1BC7 54 SLOAD 1BC8 80 DUP1 1BC9 92 SWAP3 1BCA 91 SWAP2 1BCB 90 SWAP1 1BCC 60 PUSH1 0x01 1BCE 01 ADD 1BCF 91 SWAP2 1BD0 90 SWAP1 1BD1 50 POP 1BD2 55 SSTORE 1BD3 50 POP 1BD4 60 PUSH1 0x01 1BD6 90 SWAP1 1BD7 50 POP 1BD8 92 SWAP3 1BD9 91 SWAP2 1BDA 50 POP 1BDB 50 POP 1BDC 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1BD2 storage[0x09] = 0x01 + storage[0x09] // @1BD8 stack[-4] = 0x01 // } // Block ends with unconditional jump to stack[-4] label_1BDD: // Incoming call from 0x0A0C, returns to 0x0A0D // Inputs[2] // { // @1BE5 storage[0x05] // @1C19 msg.sender // } 1BDD 5B JUMPDEST 1BDE 60 PUSH1 0x00 1BE0 60 PUSH1 0x05 1BE2 60 PUSH1 0x01 1BE4 90 SWAP1 1BE5 54 SLOAD 1BE6 90 SWAP1 1BE7 61 PUSH2 0x0100 1BEA 0A EXP 1BEB 90 SWAP1 1BEC 04 DIV 1BED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C02 16 AND 1C03 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C18 16 AND 1C19 33 CALLER 1C1A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C2F 16 AND 1C30 14 EQ 1C31 15 ISZERO 1C32 15 ISZERO 1C33 61 PUSH2 0x1c3b 1C36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BDE stack[0] = 0x00 } // Block ends with conditional jump to 0x1c3b, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) label_1C37: // Incoming jump from 0x1C36, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @1C3A memory[0x00:0x00] } 1C37 60 PUSH1 0x00 1C39 80 DUP1 1C3A FD *REVERT // Stack delta = +0 // Outputs[1] { @1C3A revert(memory[0x00:0x00]); } // Block terminates label_1C3B: // Incoming jump from 0x1C36, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[3] // { // @1C3F storage[0x0c] // @1C42 stack[-1] // @1C44 stack[-2] // } 1C3B 5B JUMPDEST 1C3C 60 PUSH1 0x0c 1C3E 80 DUP1 1C3F 54 SLOAD 1C40 90 SWAP1 1C41 50 POP 1C42 90 SWAP1 1C43 50 POP 1C44 90 SWAP1 1C45 56 *JUMP // Stack delta = -1 // Outputs[1] { @1C44 stack[-2] = storage[0x0c] } // Block ends with unconditional jump to stack[-2] label_1C46: // Incoming jump from 0x0A64 // Inputs[2] // { // @1C4E storage[0x05] // @1C82 msg.sender // } 1C46 5B JUMPDEST 1C47 60 PUSH1 0x00 1C49 60 PUSH1 0x05 1C4B 60 PUSH1 0x01 1C4D 90 SWAP1 1C4E 54 SLOAD 1C4F 90 SWAP1 1C50 61 PUSH2 0x0100 1C53 0A EXP 1C54 90 SWAP1 1C55 04 DIV 1C56 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C6B 16 AND 1C6C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C81 16 AND 1C82 33 CALLER 1C83 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C98 16 AND 1C99 14 EQ 1C9A 15 ISZERO 1C9B 15 ISZERO 1C9C 61 PUSH2 0x1ca4 1C9F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C47 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ca4, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) label_1CA0: // Incoming jump from 0x1C9F, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @1CA3 memory[0x00:0x00] } 1CA0 60 PUSH1 0x00 1CA2 80 DUP1 1CA3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CA3 revert(memory[0x00:0x00]); } // Block terminates label_1CA4: // Incoming jump from 0x1C9F, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x01) // Inputs[1] { @1CAA stack[-2] } 1CA4 5B JUMPDEST 1CA5 60 PUSH1 0x01 1CA7 61 PUSH2 0x1caf 1CAA 83 DUP4 1CAB 61 PUSH2 0x1860 1CAE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CA5 stack[0] = 0x01 // @1CA7 stack[1] = 0x1caf // @1CAA stack[2] = stack[-2] // } // Block ends with call to 0x1860, returns to 0x1CAF label_1CAF: // Incoming return from call to 0x1860 at 0x1CAE // Inputs[2] // { // @1CB0 stack[-2] // @1CB0 stack[-1] // } 1CAF 5B JUMPDEST 1CB0 11 GT 1CB1 15 ISZERO 1CB2 15 ISZERO 1CB3 61 PUSH2 0x1cbb 1CB6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1cbb, if !!(stack[-1] > stack[-2]) label_1CB7: // Incoming jump from 0x1CB6, if not !!(stack[-1] > stack[-2]) // Inputs[1] { @1CBA memory[0x00:0x00] } 1CB7 60 PUSH1 0x00 1CB9 80 DUP1 1CBA FD *REVERT // Stack delta = +0 // Outputs[1] { @1CBA revert(memory[0x00:0x00]); } // Block terminates label_1CBB: // Incoming jump from 0x1CB6, if !!(stack[-1] > stack[-2]) // Inputs[4] // { // @1CC2 stack[-2] // @1CFC memory[0x00:0x40] // @1D03 stack[-1] // @1D05 stack[-3] // } 1CBB 5B JUMPDEST 1CBC 60 PUSH1 0x01 1CBE 60 PUSH1 0x06 1CC0 60 PUSH1 0x00 1CC2 84 DUP5 1CC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CD8 16 AND 1CD9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CEE 16 AND 1CEF 81 DUP2 1CF0 52 MSTORE 1CF1 60 PUSH1 0x20 1CF3 01 ADD 1CF4 90 SWAP1 1CF5 81 DUP2 1CF6 52 MSTORE 1CF7 60 PUSH1 0x20 1CF9 01 ADD 1CFA 60 PUSH1 0x00 1CFC 20 SHA3 1CFD 81 DUP2 1CFE 90 SWAP1 1CFF 55 SSTORE 1D00 50 POP 1D01 60 PUSH1 0x01 1D03 90 SWAP1 1D04 50 POP 1D05 91 SWAP2 1D06 90 SWAP1 1D07 50 POP 1D08 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1CF0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1CF6 memory[0x20:0x40] = 0x06 // @1CFF storage[keccak256(memory[0x00:0x40])] = 0x01 // @1D05 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_1D09: // Incoming jump from 0x0AE0 // Inputs[6] // { // @1D10 stack[-2] // @1D4A memory[0x00:0x40] // @1D4D stack[-1] // @1D87 memory[0x00:0x40] // @1D88 storage[keccak256(memory[0x00:0x40])] // @1D8B stack[-3] // } 1D09 5B JUMPDEST 1D0A 60 PUSH1 0x00 1D0C 60 PUSH1 0x01 1D0E 60 PUSH1 0x00 1D10 84 DUP5 1D11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D26 16 AND 1D27 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D3C 16 AND 1D3D 81 DUP2 1D3E 52 MSTORE 1D3F 60 PUSH1 0x20 1D41 01 ADD 1D42 90 SWAP1 1D43 81 DUP2 1D44 52 MSTORE 1D45 60 PUSH1 0x20 1D47 01 ADD 1D48 60 PUSH1 0x00 1D4A 20 SHA3 1D4B 60 PUSH1 0x00 1D4D 83 DUP4 1D4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D63 16 AND 1D64 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D79 16 AND 1D7A 81 DUP2 1D7B 52 MSTORE 1D7C 60 PUSH1 0x20 1D7E 01 ADD 1D7F 90 SWAP1 1D80 81 DUP2 1D81 52 MSTORE 1D82 60 PUSH1 0x20 1D84 01 ADD 1D85 60 PUSH1 0x00 1D87 20 SHA3 1D88 54 SLOAD 1D89 90 SWAP1 1D8A 50 POP 1D8B 92 SWAP3 1D8C 91 SWAP2 1D8D 50 POP 1D8E 50 POP 1D8F 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1D3E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1D44 memory[0x20:0x40] = 0x01 // @1D7B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1D81 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1D8B stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1D90: // Incoming jump from 0x105B // Incoming jump from 0x0CFA // Incoming jump from 0x1B89 // Incoming call from 0x0BC5, returns to 0x0BC6 // Inputs[1] { @1DA9 stack[-2] } 1D90 5B JUMPDEST 1D91 60 PUSH1 0x00 1D93 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DA8 16 AND 1DA9 82 DUP3 1DAA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DBF 16 AND 1DC0 14 EQ 1DC1 15 ISZERO 1DC2 15 ISZERO 1DC3 15 ISZERO 1DC4 61 PUSH2 0x1dcc 1DC7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1dcc, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1DC8: // Incoming jump from 0x1DC7, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1DCB memory[0x00:0x00] } 1DC8 60 PUSH1 0x00 1DCA 80 DUP1 1DCB FD *REVERT // Stack delta = +0 // Outputs[1] { @1DCB revert(memory[0x00:0x00]); } // Block terminates label_1DCC: // Incoming jump from 0x1DC7, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1DE5 stack[-3] } 1DCC 5B JUMPDEST 1DCD 60 PUSH1 0x00 1DCF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DE4 16 AND 1DE5 83 DUP4 1DE6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DFB 16 AND 1DFC 14 EQ 1DFD 15 ISZERO 1DFE 15 ISZERO 1DFF 15 ISZERO 1E00 61 PUSH2 0x1e08 1E03 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e08, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1E04: // Incoming jump from 0x1E03, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1E07 memory[0x00:0x00] } 1E04 60 PUSH1 0x00 1E06 80 DUP1 1E07 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E07 revert(memory[0x00:0x00]); } // Block terminates label_1E08: // Incoming jump from 0x1E03, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[9] // { // @1E09 stack[-1] // @1E0E stack[-3] // @1E48 memory[0x00:0x40] // @1E4B stack[-2] // @1E85 memory[0x00:0x40] // @1EDC memory[0x40:0x60] // @1EE9 memory[0x40:0x60] // @1EEE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1EF2 stack[-4] // } 1E08 5B JUMPDEST 1E09 80 DUP1 1E0A 60 PUSH1 0x01 1E0C 60 PUSH1 0x00 1E0E 85 DUP6 1E0F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E24 16 AND 1E25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E3A 16 AND 1E3B 81 DUP2 1E3C 52 MSTORE 1E3D 60 PUSH1 0x20 1E3F 01 ADD 1E40 90 SWAP1 1E41 81 DUP2 1E42 52 MSTORE 1E43 60 PUSH1 0x20 1E45 01 ADD 1E46 60 PUSH1 0x00 1E48 20 SHA3 1E49 60 PUSH1 0x00 1E4B 84 DUP5 1E4C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E61 16 AND 1E62 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E77 16 AND 1E78 81 DUP2 1E79 52 MSTORE 1E7A 60 PUSH1 0x20 1E7C 01 ADD 1E7D 90 SWAP1 1E7E 81 DUP2 1E7F 52 MSTORE 1E80 60 PUSH1 0x20 1E82 01 ADD 1E83 60 PUSH1 0x00 1E85 20 SHA3 1E86 81 DUP2 1E87 90 SWAP1 1E88 55 SSTORE 1E89 50 POP 1E8A 81 DUP2 1E8B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EA0 16 AND 1EA1 83 DUP4 1EA2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EB7 16 AND 1EB8 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1ED9 83 DUP4 1EDA 60 PUSH1 0x40 1EDC 51 MLOAD 1EDD 80 DUP1 1EDE 82 DUP3 1EDF 81 DUP2 1EE0 52 MSTORE 1EE1 60 PUSH1 0x20 1EE3 01 ADD 1EE4 91 SWAP2 1EE5 50 POP 1EE6 50 POP 1EE7 60 PUSH1 0x40 1EE9 51 MLOAD 1EEA 80 DUP1 1EEB 91 SWAP2 1EEC 03 SUB 1EED 90 SWAP1 1EEE A3 LOG3 1EEF 50 POP 1EF0 50 POP 1EF1 50 POP 1EF2 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @1E3C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1E42 memory[0x20:0x40] = 0x01 // @1E79 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1E7F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1E88 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1EE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1EEE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_1EF3: // Incoming call from 0x1BC0, returns to 0x1BC1 // Incoming call from 0x0C61, returns to 0x0C62 // Inputs[1] { @1F0C stack[-2] } 1EF3 5B JUMPDEST 1EF4 60 PUSH1 0x00 1EF6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F0B 16 AND 1F0C 82 DUP3 1F0D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F22 16 AND 1F23 14 EQ 1F24 15 ISZERO 1F25 15 ISZERO 1F26 15 ISZERO 1F27 61 PUSH2 0x1f2f 1F2A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f2f, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1F2B: // Incoming jump from 0x1F2A, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1F2E memory[0x00:0x00] } 1F2B 60 PUSH1 0x00 1F2D 80 DUP1 1F2E FD *REVERT // Stack delta = +0 // Outputs[1] { @1F2E revert(memory[0x00:0x00]); } // Block terminates label_1F2F: // Incoming jump from 0x1F2A, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @1F33 stack[-1] // @1F37 stack[-3] // @1F71 memory[0x00:0x40] // @1F72 storage[keccak256(memory[0x00:0x40])] // } 1F2F 5B JUMPDEST 1F30 61 PUSH2 0x1f80 1F33 81 DUP2 1F34 60 PUSH1 0x00 1F36 80 DUP1 1F37 86 DUP7 1F38 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F4D 16 AND 1F4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F63 16 AND 1F64 81 DUP2 1F65 52 MSTORE 1F66 60 PUSH1 0x20 1F68 01 ADD 1F69 90 SWAP1 1F6A 81 DUP2 1F6B 52 MSTORE 1F6C 60 PUSH1 0x20 1F6E 01 ADD 1F6F 60 PUSH1 0x00 1F71 20 SHA3 1F72 54 SLOAD 1F73 61 PUSH2 0x20bf 1F76 90 SWAP1 1F77 91 SWAP2 1F78 90 SWAP1 1F79 63 PUSH4 0xffffffff 1F7E 16 AND 1F7F 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1F30 stack[0] = 0x1f80 // @1F65 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1F6B memory[0x20:0x40] = 0x00 // @1F77 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1F78 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x20bf, returns to 0x1F80 label_1F80: // Incoming return from call to 0x20BF at 0x1F7F // Inputs[7] // { // @1F84 stack[-4] // @1FBE memory[0x00:0x40] // @1FBF stack[-1] // @1FC6 stack[-2] // @1FCA stack[-3] // @2004 memory[0x00:0x40] // @2005 storage[keccak256(memory[0x00:0x40])] // } 1F80 5B JUMPDEST 1F81 60 PUSH1 0x00 1F83 80 DUP1 1F84 85 DUP6 1F85 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F9A 16 AND 1F9B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FB0 16 AND 1FB1 81 DUP2 1FB2 52 MSTORE 1FB3 60 PUSH1 0x20 1FB5 01 ADD 1FB6 90 SWAP1 1FB7 81 DUP2 1FB8 52 MSTORE 1FB9 60 PUSH1 0x20 1FBB 01 ADD 1FBC 60 PUSH1 0x00 1FBE 20 SHA3 1FBF 81 DUP2 1FC0 90 SWAP1 1FC1 55 SSTORE 1FC2 50 POP 1FC3 61 PUSH2 0x2013 1FC6 81 DUP2 1FC7 60 PUSH1 0x00 1FC9 80 DUP1 1FCA 85 DUP6 1FCB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FE0 16 AND 1FE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FF6 16 AND 1FF7 81 DUP2 1FF8 52 MSTORE 1FF9 60 PUSH1 0x20 1FFB 01 ADD 1FFC 90 SWAP1 1FFD 81 DUP2 1FFE 52 MSTORE 1FFF 60 PUSH1 0x20 2001 01 ADD 2002 60 PUSH1 0x00 2004 20 SHA3 2005 54 SLOAD 2006 61 PUSH2 0x20e1 2009 90 SWAP1 200A 91 SWAP2 200B 90 SWAP1 200C 63 PUSH4 0xffffffff 2011 16 AND 2012 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1FB2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1FB8 memory[0x20:0x40] = 0x00 // @1FC1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1FC3 stack[-1] = 0x2013 // @1FF8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1FFE memory[0x20:0x40] = 0x00 // @200A stack[0] = storage[keccak256(memory[0x00:0x40])] // @200B stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x20e1, returns to 0x2013 label_2013: // Incoming return from call to 0x20E1 at 0x2012 // Inputs[9] // { // @2017 stack[-3] // @2051 memory[0x00:0x40] // @2052 stack[-1] // @206D stack[-4] // @20A5 stack[-2] // @20A8 memory[0x40:0x60] // @20B5 memory[0x40:0x60] // @20BA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @20BE stack[-5] // } 2013 5B JUMPDEST 2014 60 PUSH1 0x00 2016 80 DUP1 2017 84 DUP5 2018 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 202D 16 AND 202E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2043 16 AND 2044 81 DUP2 2045 52 MSTORE 2046 60 PUSH1 0x20 2048 01 ADD 2049 90 SWAP1 204A 81 DUP2 204B 52 MSTORE 204C 60 PUSH1 0x20 204E 01 ADD 204F 60 PUSH1 0x00 2051 20 SHA3 2052 81 DUP2 2053 90 SWAP1 2054 55 SSTORE 2055 50 POP 2056 81 DUP2 2057 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 206C 16 AND 206D 83 DUP4 206E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2083 16 AND 2084 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 20A5 83 DUP4 20A6 60 PUSH1 0x40 20A8 51 MLOAD 20A9 80 DUP1 20AA 82 DUP3 20AB 81 DUP2 20AC 52 MSTORE 20AD 60 PUSH1 0x20 20AF 01 ADD 20B0 91 SWAP2 20B1 50 POP 20B2 50 POP 20B3 60 PUSH1 0x40 20B5 51 MLOAD 20B6 80 DUP1 20B7 91 SWAP2 20B8 03 SUB 20B9 90 SWAP1 20BA A3 LOG3 20BB 50 POP 20BC 50 POP 20BD 50 POP 20BE 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @2045 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @204B memory[0x20:0x40] = 0x00 // @2054 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @20AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @20BA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-5] label_20BF: // Incoming call from 0x0E56, returns to 0x0E57 // Incoming call from 0x1B84, returns to 0x1B85 // Incoming call from 0x0E56, returns to 0x0E57 // Incoming call from 0x1F7F, returns to 0x1F80 // Incoming call from 0x0CF5, returns to 0x0CF6 // Inputs[2] // { // @20C2 stack[-2] // @20C3 stack[-1] // } 20BF 5B JUMPDEST 20C0 60 PUSH1 0x00 20C2 82 DUP3 20C3 82 DUP3 20C4 11 GT 20C5 15 ISZERO 20C6 15 ISZERO 20C7 15 ISZERO 20C8 61 PUSH2 0x20d0 20CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20C0 stack[0] = 0x00 } // Block ends with conditional jump to 0x20d0, if !!!(stack[-1] > stack[-2]) label_20CC: // Incoming jump from 0x20CB, if not !!!(stack[-1] > stack[-2]) // Inputs[1] { @20CF memory[0x00:0x00] } 20CC 60 PUSH1 0x00 20CE 80 DUP1 20CF FD *REVERT // Stack delta = +0 // Outputs[1] { @20CF revert(memory[0x00:0x00]); } // Block terminates label_20D0: // Incoming jump from 0x20CB, if !!!(stack[-1] > stack[-2]) // Inputs[4] // { // @20D3 stack[-2] // @20D4 stack[-3] // @20D9 stack[-1] // @20DC stack[-4] // } 20D0 5B JUMPDEST 20D1 60 PUSH1 0x00 20D3 82 DUP3 20D4 84 DUP5 20D5 03 SUB 20D6 90 SWAP1 20D7 50 POP 20D8 80 DUP1 20D9 91 SWAP2 20DA 50 POP 20DB 50 POP 20DC 92 SWAP3 20DD 91 SWAP2 20DE 50 POP 20DF 50 POP 20E0 56 *JUMP // Stack delta = -3 // Outputs[1] { @20DC stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_20E1: // Incoming call from 0x1056, returns to 0x1057 // Incoming call from 0x1249, returns to 0x124A // Incoming call from 0x2012, returns to 0x2013 // Inputs[2] // { // @20E5 stack[-1] // @20E6 stack[-2] // } 20E1 5B JUMPDEST 20E2 60 PUSH1 0x00 20E4 80 DUP1 20E5 82 DUP3 20E6 84 DUP5 20E7 01 ADD 20E8 90 SWAP1 20E9 50 POP 20EA 83 DUP4 20EB 81 DUP2 20EC 10 LT 20ED 15 ISZERO 20EE 15 ISZERO 20EF 15 ISZERO 20F0 61 PUSH2 0x20f8 20F3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20E2 stack[0] = 0x00 // @20E8 stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x20f8, if !!!(stack[-2] + stack[-1] < stack[-2]) label_20F4: // Incoming jump from 0x20F3, if not !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @20F7 memory[0x00:0x00] } 20F4 60 PUSH1 0x00 20F6 80 DUP1 20F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F7 revert(memory[0x00:0x00]); } // Block terminates label_20F8: // Incoming jump from 0x20F3, if !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @20F9 stack[-1] // @20FA stack[-2] // @20FD stack[-5] // @20FE stack[-4] // } 20F8 5B JUMPDEST 20F9 80 DUP1 20FA 91 SWAP2 20FB 50 POP 20FC 50 POP 20FD 92 SWAP3 20FE 91 SWAP2 20FF 50 POP 2100 50 POP 2101 56 *JUMP // Stack delta = -4 // Outputs[1] { @20FD stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2102: // Incoming call from 0x0EA0, returns to 0x0EA1 // Incoming call from 0x1346, returns to 0x1347 // Incoming call from 0x11BE, returns to 0x11BF // Inputs[2] // { // @2107 memory[0x40:0x60] // @2138 stack[-1] // } 2102 5B JUMPDEST 2103 60 PUSH1 0x60 2105 60 PUSH1 0x40 2107 51 MLOAD 2108 90 SWAP1 2109 81 DUP2 210A 01 ADD 210B 60 PUSH1 0x40 210D 52 MSTORE 210E 80 DUP1 210F 60 PUSH1 0x00 2111 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2126 16 AND 2127 81 DUP2 2128 52 MSTORE 2129 60 PUSH1 0x20 212B 01 ADD 212C 60 PUSH1 0x00 212E 81 DUP2 212F 52 MSTORE 2130 60 PUSH1 0x20 2132 01 ADD 2133 60 PUSH1 0x00 2135 81 DUP2 2136 52 MSTORE 2137 50 POP 2138 90 SWAP1 2139 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @210D memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @2128 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @212F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @2136 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @2138 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] 213A FE *ASSERT 213B A1 LOG1 213C 65 PUSH6 0x627a7a723058 2143 20 SHA3 2144 03 SUB 2145 33 CALLER 2146 3F EXTCODEHASH 2147 8A DUP11 2148 AD AD 2149 CC CC 214A 44 DIFFICULTY 214B 35 CALLDATALOAD 214C 74 PUSH21 0x7bf03c2b39d08f8cea4a778a9e67cb72ce6b7ec60b 2162 7A PUSH27 0xcf0029