Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x00fc 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x00fc, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 63 PUSH4 0xffffffff 0035 16 AND 0036 80 DUP1 0037 63 PUSH4 0x06fdde03 003C 14 EQ 003D 61 PUSH2 0x0101 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0101, if 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x095ea7b3 0047 14 EQ 0048 61 PUSH2 0x0191 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0191, if 0x095ea7b3 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x18160ddd 0052 14 EQ 0053 61 PUSH2 0x01f6 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f6, if 0x18160ddd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x18160ddd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x23b872dd 005D 14 EQ 005E 61 PUSH2 0x0221 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0221, if 0x23b872dd == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x23b872dd == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x313ce567 0068 14 EQ 0069 61 PUSH2 0x02a6 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a6, if 0x313ce567 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x313ce567 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0x32ab0acb 0073 14 EQ 0074 61 PUSH2 0x02d7 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d7, if 0x32ab0acb == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0x32ab0acb == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0x39509351 007E 14 EQ 007F 61 PUSH2 0x0326 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0326, if 0x39509351 == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0x39509351 == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0x56e7b94b 0089 14 EQ 008A 61 PUSH2 0x038b 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038b, if 0x56e7b94b == stack[-1] label_008E: // Incoming jump from 0x008D, if not 0x56e7b94b == stack[-1] // Inputs[1] { @008E stack[-1] } 008E 80 DUP1 008F 63 PUSH4 0x6c59caf3 0094 14 EQ 0095 61 PUSH2 0x03f8 0098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f8, if 0x6c59caf3 == stack[-1] label_0099: // Incoming jump from 0x0098, if not 0x6c59caf3 == stack[-1] // Inputs[1] { @0099 stack[-1] } 0099 80 DUP1 009A 63 PUSH4 0x70a08231 009F 14 EQ 00A0 61 PUSH2 0x0439 00A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0439, if 0x70a08231 == stack[-1] label_00A4: // Incoming jump from 0x00A3, if not 0x70a08231 == stack[-1] // Inputs[1] { @00A4 stack[-1] } 00A4 80 DUP1 00A5 63 PUSH4 0x9511500d 00AA 14 EQ 00AB 61 PUSH2 0x0490 00AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0490, if 0x9511500d == stack[-1] label_00AF: // Incoming jump from 0x00AE, if not 0x9511500d == stack[-1] // Inputs[1] { @00AF stack[-1] } 00AF 80 DUP1 00B0 63 PUSH4 0x95d89b41 00B5 14 EQ 00B6 61 PUSH2 0x04e7 00B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e7, if 0x95d89b41 == stack[-1] label_00BA: // Incoming jump from 0x00B9, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00BA stack[-1] } 00BA 80 DUP1 00BB 63 PUSH4 0xa457c2d7 00C0 14 EQ 00C1 61 PUSH2 0x0577 00C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0577, if 0xa457c2d7 == stack[-1] label_00C5: // Incoming jump from 0x00C4, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @00C5 stack[-1] } 00C5 80 DUP1 00C6 63 PUSH4 0xa9059cbb 00CB 14 EQ 00CC 61 PUSH2 0x05dc 00CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05dc, if 0xa9059cbb == stack[-1] label_00D0: // Incoming jump from 0x00CF, if not 0xa9059cbb == stack[-1] // Inputs[1] { @00D0 stack[-1] } 00D0 80 DUP1 00D1 63 PUSH4 0xac3a41da 00D6 14 EQ 00D7 61 PUSH2 0x0641 00DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0641, if 0xac3a41da == stack[-1] label_00DB: // Incoming jump from 0x00DA, if not 0xac3a41da == stack[-1] // Inputs[1] { @00DB stack[-1] } 00DB 80 DUP1 00DC 63 PUSH4 0xb74d9fdf 00E1 14 EQ 00E2 61 PUSH2 0x06ae 00E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ae, if 0xb74d9fdf == stack[-1] label_00E6: // Incoming jump from 0x00E5, if not 0xb74d9fdf == stack[-1] // Inputs[1] { @00E6 stack[-1] } 00E6 80 DUP1 00E7 63 PUSH4 0xdd62ed3e 00EC 14 EQ 00ED 61 PUSH2 0x06ef 00F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ef, if 0xdd62ed3e == stack[-1] label_00F1: // Incoming jump from 0x00F0, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @00F1 stack[-1] } 00F1 80 DUP1 00F2 63 PUSH4 0xdec94c3f 00F7 14 EQ 00F8 61 PUSH2 0x0766 00FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0766, if 0xdec94c3f == stack[-1] label_00FC: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x00FB, if not 0xdec94c3f == stack[-1] // Inputs[1] { @0100 memory[0x00:0x00] } 00FC 5B JUMPDEST 00FD 60 PUSH1 0x00 00FF 80 DUP1 0100 FD *REVERT // Stack delta = +0 // Outputs[1] { @0100 revert(memory[0x00:0x00]); } // Block terminates label_0101: // Incoming jump from 0x0040, if 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0102 msg.value } 0101 5B JUMPDEST 0102 34 CALLVALUE 0103 80 DUP1 0104 15 ISZERO 0105 61 PUSH2 0x010d 0108 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0102 stack[0] = msg.value } // Block ends with conditional jump to 0x010d, if !msg.value label_0109: // Incoming jump from 0x0108, if not !msg.value // Inputs[1] { @010C memory[0x00:0x00] } 0109 60 PUSH1 0x00 010B 80 DUP1 010C FD *REVERT // Stack delta = +0 // Outputs[1] { @010C revert(memory[0x00:0x00]); } // Block terminates label_010D: // Incoming jump from 0x0108, if !msg.value 010D 5B JUMPDEST 010E 50 POP 010F 61 PUSH2 0x0116 0112 61 PUSH2 0x07d3 0115 56 *JUMP // Stack delta = +0 // Outputs[1] { @010F stack[-1] = 0x0116 } // Block ends with call to 0x07d3, returns to 0x0116 label_0116: // Incoming return from call to 0x07D3 at 0x0115 // Inputs[4] // { // @0119 memory[0x40:0x60] // @0124 stack[-1] // @0127 memory[stack[-1]:stack[-1] + 0x20] // @0130 memory[stack[-1]:stack[-1] + 0x20] // } 0116 5B JUMPDEST 0117 60 PUSH1 0x40 0119 51 MLOAD 011A 80 DUP1 011B 80 DUP1 011C 60 PUSH1 0x20 011E 01 ADD 011F 82 DUP3 0120 81 DUP2 0121 03 SUB 0122 82 DUP3 0123 52 MSTORE 0124 83 DUP4 0125 81 DUP2 0126 81 DUP2 0127 51 MLOAD 0128 81 DUP2 0129 52 MSTORE 012A 60 PUSH1 0x20 012C 01 ADD 012D 91 SWAP2 012E 50 POP 012F 80 DUP1 0130 51 MLOAD 0131 90 SWAP1 0132 60 PUSH1 0x20 0134 01 ADD 0135 90 SWAP1 0136 80 DUP1 0137 83 DUP4 0138 83 DUP4 0139 60 PUSH1 0x00 013B 5B JUMPDEST 013C 83 DUP4 013D 81 DUP2 013E 10 LT 013F 15 ISZERO 0140 61 PUSH2 0x0156 0143 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0119 stack[0] = memory[0x40:0x60] // @011A stack[1] = memory[0x40:0x60] // @0123 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0129 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @012D stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0135 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0135 stack[3] = 0x20 + stack[-1] // @0136 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0137 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0138 stack[7] = 0x20 + stack[-1] // @0139 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0156, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0144: // Incoming jump from 0x0143, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0143, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0144 stack[-1] // @0145 stack[-2] // @0147 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0149 stack[-3] // } 0144 80 DUP1 0145 82 DUP3 0146 01 ADD 0147 51 MLOAD 0148 81 DUP2 0149 84 DUP5 014A 01 ADD 014B 52 MSTORE 014C 60 PUSH1 0x20 014E 81 DUP2 014F 01 ADD 0150 90 SWAP1 0151 50 POP 0152 61 PUSH2 0x013b 0155 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @014B memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0150 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x013b label_0156: // Incoming jump from 0x0143, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0143, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @015B stack[-5] // @015B stack[-6] // @015D stack[-7] // } 0156 5B JUMPDEST 0157 50 POP 0158 50 POP 0159 50 POP 015A 50 POP 015B 90 SWAP1 015C 50 POP 015D 90 SWAP1 015E 81 DUP2 015F 01 ADD 0160 90 SWAP1 0161 60 PUSH1 0x1f 0163 16 AND 0164 80 DUP1 0165 15 ISZERO 0166 61 PUSH2 0x0183 0169 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0160 stack[-7] = stack[-5] + stack[-7] // @0163 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0183, if !(0x1f & stack[-5]) label_016A: // Incoming jump from 0x0169, if not !(0x1f & stack[-5]) // Inputs[6] // { // @016A stack[-1] // @016B stack[-2] // @016E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0185 stack[-5] // @018B memory[0x40:0x60] // @0190 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 016A 80 DUP1 016B 82 DUP3 016C 03 SUB 016D 80 DUP1 016E 51 MLOAD 016F 60 PUSH1 0x01 0171 83 DUP4 0172 60 PUSH1 0x20 0174 03 SUB 0175 61 PUSH2 0x0100 0178 0A EXP 0179 03 SUB 017A 19 NOT 017B 16 AND 017C 81 DUP2 017D 52 MSTORE 017E 60 PUSH1 0x20 0180 01 ADD 0181 91 SWAP2 0182 50 POP 0183 5B JUMPDEST 0184 50 POP 0185 92 SWAP3 0186 50 POP 0187 50 POP 0188 50 POP 0189 60 PUSH1 0x40 018B 51 MLOAD 018C 80 DUP1 018D 91 SWAP2 018E 03 SUB 018F 90 SWAP1 0190 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @017D 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] // @0190 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0191: // Incoming jump from 0x004B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0192 msg.value } 0191 5B JUMPDEST 0192 34 CALLVALUE 0193 80 DUP1 0194 15 ISZERO 0195 61 PUSH2 0x019d 0198 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0192 stack[0] = msg.value } // Block ends with conditional jump to 0x019d, if !msg.value label_0199: // Incoming jump from 0x0198, if not !msg.value // Inputs[1] { @019C memory[0x00:0x00] } 0199 60 PUSH1 0x00 019B 80 DUP1 019C FD *REVERT // Stack delta = +0 // Outputs[1] { @019C revert(memory[0x00:0x00]); } // Block terminates label_019D: // Incoming jump from 0x0198, if !msg.value // Inputs[3] // { // @01A5 msg.data.length // @01AC msg.data[0x04:0x24] // @01CC msg.data[0x24:0x44] // } 019D 5B JUMPDEST 019E 50 POP 019F 61 PUSH2 0x01dc 01A2 60 PUSH1 0x04 01A4 80 DUP1 01A5 36 CALLDATASIZE 01A6 03 SUB 01A7 81 DUP2 01A8 01 ADD 01A9 90 SWAP1 01AA 80 DUP1 01AB 80 DUP1 01AC 35 CALLDATALOAD 01AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01C2 16 AND 01C3 90 SWAP1 01C4 60 PUSH1 0x20 01C6 01 ADD 01C7 90 SWAP1 01C8 92 SWAP3 01C9 91 SWAP2 01CA 90 SWAP1 01CB 80 DUP1 01CC 35 CALLDATALOAD 01CD 90 SWAP1 01CE 60 PUSH1 0x20 01D0 01 ADD 01D1 90 SWAP1 01D2 92 SWAP3 01D3 91 SWAP2 01D4 90 SWAP1 01D5 50 POP 01D6 50 POP 01D7 50 POP 01D8 61 PUSH2 0x0875 01DB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @019F stack[-1] = 0x01dc // @01C8 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @01D2 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0875, returns to 0x01DC label_01DC: // Incoming return from call to 0x0875 at 0x01DB // Inputs[4] // { // @01DF memory[0x40:0x60] // @01E1 stack[-1] // @01F0 memory[0x40:0x60] // @01F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01DC 5B JUMPDEST 01DD 60 PUSH1 0x40 01DF 51 MLOAD 01E0 80 DUP1 01E1 82 DUP3 01E2 15 ISZERO 01E3 15 ISZERO 01E4 15 ISZERO 01E5 15 ISZERO 01E6 81 DUP2 01E7 52 MSTORE 01E8 60 PUSH1 0x20 01EA 01 ADD 01EB 91 SWAP2 01EC 50 POP 01ED 50 POP 01EE 60 PUSH1 0x40 01F0 51 MLOAD 01F1 80 DUP1 01F2 91 SWAP2 01F3 03 SUB 01F4 90 SWAP1 01F5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @01F5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01F6: // Incoming jump from 0x0056, if 0x18160ddd == stack[-1] // Inputs[1] { @01F7 msg.value } 01F6 5B JUMPDEST 01F7 34 CALLVALUE 01F8 80 DUP1 01F9 15 ISZERO 01FA 61 PUSH2 0x0202 01FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F7 stack[0] = msg.value } // Block ends with conditional jump to 0x0202, if !msg.value label_01FE: // Incoming jump from 0x01FD, if not !msg.value // Inputs[1] { @0201 memory[0x00:0x00] } 01FE 60 PUSH1 0x00 0200 80 DUP1 0201 FD *REVERT // Stack delta = +0 // Outputs[1] { @0201 revert(memory[0x00:0x00]); } // Block terminates label_0202: // Incoming jump from 0x01FD, if !msg.value 0202 5B JUMPDEST 0203 50 POP 0204 61 PUSH2 0x020b 0207 61 PUSH2 0x09a2 020A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0204 stack[-1] = 0x020b } // Block ends with call to 0x09a2, returns to 0x020B label_020B: // Incoming return from call to 0x09A2 at 0x020A // Inputs[4] // { // @020E memory[0x40:0x60] // @0210 stack[-1] // @021B memory[0x40:0x60] // @0220 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 020B 5B JUMPDEST 020C 60 PUSH1 0x40 020E 51 MLOAD 020F 80 DUP1 0210 82 DUP3 0211 81 DUP2 0212 52 MSTORE 0213 60 PUSH1 0x20 0215 01 ADD 0216 91 SWAP2 0217 50 POP 0218 50 POP 0219 60 PUSH1 0x40 021B 51 MLOAD 021C 80 DUP1 021D 91 SWAP2 021E 03 SUB 021F 90 SWAP1 0220 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0212 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0220 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0221: // Incoming jump from 0x0061, if 0x23b872dd == stack[-1] // Inputs[1] { @0222 msg.value } 0221 5B JUMPDEST 0222 34 CALLVALUE 0223 80 DUP1 0224 15 ISZERO 0225 61 PUSH2 0x022d 0228 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0222 stack[0] = msg.value } // Block ends with conditional jump to 0x022d, if !msg.value label_0229: // Incoming jump from 0x0228, if not !msg.value // Inputs[1] { @022C memory[0x00:0x00] } 0229 60 PUSH1 0x00 022B 80 DUP1 022C FD *REVERT // Stack delta = +0 // Outputs[1] { @022C revert(memory[0x00:0x00]); } // Block terminates label_022D: // Incoming jump from 0x0228, if !msg.value // Inputs[4] // { // @0235 msg.data.length // @023C msg.data[0x04:0x24] // @025C msg.data[0x24:0x44] // @027C msg.data[0x44:0x64] // } 022D 5B JUMPDEST 022E 50 POP 022F 61 PUSH2 0x028c 0232 60 PUSH1 0x04 0234 80 DUP1 0235 36 CALLDATASIZE 0236 03 SUB 0237 81 DUP2 0238 01 ADD 0239 90 SWAP1 023A 80 DUP1 023B 80 DUP1 023C 35 CALLDATALOAD 023D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0252 16 AND 0253 90 SWAP1 0254 60 PUSH1 0x20 0256 01 ADD 0257 90 SWAP1 0258 92 SWAP3 0259 91 SWAP2 025A 90 SWAP1 025B 80 DUP1 025C 35 CALLDATALOAD 025D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0272 16 AND 0273 90 SWAP1 0274 60 PUSH1 0x20 0276 01 ADD 0277 90 SWAP1 0278 92 SWAP3 0279 91 SWAP2 027A 90 SWAP1 027B 80 DUP1 027C 35 CALLDATALOAD 027D 90 SWAP1 027E 60 PUSH1 0x20 0280 01 ADD 0281 90 SWAP1 0282 92 SWAP3 0283 91 SWAP2 0284 90 SWAP1 0285 50 POP 0286 50 POP 0287 50 POP 0288 61 PUSH2 0x09ac 028B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @022F stack[-1] = 0x028c // @0258 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0278 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // @0282 stack[2] = msg.data[0x44:0x64] // } // Block ends with call to 0x09ac, returns to 0x028C label_028C: // Incoming return from call to 0x09AC at 0x028B // Inputs[4] // { // @028F memory[0x40:0x60] // @0291 stack[-1] // @02A0 memory[0x40:0x60] // @02A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 028C 5B JUMPDEST 028D 60 PUSH1 0x40 028F 51 MLOAD 0290 80 DUP1 0291 82 DUP3 0292 15 ISZERO 0293 15 ISZERO 0294 15 ISZERO 0295 15 ISZERO 0296 81 DUP2 0297 52 MSTORE 0298 60 PUSH1 0x20 029A 01 ADD 029B 91 SWAP2 029C 50 POP 029D 50 POP 029E 60 PUSH1 0x40 02A0 51 MLOAD 02A1 80 DUP1 02A2 91 SWAP2 02A3 03 SUB 02A4 90 SWAP1 02A5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0297 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @02A5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02A6: // Incoming jump from 0x006C, if 0x313ce567 == stack[-1] // Inputs[1] { @02A7 msg.value } 02A6 5B JUMPDEST 02A7 34 CALLVALUE 02A8 80 DUP1 02A9 15 ISZERO 02AA 61 PUSH2 0x02b2 02AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A7 stack[0] = msg.value } // Block ends with conditional jump to 0x02b2, if !msg.value label_02AE: // Incoming jump from 0x02AD, if not !msg.value // Inputs[1] { @02B1 memory[0x00:0x00] } 02AE 60 PUSH1 0x00 02B0 80 DUP1 02B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B1 revert(memory[0x00:0x00]); } // Block terminates label_02B2: // Incoming jump from 0x02AD, if !msg.value 02B2 5B JUMPDEST 02B3 50 POP 02B4 61 PUSH2 0x02bb 02B7 61 PUSH2 0x0e5d 02BA 56 *JUMP // Stack delta = +0 // Outputs[1] { @02B4 stack[-1] = 0x02bb } // Block ends with call to 0x0e5d, returns to 0x02BB label_02BB: // Incoming return from call to 0x0E5D at 0x02BA // Inputs[4] // { // @02BE memory[0x40:0x60] // @02C0 stack[-1] // @02D1 memory[0x40:0x60] // @02D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02BB 5B JUMPDEST 02BC 60 PUSH1 0x40 02BE 51 MLOAD 02BF 80 DUP1 02C0 82 DUP3 02C1 60 PUSH1 0xff 02C3 16 AND 02C4 60 PUSH1 0xff 02C6 16 AND 02C7 81 DUP2 02C8 52 MSTORE 02C9 60 PUSH1 0x20 02CB 01 ADD 02CC 91 SWAP2 02CD 50 POP 02CE 50 POP 02CF 60 PUSH1 0x40 02D1 51 MLOAD 02D2 80 DUP1 02D3 91 SWAP2 02D4 03 SUB 02D5 90 SWAP1 02D6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @02D6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02D7: // Incoming jump from 0x0077, if 0x32ab0acb == stack[-1] // Inputs[1] { @02D8 msg.value } 02D7 5B JUMPDEST 02D8 34 CALLVALUE 02D9 80 DUP1 02DA 15 ISZERO 02DB 61 PUSH2 0x02e3 02DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02D8 stack[0] = msg.value } // Block ends with conditional jump to 0x02e3, if !msg.value label_02DF: // Incoming jump from 0x02DE, if not !msg.value // Inputs[1] { @02E2 memory[0x00:0x00] } 02DF 60 PUSH1 0x00 02E1 80 DUP1 02E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E2 revert(memory[0x00:0x00]); } // Block terminates label_02E3: // Incoming jump from 0x02DE, if !msg.value // Inputs[3] // { // @02EB msg.data.length // @02F2 msg.data[0x04:0x24] // @02FC msg.data[0x24:0x44] // } 02E3 5B JUMPDEST 02E4 50 POP 02E5 61 PUSH2 0x030c 02E8 60 PUSH1 0x04 02EA 80 DUP1 02EB 36 CALLDATASIZE 02EC 03 SUB 02ED 81 DUP2 02EE 01 ADD 02EF 90 SWAP1 02F0 80 DUP1 02F1 80 DUP1 02F2 35 CALLDATALOAD 02F3 90 SWAP1 02F4 60 PUSH1 0x20 02F6 01 ADD 02F7 90 SWAP1 02F8 92 SWAP3 02F9 91 SWAP2 02FA 90 SWAP1 02FB 80 DUP1 02FC 35 CALLDATALOAD 02FD 90 SWAP1 02FE 60 PUSH1 0x20 0300 01 ADD 0301 90 SWAP1 0302 92 SWAP3 0303 91 SWAP2 0304 90 SWAP1 0305 50 POP 0306 50 POP 0307 50 POP 0308 61 PUSH2 0x0e74 030B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02E5 stack[-1] = 0x030c // @02F8 stack[0] = msg.data[0x04:0x24] // @0302 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0e74, returns to 0x030C label_030C: // Incoming return from call to 0x0E74 at 0x030B // Inputs[4] // { // @030F memory[0x40:0x60] // @0311 stack[-1] // @0320 memory[0x40:0x60] // @0325 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 030C 5B JUMPDEST 030D 60 PUSH1 0x40 030F 51 MLOAD 0310 80 DUP1 0311 82 DUP3 0312 15 ISZERO 0313 15 ISZERO 0314 15 ISZERO 0315 15 ISZERO 0316 81 DUP2 0317 52 MSTORE 0318 60 PUSH1 0x20 031A 01 ADD 031B 91 SWAP2 031C 50 POP 031D 50 POP 031E 60 PUSH1 0x40 0320 51 MLOAD 0321 80 DUP1 0322 91 SWAP2 0323 03 SUB 0324 90 SWAP1 0325 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0317 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0325 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0326: // Incoming jump from 0x0082, if 0x39509351 == stack[-1] // Inputs[1] { @0327 msg.value } 0326 5B JUMPDEST 0327 34 CALLVALUE 0328 80 DUP1 0329 15 ISZERO 032A 61 PUSH2 0x0332 032D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0327 stack[0] = msg.value } // Block ends with conditional jump to 0x0332, if !msg.value label_032E: // Incoming jump from 0x032D, if not !msg.value // Inputs[1] { @0331 memory[0x00:0x00] } 032E 60 PUSH1 0x00 0330 80 DUP1 0331 FD *REVERT // Stack delta = +0 // Outputs[1] { @0331 revert(memory[0x00:0x00]); } // Block terminates label_0332: // Incoming jump from 0x032D, if !msg.value // Inputs[3] // { // @033A msg.data.length // @0341 msg.data[0x04:0x24] // @0361 msg.data[0x24:0x44] // } 0332 5B JUMPDEST 0333 50 POP 0334 61 PUSH2 0x0371 0337 60 PUSH1 0x04 0339 80 DUP1 033A 36 CALLDATASIZE 033B 03 SUB 033C 81 DUP2 033D 01 ADD 033E 90 SWAP1 033F 80 DUP1 0340 80 DUP1 0341 35 CALLDATALOAD 0342 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0357 16 AND 0358 90 SWAP1 0359 60 PUSH1 0x20 035B 01 ADD 035C 90 SWAP1 035D 92 SWAP3 035E 91 SWAP2 035F 90 SWAP1 0360 80 DUP1 0361 35 CALLDATALOAD 0362 90 SWAP1 0363 60 PUSH1 0x20 0365 01 ADD 0366 90 SWAP1 0367 92 SWAP3 0368 91 SWAP2 0369 90 SWAP1 036A 50 POP 036B 50 POP 036C 50 POP 036D 61 PUSH2 0x155b 0370 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0334 stack[-1] = 0x0371 // @035D stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0367 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x155b, returns to 0x0371 label_0371: // Incoming return from call to 0x155B at 0x0370 // Inputs[4] // { // @0374 memory[0x40:0x60] // @0376 stack[-1] // @0385 memory[0x40:0x60] // @038A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0371 5B JUMPDEST 0372 60 PUSH1 0x40 0374 51 MLOAD 0375 80 DUP1 0376 82 DUP3 0377 15 ISZERO 0378 15 ISZERO 0379 15 ISZERO 037A 15 ISZERO 037B 81 DUP2 037C 52 MSTORE 037D 60 PUSH1 0x20 037F 01 ADD 0380 91 SWAP2 0381 50 POP 0382 50 POP 0383 60 PUSH1 0x40 0385 51 MLOAD 0386 80 DUP1 0387 91 SWAP2 0388 03 SUB 0389 90 SWAP1 038A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @037C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @038A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_038B: // Incoming jump from 0x008D, if 0x56e7b94b == stack[-1] // Inputs[1] { @038C msg.value } 038B 5B JUMPDEST 038C 34 CALLVALUE 038D 80 DUP1 038E 15 ISZERO 038F 61 PUSH2 0x0397 0392 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038C stack[0] = msg.value } // Block ends with conditional jump to 0x0397, if !msg.value label_0393: // Incoming jump from 0x0392, if not !msg.value // Inputs[1] { @0396 memory[0x00:0x00] } 0393 60 PUSH1 0x00 0395 80 DUP1 0396 FD *REVERT // Stack delta = +0 // Outputs[1] { @0396 revert(memory[0x00:0x00]); } // Block terminates label_0397: // Incoming jump from 0x0392, if !msg.value // Inputs[2] // { // @039F msg.data.length // @03A6 msg.data[0x04:0x24] // } 0397 5B JUMPDEST 0398 50 POP 0399 61 PUSH2 0x03b6 039C 60 PUSH1 0x04 039E 80 DUP1 039F 36 CALLDATASIZE 03A0 03 SUB 03A1 81 DUP2 03A2 01 ADD 03A3 90 SWAP1 03A4 80 DUP1 03A5 80 DUP1 03A6 35 CALLDATALOAD 03A7 90 SWAP1 03A8 60 PUSH1 0x20 03AA 01 ADD 03AB 90 SWAP1 03AC 92 SWAP3 03AD 91 SWAP2 03AE 90 SWAP1 03AF 50 POP 03B0 50 POP 03B1 50 POP 03B2 61 PUSH2 0x1792 03B5 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0399 stack[-1] = 0x03b6 // @03AC stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x1792, returns to 0x03B6 label_03B6: // Incoming return from call to 0x1792 at 0x03B5 // Inputs[4] // { // @03B9 memory[0x40:0x60] // @03BB stack[-1] // @03F2 memory[0x40:0x60] // @03F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03B6 5B JUMPDEST 03B7 60 PUSH1 0x40 03B9 51 MLOAD 03BA 80 DUP1 03BB 82 DUP3 03BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03D1 16 AND 03D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03E7 16 AND 03E8 81 DUP2 03E9 52 MSTORE 03EA 60 PUSH1 0x20 03EC 01 ADD 03ED 91 SWAP2 03EE 50 POP 03EF 50 POP 03F0 60 PUSH1 0x40 03F2 51 MLOAD 03F3 80 DUP1 03F4 91 SWAP2 03F5 03 SUB 03F6 90 SWAP1 03F7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @03F7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03F8: // Incoming jump from 0x0098, if 0x6c59caf3 == stack[-1] // Inputs[1] { @03F9 msg.value } 03F8 5B JUMPDEST 03F9 34 CALLVALUE 03FA 80 DUP1 03FB 15 ISZERO 03FC 61 PUSH2 0x0404 03FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0404, if !msg.value label_0400: // Incoming jump from 0x03FF, if not !msg.value // Inputs[1] { @0403 memory[0x00:0x00] } 0400 60 PUSH1 0x00 0402 80 DUP1 0403 FD *REVERT // Stack delta = +0 // Outputs[1] { @0403 revert(memory[0x00:0x00]); } // Block terminates label_0404: // Incoming jump from 0x03FF, if !msg.value // Inputs[2] // { // @040C msg.data.length // @0413 msg.data[0x04:0x24] // } 0404 5B JUMPDEST 0405 50 POP 0406 61 PUSH2 0x0423 0409 60 PUSH1 0x04 040B 80 DUP1 040C 36 CALLDATASIZE 040D 03 SUB 040E 81 DUP2 040F 01 ADD 0410 90 SWAP1 0411 80 DUP1 0412 80 DUP1 0413 35 CALLDATALOAD 0414 90 SWAP1 0415 60 PUSH1 0x20 0417 01 ADD 0418 90 SWAP1 0419 92 SWAP3 041A 91 SWAP2 041B 90 SWAP1 041C 50 POP 041D 50 POP 041E 50 POP 041F 61 PUSH2 0x17cf 0422 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0406 stack[-1] = 0x0423 // @0419 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x17cf, returns to 0x0423 label_0423: // Incoming return from call to 0x17CF at 0x0422 // Incoming return from call to 0x17CF at 0x0422 // Inputs[4] // { // @0426 memory[0x40:0x60] // @0428 stack[-1] // @0433 memory[0x40:0x60] // @0438 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0423 5B JUMPDEST 0424 60 PUSH1 0x40 0426 51 MLOAD 0427 80 DUP1 0428 82 DUP3 0429 81 DUP2 042A 52 MSTORE 042B 60 PUSH1 0x20 042D 01 ADD 042E 91 SWAP2 042F 50 POP 0430 50 POP 0431 60 PUSH1 0x40 0433 51 MLOAD 0434 80 DUP1 0435 91 SWAP2 0436 03 SUB 0437 90 SWAP1 0438 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @042A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0438 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0439: // Incoming jump from 0x00A3, if 0x70a08231 == stack[-1] // Inputs[1] { @043A msg.value } 0439 5B JUMPDEST 043A 34 CALLVALUE 043B 80 DUP1 043C 15 ISZERO 043D 61 PUSH2 0x0445 0440 57 *JUMPI // Stack delta = +1 // Outputs[1] { @043A stack[0] = msg.value } // Block ends with conditional jump to 0x0445, if !msg.value label_0441: // Incoming jump from 0x0440, if not !msg.value // Inputs[1] { @0444 memory[0x00:0x00] } 0441 60 PUSH1 0x00 0443 80 DUP1 0444 FD *REVERT // Stack delta = +0 // Outputs[1] { @0444 revert(memory[0x00:0x00]); } // Block terminates label_0445: // Incoming jump from 0x0440, if !msg.value // Inputs[2] // { // @044D msg.data.length // @0454 msg.data[0x04:0x24] // } 0445 5B JUMPDEST 0446 50 POP 0447 61 PUSH2 0x047a 044A 60 PUSH1 0x04 044C 80 DUP1 044D 36 CALLDATASIZE 044E 03 SUB 044F 81 DUP2 0450 01 ADD 0451 90 SWAP1 0452 80 DUP1 0453 80 DUP1 0454 35 CALLDATALOAD 0455 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 046A 16 AND 046B 90 SWAP1 046C 60 PUSH1 0x20 046E 01 ADD 046F 90 SWAP1 0470 92 SWAP3 0471 91 SWAP2 0472 90 SWAP1 0473 50 POP 0474 50 POP 0475 50 POP 0476 61 PUSH2 0x1843 0479 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0447 stack[-1] = 0x047a // @0470 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x1843, returns to 0x047A label_047A: // Incoming return from call to 0x1843 at 0x0479 // Inputs[4] // { // @047D memory[0x40:0x60] // @047F stack[-1] // @048A memory[0x40:0x60] // @048F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 047A 5B JUMPDEST 047B 60 PUSH1 0x40 047D 51 MLOAD 047E 80 DUP1 047F 82 DUP3 0480 81 DUP2 0481 52 MSTORE 0482 60 PUSH1 0x20 0484 01 ADD 0485 91 SWAP2 0486 50 POP 0487 50 POP 0488 60 PUSH1 0x40 048A 51 MLOAD 048B 80 DUP1 048C 91 SWAP2 048D 03 SUB 048E 90 SWAP1 048F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0481 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @048F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0490: // Incoming jump from 0x00AE, if 0x9511500d == stack[-1] // Inputs[1] { @0491 msg.value } 0490 5B JUMPDEST 0491 34 CALLVALUE 0492 80 DUP1 0493 15 ISZERO 0494 61 PUSH2 0x049c 0497 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0491 stack[0] = msg.value } // Block ends with conditional jump to 0x049c, if !msg.value label_0498: // Incoming jump from 0x0497, if not !msg.value // Inputs[1] { @049B memory[0x00:0x00] } 0498 60 PUSH1 0x00 049A 80 DUP1 049B FD *REVERT // Stack delta = +0 // Outputs[1] { @049B revert(memory[0x00:0x00]); } // Block terminates label_049C: // Incoming jump from 0x0497, if !msg.value // Inputs[2] // { // @04A4 msg.data.length // @04AB msg.data[0x04:0x24] // } 049C 5B JUMPDEST 049D 50 POP 049E 61 PUSH2 0x04d1 04A1 60 PUSH1 0x04 04A3 80 DUP1 04A4 36 CALLDATASIZE 04A5 03 SUB 04A6 81 DUP2 04A7 01 ADD 04A8 90 SWAP1 04A9 80 DUP1 04AA 80 DUP1 04AB 35 CALLDATALOAD 04AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C1 16 AND 04C2 90 SWAP1 04C3 60 PUSH1 0x20 04C5 01 ADD 04C6 90 SWAP1 04C7 92 SWAP3 04C8 91 SWAP2 04C9 90 SWAP1 04CA 50 POP 04CB 50 POP 04CC 50 POP 04CD 61 PUSH2 0x188c 04D0 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @049E stack[-1] = 0x04d1 // @04C7 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x188c, returns to 0x04D1 label_04D1: // Incoming return from call to 0x188C at 0x04D0 // Inputs[4] // { // @04D4 memory[0x40:0x60] // @04D6 stack[-1] // @04E1 memory[0x40:0x60] // @04E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04D1 5B JUMPDEST 04D2 60 PUSH1 0x40 04D4 51 MLOAD 04D5 80 DUP1 04D6 82 DUP3 04D7 81 DUP2 04D8 52 MSTORE 04D9 60 PUSH1 0x20 04DB 01 ADD 04DC 91 SWAP2 04DD 50 POP 04DE 50 POP 04DF 60 PUSH1 0x40 04E1 51 MLOAD 04E2 80 DUP1 04E3 91 SWAP2 04E4 03 SUB 04E5 90 SWAP1 04E6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04E6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04E7: // Incoming jump from 0x00B9, if 0x95d89b41 == stack[-1] // Inputs[1] { @04E8 msg.value } 04E7 5B JUMPDEST 04E8 34 CALLVALUE 04E9 80 DUP1 04EA 15 ISZERO 04EB 61 PUSH2 0x04f3 04EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E8 stack[0] = msg.value } // Block ends with conditional jump to 0x04f3, if !msg.value label_04EF: // Incoming jump from 0x04EE, if not !msg.value // Inputs[1] { @04F2 memory[0x00:0x00] } 04EF 60 PUSH1 0x00 04F1 80 DUP1 04F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F2 revert(memory[0x00:0x00]); } // Block terminates label_04F3: // Incoming jump from 0x04EE, if !msg.value 04F3 5B JUMPDEST 04F4 50 POP 04F5 61 PUSH2 0x04fc 04F8 61 PUSH2 0x18d5 04FB 56 *JUMP // Stack delta = +0 // Outputs[1] { @04F5 stack[-1] = 0x04fc } // Block ends with call to 0x18d5, returns to 0x04FC label_04FC: // Incoming return from call to 0x18D5 at 0x04FB // Inputs[4] // { // @04FF memory[0x40:0x60] // @050A stack[-1] // @050D memory[stack[-1]:stack[-1] + 0x20] // @0516 memory[stack[-1]:stack[-1] + 0x20] // } 04FC 5B JUMPDEST 04FD 60 PUSH1 0x40 04FF 51 MLOAD 0500 80 DUP1 0501 80 DUP1 0502 60 PUSH1 0x20 0504 01 ADD 0505 82 DUP3 0506 81 DUP2 0507 03 SUB 0508 82 DUP3 0509 52 MSTORE 050A 83 DUP4 050B 81 DUP2 050C 81 DUP2 050D 51 MLOAD 050E 81 DUP2 050F 52 MSTORE 0510 60 PUSH1 0x20 0512 01 ADD 0513 91 SWAP2 0514 50 POP 0515 80 DUP1 0516 51 MLOAD 0517 90 SWAP1 0518 60 PUSH1 0x20 051A 01 ADD 051B 90 SWAP1 051C 80 DUP1 051D 83 DUP4 051E 83 DUP4 051F 60 PUSH1 0x00 0521 5B JUMPDEST 0522 83 DUP4 0523 81 DUP2 0524 10 LT 0525 15 ISZERO 0526 61 PUSH2 0x053c 0529 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @04FF stack[0] = memory[0x40:0x60] // @0500 stack[1] = memory[0x40:0x60] // @0509 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @050F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0513 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @051B stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @051B stack[3] = 0x20 + stack[-1] // @051C stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @051D stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @051E stack[7] = 0x20 + stack[-1] // @051F stack[8] = 0x00 // } // Block ends with conditional jump to 0x053c, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_052A: // Incoming jump from 0x0529, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0529, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @052A stack[-1] // @052B stack[-2] // @052D memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @052F stack[-3] // } 052A 80 DUP1 052B 82 DUP3 052C 01 ADD 052D 51 MLOAD 052E 81 DUP2 052F 84 DUP5 0530 01 ADD 0531 52 MSTORE 0532 60 PUSH1 0x20 0534 81 DUP2 0535 01 ADD 0536 90 SWAP1 0537 50 POP 0538 61 PUSH2 0x0521 053B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0531 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0536 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0521 label_053C: // Incoming jump from 0x0529, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0529, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0541 stack[-6] // @0541 stack[-5] // @0543 stack[-7] // } 053C 5B JUMPDEST 053D 50 POP 053E 50 POP 053F 50 POP 0540 50 POP 0541 90 SWAP1 0542 50 POP 0543 90 SWAP1 0544 81 DUP2 0545 01 ADD 0546 90 SWAP1 0547 60 PUSH1 0x1f 0549 16 AND 054A 80 DUP1 054B 15 ISZERO 054C 61 PUSH2 0x0569 054F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0546 stack[-7] = stack[-5] + stack[-7] // @0549 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0569, if !(0x1f & stack[-5]) label_0550: // Incoming jump from 0x054F, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0550 stack[-1] // @0551 stack[-2] // @0554 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @056B stack[-5] // @0571 memory[0x40:0x60] // @0576 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0550 80 DUP1 0551 82 DUP3 0552 03 SUB 0553 80 DUP1 0554 51 MLOAD 0555 60 PUSH1 0x01 0557 83 DUP4 0558 60 PUSH1 0x20 055A 03 SUB 055B 61 PUSH2 0x0100 055E 0A EXP 055F 03 SUB 0560 19 NOT 0561 16 AND 0562 81 DUP2 0563 52 MSTORE 0564 60 PUSH1 0x20 0566 01 ADD 0567 91 SWAP2 0568 50 POP 0569 5B JUMPDEST 056A 50 POP 056B 92 SWAP3 056C 50 POP 056D 50 POP 056E 50 POP 056F 60 PUSH1 0x40 0571 51 MLOAD 0572 80 DUP1 0573 91 SWAP2 0574 03 SUB 0575 90 SWAP1 0576 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0563 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] // @0576 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0577: // Incoming jump from 0x00C4, if 0xa457c2d7 == stack[-1] // Inputs[1] { @0578 msg.value } 0577 5B JUMPDEST 0578 34 CALLVALUE 0579 80 DUP1 057A 15 ISZERO 057B 61 PUSH2 0x0583 057E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0578 stack[0] = msg.value } // Block ends with conditional jump to 0x0583, if !msg.value label_057F: // Incoming jump from 0x057E, if not !msg.value // Inputs[1] { @0582 memory[0x00:0x00] } 057F 60 PUSH1 0x00 0581 80 DUP1 0582 FD *REVERT // Stack delta = +0 // Outputs[1] { @0582 revert(memory[0x00:0x00]); } // Block terminates label_0583: // Incoming jump from 0x057E, if !msg.value // Inputs[3] // { // @058B msg.data.length // @0592 msg.data[0x04:0x24] // @05B2 msg.data[0x24:0x44] // } 0583 5B JUMPDEST 0584 50 POP 0585 61 PUSH2 0x05c2 0588 60 PUSH1 0x04 058A 80 DUP1 058B 36 CALLDATASIZE 058C 03 SUB 058D 81 DUP2 058E 01 ADD 058F 90 SWAP1 0590 80 DUP1 0591 80 DUP1 0592 35 CALLDATALOAD 0593 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05A8 16 AND 05A9 90 SWAP1 05AA 60 PUSH1 0x20 05AC 01 ADD 05AD 90 SWAP1 05AE 92 SWAP3 05AF 91 SWAP2 05B0 90 SWAP1 05B1 80 DUP1 05B2 35 CALLDATALOAD 05B3 90 SWAP1 05B4 60 PUSH1 0x20 05B6 01 ADD 05B7 90 SWAP1 05B8 92 SWAP3 05B9 91 SWAP2 05BA 90 SWAP1 05BB 50 POP 05BC 50 POP 05BD 50 POP 05BE 61 PUSH2 0x1977 05C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0585 stack[-1] = 0x05c2 // @05AE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @05B8 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x1977, returns to 0x05C2 label_05C2: // Incoming return from call to 0x1977 at 0x05C1 // Inputs[4] // { // @05C5 memory[0x40:0x60] // @05C7 stack[-1] // @05D6 memory[0x40:0x60] // @05DB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05C2 5B JUMPDEST 05C3 60 PUSH1 0x40 05C5 51 MLOAD 05C6 80 DUP1 05C7 82 DUP3 05C8 15 ISZERO 05C9 15 ISZERO 05CA 15 ISZERO 05CB 15 ISZERO 05CC 81 DUP2 05CD 52 MSTORE 05CE 60 PUSH1 0x20 05D0 01 ADD 05D1 91 SWAP2 05D2 50 POP 05D3 50 POP 05D4 60 PUSH1 0x40 05D6 51 MLOAD 05D7 80 DUP1 05D8 91 SWAP2 05D9 03 SUB 05DA 90 SWAP1 05DB F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @05DB return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05DC: // Incoming jump from 0x00CF, if 0xa9059cbb == stack[-1] // Inputs[1] { @05DD msg.value } 05DC 5B JUMPDEST 05DD 34 CALLVALUE 05DE 80 DUP1 05DF 15 ISZERO 05E0 61 PUSH2 0x05e8 05E3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05DD stack[0] = msg.value } // Block ends with conditional jump to 0x05e8, if !msg.value label_05E4: // Incoming jump from 0x05E3, if not !msg.value // Inputs[1] { @05E7 memory[0x00:0x00] } 05E4 60 PUSH1 0x00 05E6 80 DUP1 05E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E7 revert(memory[0x00:0x00]); } // Block terminates label_05E8: // Incoming jump from 0x05E3, if !msg.value // Inputs[3] // { // @05F0 msg.data.length // @05F7 msg.data[0x04:0x24] // @0617 msg.data[0x24:0x44] // } 05E8 5B JUMPDEST 05E9 50 POP 05EA 61 PUSH2 0x0627 05ED 60 PUSH1 0x04 05EF 80 DUP1 05F0 36 CALLDATASIZE 05F1 03 SUB 05F2 81 DUP2 05F3 01 ADD 05F4 90 SWAP1 05F5 80 DUP1 05F6 80 DUP1 05F7 35 CALLDATALOAD 05F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 060D 16 AND 060E 90 SWAP1 060F 60 PUSH1 0x20 0611 01 ADD 0612 90 SWAP1 0613 92 SWAP3 0614 91 SWAP2 0615 90 SWAP1 0616 80 DUP1 0617 35 CALLDATALOAD 0618 90 SWAP1 0619 60 PUSH1 0x20 061B 01 ADD 061C 90 SWAP1 061D 92 SWAP3 061E 91 SWAP2 061F 90 SWAP1 0620 50 POP 0621 50 POP 0622 50 POP 0623 61 PUSH2 0x1bae 0626 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05EA stack[-1] = 0x0627 // @0613 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @061D stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x1bae, returns to 0x0627 label_0627: // Incoming return from call to 0x1BAE at 0x0626 // Incoming return from call to 0x1BAE at 0x0626 // Inputs[4] // { // @062A memory[0x40:0x60] // @062C stack[-1] // @063B memory[0x40:0x60] // @0640 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0627 5B JUMPDEST 0628 60 PUSH1 0x40 062A 51 MLOAD 062B 80 DUP1 062C 82 DUP3 062D 15 ISZERO 062E 15 ISZERO 062F 15 ISZERO 0630 15 ISZERO 0631 81 DUP2 0632 52 MSTORE 0633 60 PUSH1 0x20 0635 01 ADD 0636 91 SWAP2 0637 50 POP 0638 50 POP 0639 60 PUSH1 0x40 063B 51 MLOAD 063C 80 DUP1 063D 91 SWAP2 063E 03 SUB 063F 90 SWAP1 0640 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0632 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0640 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0641: // Incoming jump from 0x00DA, if 0xac3a41da == stack[-1] // Inputs[1] { @0642 msg.value } 0641 5B JUMPDEST 0642 34 CALLVALUE 0643 80 DUP1 0644 15 ISZERO 0645 61 PUSH2 0x064d 0648 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0642 stack[0] = msg.value } // Block ends with conditional jump to 0x064d, if !msg.value label_0649: // Incoming jump from 0x0648, if not !msg.value // Inputs[1] { @064C memory[0x00:0x00] } 0649 60 PUSH1 0x00 064B 80 DUP1 064C FD *REVERT // Stack delta = +0 // Outputs[1] { @064C revert(memory[0x00:0x00]); } // Block terminates label_064D: // Incoming jump from 0x0648, if !msg.value // Inputs[2] // { // @0655 msg.data.length // @065C msg.data[0x04:0x24] // } 064D 5B JUMPDEST 064E 50 POP 064F 61 PUSH2 0x066c 0652 60 PUSH1 0x04 0654 80 DUP1 0655 36 CALLDATASIZE 0656 03 SUB 0657 81 DUP2 0658 01 ADD 0659 90 SWAP1 065A 80 DUP1 065B 80 DUP1 065C 35 CALLDATALOAD 065D 90 SWAP1 065E 60 PUSH1 0x20 0660 01 ADD 0661 90 SWAP1 0662 92 SWAP3 0663 91 SWAP2 0664 90 SWAP1 0665 50 POP 0666 50 POP 0667 50 POP 0668 61 PUSH2 0x2a0e 066B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @064F stack[-1] = 0x066c // @0662 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x2a0e, returns to 0x066C label_066C: // Incoming return from call to 0x2A0E at 0x066B // Inputs[4] // { // @066F memory[0x40:0x60] // @0671 stack[-1] // @06A8 memory[0x40:0x60] // @06AD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 066C 5B JUMPDEST 066D 60 PUSH1 0x40 066F 51 MLOAD 0670 80 DUP1 0671 82 DUP3 0672 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0687 16 AND 0688 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 069D 16 AND 069E 81 DUP2 069F 52 MSTORE 06A0 60 PUSH1 0x20 06A2 01 ADD 06A3 91 SWAP2 06A4 50 POP 06A5 50 POP 06A6 60 PUSH1 0x40 06A8 51 MLOAD 06A9 80 DUP1 06AA 91 SWAP2 06AB 03 SUB 06AC 90 SWAP1 06AD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @069F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @06AD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06AE: // Incoming jump from 0x00E5, if 0xb74d9fdf == stack[-1] // Inputs[1] { @06AF msg.value } 06AE 5B JUMPDEST 06AF 34 CALLVALUE 06B0 80 DUP1 06B1 15 ISZERO 06B2 61 PUSH2 0x06ba 06B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06AF stack[0] = msg.value } // Block ends with conditional jump to 0x06ba, if !msg.value label_06B6: // Incoming jump from 0x06B5, if not !msg.value // Inputs[1] { @06B9 memory[0x00:0x00] } 06B6 60 PUSH1 0x00 06B8 80 DUP1 06B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B9 revert(memory[0x00:0x00]); } // Block terminates label_06BA: // Incoming jump from 0x06B5, if !msg.value // Inputs[2] // { // @06C2 msg.data.length // @06C9 msg.data[0x04:0x24] // } 06BA 5B JUMPDEST 06BB 50 POP 06BC 61 PUSH2 0x06d9 06BF 60 PUSH1 0x04 06C1 80 DUP1 06C2 36 CALLDATASIZE 06C3 03 SUB 06C4 81 DUP2 06C5 01 ADD 06C6 90 SWAP1 06C7 80 DUP1 06C8 80 DUP1 06C9 35 CALLDATALOAD 06CA 90 SWAP1 06CB 60 PUSH1 0x20 06CD 01 ADD 06CE 90 SWAP1 06CF 92 SWAP3 06D0 91 SWAP2 06D1 90 SWAP1 06D2 50 POP 06D3 50 POP 06D4 50 POP 06D5 61 PUSH2 0x2c16 06D8 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06BC stack[-1] = 0x06d9 // @06CF stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x2c16, returns to 0x06D9 label_06D9: // Incoming return from call to 0x2C16 at 0x06D8 // Inputs[4] // { // @06DC memory[0x40:0x60] // @06DE stack[-1] // @06E9 memory[0x40:0x60] // @06EE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06D9 5B JUMPDEST 06DA 60 PUSH1 0x40 06DC 51 MLOAD 06DD 80 DUP1 06DE 82 DUP3 06DF 81 DUP2 06E0 52 MSTORE 06E1 60 PUSH1 0x20 06E3 01 ADD 06E4 91 SWAP2 06E5 50 POP 06E6 50 POP 06E7 60 PUSH1 0x40 06E9 51 MLOAD 06EA 80 DUP1 06EB 91 SWAP2 06EC 03 SUB 06ED 90 SWAP1 06EE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @06E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06EE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06EF: // Incoming jump from 0x00F0, if 0xdd62ed3e == stack[-1] // Inputs[1] { @06F0 msg.value } 06EF 5B JUMPDEST 06F0 34 CALLVALUE 06F1 80 DUP1 06F2 15 ISZERO 06F3 61 PUSH2 0x06fb 06F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06F0 stack[0] = msg.value } // Block ends with conditional jump to 0x06fb, if !msg.value label_06F7: // Incoming jump from 0x06F6, if not !msg.value // Inputs[1] { @06FA memory[0x00:0x00] } 06F7 60 PUSH1 0x00 06F9 80 DUP1 06FA FD *REVERT // Stack delta = +0 // Outputs[1] { @06FA revert(memory[0x00:0x00]); } // Block terminates label_06FB: // Incoming jump from 0x06F6, if !msg.value // Inputs[3] // { // @0703 msg.data.length // @070A msg.data[0x04:0x24] // @072A msg.data[0x24:0x44] // } 06FB 5B JUMPDEST 06FC 50 POP 06FD 61 PUSH2 0x0750 0700 60 PUSH1 0x04 0702 80 DUP1 0703 36 CALLDATASIZE 0704 03 SUB 0705 81 DUP2 0706 01 ADD 0707 90 SWAP1 0708 80 DUP1 0709 80 DUP1 070A 35 CALLDATALOAD 070B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0720 16 AND 0721 90 SWAP1 0722 60 PUSH1 0x20 0724 01 ADD 0725 90 SWAP1 0726 92 SWAP3 0727 91 SWAP2 0728 90 SWAP1 0729 80 DUP1 072A 35 CALLDATALOAD 072B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0740 16 AND 0741 90 SWAP1 0742 60 PUSH1 0x20 0744 01 ADD 0745 90 SWAP1 0746 92 SWAP3 0747 91 SWAP2 0748 90 SWAP1 0749 50 POP 074A 50 POP 074B 50 POP 074C 61 PUSH2 0x2d71 074F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06FD stack[-1] = 0x0750 // @0726 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0746 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // } // Block ends with call to 0x2d71, returns to 0x0750 label_0750: // Incoming return from call to 0x2D71 at 0x074F // Inputs[4] // { // @0753 memory[0x40:0x60] // @0755 stack[-1] // @0760 memory[0x40:0x60] // @0765 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0750 5B JUMPDEST 0751 60 PUSH1 0x40 0753 51 MLOAD 0754 80 DUP1 0755 82 DUP3 0756 81 DUP2 0757 52 MSTORE 0758 60 PUSH1 0x20 075A 01 ADD 075B 91 SWAP2 075C 50 POP 075D 50 POP 075E 60 PUSH1 0x40 0760 51 MLOAD 0761 80 DUP1 0762 91 SWAP2 0763 03 SUB 0764 90 SWAP1 0765 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0757 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0765 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0766: // Incoming jump from 0x00FB, if 0xdec94c3f == stack[-1] // Inputs[1] { @0767 msg.value } 0766 5B JUMPDEST 0767 34 CALLVALUE 0768 80 DUP1 0769 15 ISZERO 076A 61 PUSH2 0x0772 076D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0767 stack[0] = msg.value } // Block ends with conditional jump to 0x0772, if !msg.value label_076E: // Incoming jump from 0x076D, if not !msg.value // Inputs[1] { @0771 memory[0x00:0x00] } 076E 60 PUSH1 0x00 0770 80 DUP1 0771 FD *REVERT // Stack delta = +0 // Outputs[1] { @0771 revert(memory[0x00:0x00]); } // Block terminates label_0772: // Incoming jump from 0x076D, if !msg.value // Inputs[2] // { // @077A msg.data.length // @0781 msg.data[0x04:0x24] // } 0772 5B JUMPDEST 0773 50 POP 0774 61 PUSH2 0x0791 0777 60 PUSH1 0x04 0779 80 DUP1 077A 36 CALLDATASIZE 077B 03 SUB 077C 81 DUP2 077D 01 ADD 077E 90 SWAP1 077F 80 DUP1 0780 80 DUP1 0781 35 CALLDATALOAD 0782 90 SWAP1 0783 60 PUSH1 0x20 0785 01 ADD 0786 90 SWAP1 0787 92 SWAP3 0788 91 SWAP2 0789 90 SWAP1 078A 50 POP 078B 50 POP 078C 50 POP 078D 61 PUSH2 0x2df8 0790 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0774 stack[-1] = 0x0791 // @0787 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x2df8, returns to 0x0791 label_0791: // Incoming return from call to 0x2DF8 at 0x0790 // Inputs[4] // { // @0794 memory[0x40:0x60] // @0796 stack[-1] // @07CD memory[0x40:0x60] // @07D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0791 5B JUMPDEST 0792 60 PUSH1 0x40 0794 51 MLOAD 0795 80 DUP1 0796 82 DUP3 0797 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07AC 16 AND 07AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C2 16 AND 07C3 81 DUP2 07C4 52 MSTORE 07C5 60 PUSH1 0x20 07C7 01 ADD 07C8 91 SWAP2 07C9 50 POP 07CA 50 POP 07CB 60 PUSH1 0x40 07CD 51 MLOAD 07CE 80 DUP1 07CF 91 SWAP2 07D0 03 SUB 07D1 90 SWAP1 07D2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @07C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @07D2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_07D3: // Incoming call from 0x0115, returns to 0x0116 // Inputs[3] // { // @07D9 storage[0x00] // @07FA memory[0x40:0x60] // @080D storage[0x00] // } 07D3 5B JUMPDEST 07D4 60 PUSH1 0x60 07D6 60 PUSH1 0x00 07D8 80 DUP1 07D9 54 SLOAD 07DA 60 PUSH1 0x01 07DC 81 DUP2 07DD 60 PUSH1 0x01 07DF 16 AND 07E0 15 ISZERO 07E1 61 PUSH2 0x0100 07E4 02 MUL 07E5 03 SUB 07E6 16 AND 07E7 60 PUSH1 0x02 07E9 90 SWAP1 07EA 04 DIV 07EB 80 DUP1 07EC 60 PUSH1 0x1f 07EE 01 ADD 07EF 60 PUSH1 0x20 07F1 80 DUP1 07F2 91 SWAP2 07F3 04 DIV 07F4 02 MUL 07F5 60 PUSH1 0x20 07F7 01 ADD 07F8 60 PUSH1 0x40 07FA 51 MLOAD 07FB 90 SWAP1 07FC 81 DUP2 07FD 01 ADD 07FE 60 PUSH1 0x40 0800 52 MSTORE 0801 80 DUP1 0802 92 SWAP3 0803 91 SWAP2 0804 90 SWAP1 0805 81 DUP2 0806 81 DUP2 0807 52 MSTORE 0808 60 PUSH1 0x20 080A 01 ADD 080B 82 DUP3 080C 80 DUP1 080D 54 SLOAD 080E 60 PUSH1 0x01 0810 81 DUP2 0811 60 PUSH1 0x01 0813 16 AND 0814 15 ISZERO 0815 61 PUSH2 0x0100 0818 02 MUL 0819 03 SUB 081A 16 AND 081B 60 PUSH1 0x02 081D 90 SWAP1 081E 04 DIV 081F 80 DUP1 0820 15 ISZERO 0821 61 PUSH2 0x086b 0824 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @07D4 stack[0] = 0x60 // @0800 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) / 0x20 * 0x20 // @0802 stack[1] = memory[0x40:0x60] // @0803 stack[2] = 0x00 // @0804 stack[3] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @0807 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @080A stack[4] = 0x20 + memory[0x40:0x60] // @080B stack[5] = 0x00 // @081E stack[6] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // } // Block ends with conditional jump to 0x086b, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) label_0825: // Incoming jump from 0x0824, if not !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Inputs[1] { @0825 stack[-1] } 0825 80 DUP1 0826 60 PUSH1 0x1f 0828 10 LT 0829 61 PUSH2 0x0840 082C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0840, if 0x1f < stack[-1] label_082D: // Incoming jump from 0x082C, if not 0x1f < stack[-1] // Inputs[4] // { // @0831 stack[-2] // @0832 storage[stack[-2]] // @0835 stack[-3] // @0837 stack[-1] // } 082D 61 PUSH2 0x0100 0830 80 DUP1 0831 83 DUP4 0832 54 SLOAD 0833 04 DIV 0834 02 MUL 0835 83 DUP4 0836 52 MSTORE 0837 91 SWAP2 0838 60 PUSH1 0x20 083A 01 ADD 083B 91 SWAP2 083C 61 PUSH2 0x086b 083F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0836 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @083B stack[-1] = stack[-1] // @083B stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x086b label_0840: // Incoming jump from 0x082C, if 0x1f < stack[-1] // Inputs[5] // { // @0841 stack[-3] // @0842 stack[-1] // @0844 stack[-2] // @084C memory[0x00:0x20] // @0850 storage[keccak256(memory[0x00:0x20])] // } 0840 5B JUMPDEST 0841 82 DUP3 0842 01 ADD 0843 91 SWAP2 0844 90 SWAP1 0845 60 PUSH1 0x00 0847 52 MSTORE 0848 60 PUSH1 0x20 084A 60 PUSH1 0x00 084C 20 SHA3 084D 90 SWAP1 084E 5B JUMPDEST 084F 81 DUP2 0850 54 SLOAD 0851 81 DUP2 0852 52 MSTORE 0853 90 SWAP1 0854 60 PUSH1 0x01 0856 01 ADD 0857 90 SWAP1 0858 60 PUSH1 0x20 085A 01 ADD 085B 80 DUP1 085C 83 DUP4 085D 11 GT 085E 61 PUSH2 0x084e 0861 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0843 stack[-3] = stack[-3] + stack[-1] // @0847 memory[0x00:0x20] = stack[-2] // @0852 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0857 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @085A stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x084e, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0862: // Incoming jump from 0x0861, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0861, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0862 stack[-3] // @0863 stack[-1] // } 0862 82 DUP3 0863 90 SWAP1 0864 03 SUB 0865 60 PUSH1 0x1f 0867 16 AND 0868 82 DUP3 0869 01 ADD 086A 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @086A stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @086A stack[-1] = stack[-3] // } // Block continues label_086B: // Incoming jump from 0x083F // Incoming jump from 0x0824, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Incoming jump from 0x086A // Inputs[3] // { // @0871 stack[-7] // @0871 stack[-6] // @0873 stack[-8] // } 086B 5B JUMPDEST 086C 50 POP 086D 50 POP 086E 50 POP 086F 50 POP 0870 50 POP 0871 90 SWAP1 0872 50 POP 0873 90 SWAP1 0874 56 *JUMP // Stack delta = -7 // Outputs[1] { @0873 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0875: // Incoming call from 0x01DB, returns to 0x01DC // Inputs[1] { @088F stack[-2] } 0875 5B JUMPDEST 0876 60 PUSH1 0x00 0878 80 DUP1 0879 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 088E 16 AND 088F 83 DUP4 0890 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08A5 16 AND 08A6 14 EQ 08A7 15 ISZERO 08A8 15 ISZERO 08A9 15 ISZERO 08AA 61 PUSH2 0x08b2 08AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0876 stack[0] = 0x00 } // Block ends with conditional jump to 0x08b2, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_08AE: // Incoming jump from 0x08AD, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @08B1 memory[0x00:0x00] } 08AE 60 PUSH1 0x00 08B0 80 DUP1 08B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @08B1 revert(memory[0x00:0x00]); } // Block terminates label_08B2: // Incoming jump from 0x08AD, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[11] // { // @08B3 stack[-2] // @08B8 msg.sender // @08F2 memory[0x00:0x40] // @08F5 stack[-3] // @092F memory[0x00:0x40] // @094B msg.sender // @0986 memory[0x40:0x60] // @0993 memory[0x40:0x60] // @0998 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @099B stack[-1] // @099D stack[-4] // } 08B2 5B JUMPDEST 08B3 81 DUP2 08B4 60 PUSH1 0x05 08B6 60 PUSH1 0x00 08B8 33 CALLER 08B9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08CE 16 AND 08CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08E4 16 AND 08E5 81 DUP2 08E6 52 MSTORE 08E7 60 PUSH1 0x20 08E9 01 ADD 08EA 90 SWAP1 08EB 81 DUP2 08EC 52 MSTORE 08ED 60 PUSH1 0x20 08EF 01 ADD 08F0 60 PUSH1 0x00 08F2 20 SHA3 08F3 60 PUSH1 0x00 08F5 85 DUP6 08F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 090B 16 AND 090C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0921 16 AND 0922 81 DUP2 0923 52 MSTORE 0924 60 PUSH1 0x20 0926 01 ADD 0927 90 SWAP1 0928 81 DUP2 0929 52 MSTORE 092A 60 PUSH1 0x20 092C 01 ADD 092D 60 PUSH1 0x00 092F 20 SHA3 0930 81 DUP2 0931 90 SWAP1 0932 55 SSTORE 0933 50 POP 0934 82 DUP3 0935 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 094A 16 AND 094B 33 CALLER 094C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0961 16 AND 0962 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0983 84 DUP5 0984 60 PUSH1 0x40 0986 51 MLOAD 0987 80 DUP1 0988 82 DUP3 0989 81 DUP2 098A 52 MSTORE 098B 60 PUSH1 0x20 098D 01 ADD 098E 91 SWAP2 098F 50 POP 0990 50 POP 0991 60 PUSH1 0x40 0993 51 MLOAD 0994 80 DUP1 0995 91 SWAP2 0996 03 SUB 0997 90 SWAP1 0998 A3 LOG3 0999 60 PUSH1 0x01 099B 90 SWAP1 099C 50 POP 099D 92 SWAP3 099E 91 SWAP2 099F 50 POP 09A0 50 POP 09A1 56 *JUMP // Stack delta = -3 // Outputs[8] // { // @08E6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @08EC memory[0x20:0x40] = 0x05 // @0923 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0929 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0932 storage[keccak256(memory[0x00:0x40])] = stack[-2] // @098A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0998 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // @099D stack[-4] = 0x01 // } // Block ends with unconditional jump to stack[-4] label_09A2: // Incoming call from 0x020A, returns to 0x020B // Inputs[2] // { // @09A7 storage[0x03] // @09AA stack[-1] // } 09A2 5B JUMPDEST 09A3 60 PUSH1 0x00 09A5 60 PUSH1 0x03 09A7 54 SLOAD 09A8 90 SWAP1 09A9 50 POP 09AA 90 SWAP1 09AB 56 *JUMP // Stack delta = +0 // Outputs[1] { @09AA stack[-1] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_09AC: // Incoming call from 0x028B, returns to 0x028C // Inputs[4] // { // @09B3 stack[-3] // @09ED memory[0x00:0x40] // @09EE storage[keccak256(memory[0x00:0x40])] // @09EF stack[-1] // } 09AC 5B JUMPDEST 09AD 60 PUSH1 0x00 09AF 60 PUSH1 0x04 09B1 60 PUSH1 0x00 09B3 85 DUP6 09B4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09C9 16 AND 09CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09DF 16 AND 09E0 81 DUP2 09E1 52 MSTORE 09E2 60 PUSH1 0x20 09E4 01 ADD 09E5 90 SWAP1 09E6 81 DUP2 09E7 52 MSTORE 09E8 60 PUSH1 0x20 09EA 01 ADD 09EB 60 PUSH1 0x00 09ED 20 SHA3 09EE 54 SLOAD 09EF 82 DUP3 09F0 11 GT 09F1 15 ISZERO 09F2 15 ISZERO 09F3 15 ISZERO 09F4 61 PUSH2 0x09fc 09F7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @09AD stack[0] = 0x00 // @09E1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @09E7 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x09fc, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) label_09F8: // Incoming jump from 0x09F7, if not !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @09FB memory[0x00:0x00] } 09F8 60 PUSH1 0x00 09FA 80 DUP1 09FB FD *REVERT // Stack delta = +0 // Outputs[1] { @09FB revert(memory[0x00:0x00]); } // Block terminates label_09FC: // Incoming jump from 0x09F7, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[6] // { // @0A01 stack[-4] // @0A3B memory[0x00:0x40] // @0A3E msg.sender // @0A78 memory[0x00:0x40] // @0A79 storage[keccak256(memory[0x00:0x40])] // @0A7A stack[-2] // } 09FC 5B JUMPDEST 09FD 60 PUSH1 0x05 09FF 60 PUSH1 0x00 0A01 85 DUP6 0A02 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A17 16 AND 0A18 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A2D 16 AND 0A2E 81 DUP2 0A2F 52 MSTORE 0A30 60 PUSH1 0x20 0A32 01 ADD 0A33 90 SWAP1 0A34 81 DUP2 0A35 52 MSTORE 0A36 60 PUSH1 0x20 0A38 01 ADD 0A39 60 PUSH1 0x00 0A3B 20 SHA3 0A3C 60 PUSH1 0x00 0A3E 33 CALLER 0A3F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A54 16 AND 0A55 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A6A 16 AND 0A6B 81 DUP2 0A6C 52 MSTORE 0A6D 60 PUSH1 0x20 0A6F 01 ADD 0A70 90 SWAP1 0A71 81 DUP2 0A72 52 MSTORE 0A73 60 PUSH1 0x20 0A75 01 ADD 0A76 60 PUSH1 0x00 0A78 20 SHA3 0A79 54 SLOAD 0A7A 82 DUP3 0A7B 11 GT 0A7C 15 ISZERO 0A7D 15 ISZERO 0A7E 15 ISZERO 0A7F 61 PUSH2 0x0a87 0A82 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0A2F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0A35 memory[0x20:0x40] = 0x05 // @0A6C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0A72 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0a87, if !!!(stack[-2] > storage[keccak256(memory[0x00:0x40])]) label_0A83: // Incoming jump from 0x0A82, if not !!!(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0A86 memory[0x00:0x00] } 0A83 60 PUSH1 0x00 0A85 80 DUP1 0A86 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A86 revert(memory[0x00:0x00]); } // Block terminates label_0A87: // Incoming jump from 0x0A82, if !!!(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0AA0 stack[-3] } 0A87 5B JUMPDEST 0A88 60 PUSH1 0x00 0A8A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A9F 16 AND 0AA0 83 DUP4 0AA1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AB6 16 AND 0AB7 14 EQ 0AB8 15 ISZERO 0AB9 15 ISZERO 0ABA 15 ISZERO 0ABB 61 PUSH2 0x0ac3 0ABE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ac3, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0ABF: // Incoming jump from 0x0ABE, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0AC2 memory[0x00:0x00] } 0ABF 60 PUSH1 0x00 0AC1 80 DUP1 0AC2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AC2 revert(memory[0x00:0x00]); } // Block terminates label_0AC3: // Incoming jump from 0x0ABE, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @0AC9 storage[0x08] // @0AE0 stack[-3] // @0B1A memory[0x00:0x40] // @0B1B storage[keccak256(memory[0x00:0x40])] // @0B29 memory[0x00:0x40] // @0B31 storage[keccak256(memory[0x00:0x40])] // @0B6B stack[-2] // } 0AC3 5B JUMPDEST 0AC4 60 PUSH1 0x08 0AC6 60 PUSH1 0x00 0AC8 81 DUP2 0AC9 54 SLOAD 0ACA 80 DUP1 0ACB 92 SWAP3 0ACC 91 SWAP2 0ACD 90 SWAP1 0ACE 60 PUSH1 0x01 0AD0 01 ADD 0AD1 91 SWAP2 0AD2 90 SWAP1 0AD3 50 POP 0AD4 55 SSTORE 0AD5 50 POP 0AD6 60 PUSH1 0x00 0AD8 60 PUSH1 0x0b 0ADA 60 PUSH1 0x00 0ADC 60 PUSH1 0x0a 0ADE 60 PUSH1 0x00 0AE0 87 DUP8 0AE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AF6 16 AND 0AF7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B0C 16 AND 0B0D 81 DUP2 0B0E 52 MSTORE 0B0F 60 PUSH1 0x20 0B11 01 ADD 0B12 90 SWAP1 0B13 81 DUP2 0B14 52 MSTORE 0B15 60 PUSH1 0x20 0B17 01 ADD 0B18 60 PUSH1 0x00 0B1A 20 SHA3 0B1B 54 SLOAD 0B1C 81 DUP2 0B1D 52 MSTORE 0B1E 60 PUSH1 0x20 0B20 01 ADD 0B21 90 SWAP1 0B22 81 DUP2 0B23 52 MSTORE 0B24 60 PUSH1 0x20 0B26 01 ADD 0B27 60 PUSH1 0x00 0B29 20 SHA3 0B2A 60 PUSH1 0x00 0B2C 61 PUSH2 0x0100 0B2F 0A EXP 0B30 81 DUP2 0B31 54 SLOAD 0B32 81 DUP2 0B33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B48 02 MUL 0B49 19 NOT 0B4A 16 AND 0B4B 90 SWAP1 0B4C 83 DUP4 0B4D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B62 16 AND 0B63 02 MUL 0B64 17 OR 0B65 90 SWAP1 0B66 55 SSTORE 0B67 50 POP 0B68 61 PUSH2 0x0b70 0B6B 82 DUP3 0B6C 61 PUSH2 0x2c16 0B6F 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0AD4 storage[0x08] = 0x01 + storage[0x08] // @0B0E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0B14 memory[0x20:0x40] = 0x0a // @0B1D memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @0B23 memory[0x20:0x40] = 0x0b // @0B66 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @0B68 stack[0] = 0x0b70 // @0B6B stack[1] = stack[-2] // } // Block ends with call to 0x2c16, returns to 0x0B70 label_0B70: // Incoming return from call to 0x2C16 at 0x0B6F // Inputs[12] // { // @0B75 stack[-1] // @0B77 storage[0x09] // @0B82 storage[0x09] // @0B87 stack[-4] // @0BC1 memory[0x00:0x40] // @0BCD storage[0x09] // @0BDB memory[0x00:0x40] // @0BE3 storage[keccak256(memory[0x00:0x40])] // @0C1D stack[-3] // @0C22 stack[-5] // @0C5C memory[0x00:0x40] // @0C5D storage[keccak256(memory[0x00:0x40])] // } 0B70 5B JUMPDEST 0B71 60 PUSH1 0x09 0B73 60 PUSH1 0x00 0B75 82 DUP3 0B76 82 DUP3 0B77 54 SLOAD 0B78 01 ADD 0B79 92 SWAP3 0B7A 50 POP 0B7B 50 POP 0B7C 81 DUP2 0B7D 90 SWAP1 0B7E 55 SSTORE 0B7F 50 POP 0B80 60 PUSH1 0x09 0B82 54 SLOAD 0B83 60 PUSH1 0x0a 0B85 60 PUSH1 0x00 0B87 85 DUP6 0B88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B9D 16 AND 0B9E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BB3 16 AND 0BB4 81 DUP2 0BB5 52 MSTORE 0BB6 60 PUSH1 0x20 0BB8 01 ADD 0BB9 90 SWAP1 0BBA 81 DUP2 0BBB 52 MSTORE 0BBC 60 PUSH1 0x20 0BBE 01 ADD 0BBF 60 PUSH1 0x00 0BC1 20 SHA3 0BC2 81 DUP2 0BC3 90 SWAP1 0BC4 55 SSTORE 0BC5 50 POP 0BC6 82 DUP3 0BC7 60 PUSH1 0x0b 0BC9 60 PUSH1 0x00 0BCB 60 PUSH1 0x09 0BCD 54 SLOAD 0BCE 81 DUP2 0BCF 52 MSTORE 0BD0 60 PUSH1 0x20 0BD2 01 ADD 0BD3 90 SWAP1 0BD4 81 DUP2 0BD5 52 MSTORE 0BD6 60 PUSH1 0x20 0BD8 01 ADD 0BD9 60 PUSH1 0x00 0BDB 20 SHA3 0BDC 60 PUSH1 0x00 0BDE 61 PUSH2 0x0100 0BE1 0A EXP 0BE2 81 DUP2 0BE3 54 SLOAD 0BE4 81 DUP2 0BE5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BFA 02 MUL 0BFB 19 NOT 0BFC 16 AND 0BFD 90 SWAP1 0BFE 83 DUP4 0BFF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C14 16 AND 0C15 02 MUL 0C16 17 OR 0C17 90 SWAP1 0C18 55 SSTORE 0C19 50 POP 0C1A 61 PUSH2 0x0c6b 0C1D 82 DUP3 0C1E 60 PUSH1 0x04 0C20 60 PUSH1 0x00 0C22 87 DUP8 0C23 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C38 16 AND 0C39 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C4E 16 AND 0C4F 81 DUP2 0C50 52 MSTORE 0C51 60 PUSH1 0x20 0C53 01 ADD 0C54 90 SWAP1 0C55 81 DUP2 0C56 52 MSTORE 0C57 60 PUSH1 0x20 0C59 01 ADD 0C5A 60 PUSH1 0x00 0C5C 20 SHA3 0C5D 54 SLOAD 0C5E 61 PUSH2 0x3002 0C61 90 SWAP1 0C62 91 SWAP2 0C63 90 SWAP1 0C64 63 PUSH4 0xffffffff 0C69 16 AND 0C6A 56 *JUMP // Stack delta = +2 // Outputs[12] // { // @0B7E storage[0x09] = storage[0x09] + stack[-1] // @0BB5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0BBB memory[0x20:0x40] = 0x0a // @0BC4 storage[keccak256(memory[0x00:0x40])] = storage[0x09] // @0BCF memory[0x00:0x20] = storage[0x09] // @0BD5 memory[0x20:0x40] = 0x0b // @0C18 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @0C1A stack[-1] = 0x0c6b // @0C50 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0C56 memory[0x20:0x40] = 0x04 // @0C62 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0C63 stack[1] = stack[-3] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x0C6B label_0C6B: // Incoming return from call to 0x3002 at 0x0C6A // Inputs[7] // { // @0C70 stack[-5] // @0CAA memory[0x00:0x40] // @0CAB stack[-1] // @0CB2 stack[-3] // @0CB7 stack[-4] // @0CF1 memory[0x00:0x40] // @0CF2 storage[keccak256(memory[0x00:0x40])] // } 0C6B 5B JUMPDEST 0C6C 60 PUSH1 0x04 0C6E 60 PUSH1 0x00 0C70 86 DUP7 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 81 DUP2 0CAC 90 SWAP1 0CAD 55 SSTORE 0CAE 50 POP 0CAF 61 PUSH2 0x0d00 0CB2 82 DUP3 0CB3 60 PUSH1 0x04 0CB5 60 PUSH1 0x00 0CB7 86 DUP7 0CB8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CCD 16 AND 0CCE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CE3 16 AND 0CE4 81 DUP2 0CE5 52 MSTORE 0CE6 60 PUSH1 0x20 0CE8 01 ADD 0CE9 90 SWAP1 0CEA 81 DUP2 0CEB 52 MSTORE 0CEC 60 PUSH1 0x20 0CEE 01 ADD 0CEF 60 PUSH1 0x00 0CF1 20 SHA3 0CF2 54 SLOAD 0CF3 61 PUSH2 0x3023 0CF6 90 SWAP1 0CF7 91 SWAP2 0CF8 90 SWAP1 0CF9 63 PUSH4 0xffffffff 0CFE 16 AND 0CFF 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0C9E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0CA4 memory[0x20:0x40] = 0x04 // @0CAD storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0CAF stack[-1] = 0x0d00 // @0CE5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0CEB memory[0x20:0x40] = 0x04 // @0CF7 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0CF8 stack[1] = stack[-3] // } // Block ends with call to 0xffffffff & 0x3023, returns to 0x0D00 label_0D00: // Incoming return from call to 0x3023 at 0x0CFF // Inputs[9] // { // @0D05 stack[-4] // @0D3F memory[0x00:0x40] // @0D40 stack[-1] // @0D47 stack[-3] // @0D4C stack[-5] // @0D86 memory[0x00:0x40] // @0D89 msg.sender // @0DC3 memory[0x00:0x40] // @0DC4 storage[keccak256(memory[0x00:0x40])] // } 0D00 5B JUMPDEST 0D01 60 PUSH1 0x04 0D03 60 PUSH1 0x00 0D05 85 DUP6 0D06 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D1B 16 AND 0D1C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D31 16 AND 0D32 81 DUP2 0D33 52 MSTORE 0D34 60 PUSH1 0x20 0D36 01 ADD 0D37 90 SWAP1 0D38 81 DUP2 0D39 52 MSTORE 0D3A 60 PUSH1 0x20 0D3C 01 ADD 0D3D 60 PUSH1 0x00 0D3F 20 SHA3 0D40 81 DUP2 0D41 90 SWAP1 0D42 55 SSTORE 0D43 50 POP 0D44 61 PUSH2 0x0dd2 0D47 82 DUP3 0D48 60 PUSH1 0x05 0D4A 60 PUSH1 0x00 0D4C 87 DUP8 0D4D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D62 16 AND 0D63 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D78 16 AND 0D79 81 DUP2 0D7A 52 MSTORE 0D7B 60 PUSH1 0x20 0D7D 01 ADD 0D7E 90 SWAP1 0D7F 81 DUP2 0D80 52 MSTORE 0D81 60 PUSH1 0x20 0D83 01 ADD 0D84 60 PUSH1 0x00 0D86 20 SHA3 0D87 60 PUSH1 0x00 0D89 33 CALLER 0D8A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D9F 16 AND 0DA0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DB5 16 AND 0DB6 81 DUP2 0DB7 52 MSTORE 0DB8 60 PUSH1 0x20 0DBA 01 ADD 0DBB 90 SWAP1 0DBC 81 DUP2 0DBD 52 MSTORE 0DBE 60 PUSH1 0x20 0DC0 01 ADD 0DC1 60 PUSH1 0x00 0DC3 20 SHA3 0DC4 54 SLOAD 0DC5 61 PUSH2 0x3002 0DC8 90 SWAP1 0DC9 91 SWAP2 0DCA 90 SWAP1 0DCB 63 PUSH4 0xffffffff 0DD0 16 AND 0DD1 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @0D33 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0D39 memory[0x20:0x40] = 0x04 // @0D42 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0D44 stack[-1] = 0x0dd2 // @0D7A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0D80 memory[0x20:0x40] = 0x05 // @0DB7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0DBD memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0DC9 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0DCA stack[1] = stack[-3] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x0DD2 label_0DD2: // Incoming return from call to 0x3002 at 0x0DD1 // Inputs[7] // { // @0DD7 stack[-5] // @0E11 memory[0x00:0x40] // @0E14 msg.sender // @0E4E memory[0x00:0x40] // @0E4F stack[-1] // @0E55 stack[-2] // @0E57 stack[-6] // } 0DD2 5B JUMPDEST 0DD3 60 PUSH1 0x05 0DD5 60 PUSH1 0x00 0DD7 86 DUP7 0DD8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DED 16 AND 0DEE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E03 16 AND 0E04 81 DUP2 0E05 52 MSTORE 0E06 60 PUSH1 0x20 0E08 01 ADD 0E09 90 SWAP1 0E0A 81 DUP2 0E0B 52 MSTORE 0E0C 60 PUSH1 0x20 0E0E 01 ADD 0E0F 60 PUSH1 0x00 0E11 20 SHA3 0E12 60 PUSH1 0x00 0E14 33 CALLER 0E15 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E2A 16 AND 0E2B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E40 16 AND 0E41 81 DUP2 0E42 52 MSTORE 0E43 60 PUSH1 0x20 0E45 01 ADD 0E46 90 SWAP1 0E47 81 DUP2 0E48 52 MSTORE 0E49 60 PUSH1 0x20 0E4B 01 ADD 0E4C 60 PUSH1 0x00 0E4E 20 SHA3 0E4F 81 DUP2 0E50 90 SWAP1 0E51 55 SSTORE 0E52 50 POP 0E53 60 PUSH1 0x01 0E55 90 SWAP1 0E56 50 POP 0E57 93 SWAP4 0E58 92 SWAP3 0E59 50 POP 0E5A 50 POP 0E5B 50 POP 0E5C 56 *JUMP // Stack delta = -5 // Outputs[6] // { // @0E05 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0E0B memory[0x20:0x40] = 0x05 // @0E42 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0E48 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E51 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0E57 stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_0E5D: // Incoming call from 0x02BA, returns to 0x02BB // Inputs[2] // { // @0E65 storage[0x02] // @0E72 stack[-1] // } 0E5D 5B JUMPDEST 0E5E 60 PUSH1 0x00 0E60 60 PUSH1 0x02 0E62 60 PUSH1 0x00 0E64 90 SWAP1 0E65 54 SLOAD 0E66 90 SWAP1 0E67 61 PUSH2 0x0100 0E6A 0A EXP 0E6B 90 SWAP1 0E6C 04 DIV 0E6D 60 PUSH1 0xff 0E6F 16 AND 0E70 90 SWAP1 0E71 50 POP 0E72 90 SWAP1 0E73 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E72 stack[-1] = 0xff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0E74: // Incoming call from 0x030B, returns to 0x030C // Inputs[1] { @0E7B stack[-2] } 0E74 5B JUMPDEST 0E75 60 PUSH1 0x00 0E77 80 DUP1 0E78 61 PUSH2 0x0e80 0E7B 84 DUP5 0E7C 61 PUSH2 0x1792 0E7F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E75 stack[0] = 0x00 // @0E77 stack[1] = 0x00 // @0E78 stack[2] = 0x0e80 // @0E7B stack[3] = stack[-2] // } // Block ends with call to 0x1792, returns to 0x0E80 label_0E80: // Incoming return from call to 0x1792 at 0x0E7F // Inputs[3] // { // @0E81 stack[-2] // @0E81 stack[-1] // @0E88 storage[0x08] // } 0E80 5B JUMPDEST 0E81 90 SWAP1 0E82 50 POP 0E83 60 PUSH1 0x08 0E85 60 PUSH1 0x00 0E87 81 DUP2 0E88 54 SLOAD 0E89 80 DUP1 0E8A 92 SWAP3 0E8B 91 SWAP2 0E8C 90 SWAP1 0E8D 60 PUSH1 0x01 0E8F 01 ADD 0E90 91 SWAP2 0E91 90 SWAP1 0E92 50 POP 0E93 55 SSTORE 0E94 50 POP 0E95 60 PUSH1 0x00 0E97 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EAC 16 AND 0EAD 81 DUP2 0EAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EC3 16 AND 0EC4 14 EQ 0EC5 15 ISZERO 0EC6 61 PUSH2 0x0ece 0EC9 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0E81 stack[-2] = stack[-1] // @0E93 storage[0x08] = 0x01 + storage[0x08] // } // Block ends with conditional jump to 0x0ece, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0ECA: // Incoming jump from 0x0EC9, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0ECD memory[0x00:0x00] } 0ECA 60 PUSH1 0x00 0ECC 80 DUP1 0ECD FD *REVERT // Stack delta = +0 // Outputs[1] { @0ECD revert(memory[0x00:0x00]); } // Block terminates label_0ECE: // Incoming jump from 0x0EC9, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0ED2 stack[-3] } 0ECE 5B JUMPDEST 0ECF 61 PUSH2 0x0ed7 0ED2 83 DUP4 0ED3 61 PUSH2 0x17cf 0ED6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0ECF stack[0] = 0x0ed7 // @0ED2 stack[1] = stack[-3] // } // Block ends with call to 0x17cf, returns to 0x0ED7 label_0ED7: // Incoming return from call to 0x17CF at 0x0ED6 // Inputs[5] // { // @0ED8 stack[-1] // @0ED8 stack[-4] // @0EDE msg.sender // @0F18 memory[0x00:0x40] // @0F19 storage[keccak256(memory[0x00:0x40])] // } 0ED7 5B JUMPDEST 0ED8 92 SWAP3 0ED9 50 POP 0EDA 60 PUSH1 0x04 0EDC 60 PUSH1 0x00 0EDE 33 CALLER 0EDF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF4 16 AND 0EF5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F0A 16 AND 0F0B 81 DUP2 0F0C 52 MSTORE 0F0D 60 PUSH1 0x20 0F0F 01 ADD 0F10 90 SWAP1 0F11 81 DUP2 0F12 52 MSTORE 0F13 60 PUSH1 0x20 0F15 01 ADD 0F16 60 PUSH1 0x00 0F18 20 SHA3 0F19 54 SLOAD 0F1A 83 DUP4 0F1B 11 GT 0F1C 15 ISZERO 0F1D 15 ISZERO 0F1E 15 ISZERO 0F1F 61 PUSH2 0x0f27 0F22 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0ED8 stack[-4] = stack[-1] // @0F0C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0F12 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0f27, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) label_0F23: // Incoming jump from 0x0F22, if not !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0F26 memory[0x00:0x00] } 0F23 60 PUSH1 0x00 0F25 80 DUP1 0F26 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F26 revert(memory[0x00:0x00]); } // Block terminates label_0F27: // Incoming jump from 0x0F22, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0F40 stack[-1] } 0F27 5B JUMPDEST 0F28 60 PUSH1 0x00 0F2A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F3F 16 AND 0F40 81 DUP2 0F41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F56 16 AND 0F57 14 EQ 0F58 15 ISZERO 0F59 15 ISZERO 0F5A 15 ISZERO 0F5B 61 PUSH2 0x0f63 0F5E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f63, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0F5F: // Incoming jump from 0x0F5E, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0F62 memory[0x00:0x00] } 0F5F 60 PUSH1 0x00 0F61 80 DUP1 0F62 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F62 revert(memory[0x00:0x00]); } // Block terminates label_0F63: // Incoming jump from 0x0F5E, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @0F64 address(this) // @0F7B stack[-1] // } 0F63 5B JUMPDEST 0F64 30 ADDRESS 0F65 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F7A 16 AND 0F7B 81 DUP2 0F7C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F91 16 AND 0F92 14 EQ 0F93 15 ISZERO 0F94 15 ISZERO 0F95 15 ISZERO 0F96 61 PUSH2 0x0f9e 0F99 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f9e, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & address(this)) label_0F9A: // Incoming jump from 0x0F99, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & address(this)) // Inputs[1] { @0F9D memory[0x00:0x00] } 0F9A 60 PUSH1 0x00 0F9C 80 DUP1 0F9D FD *REVERT // Stack delta = +0 // Outputs[1] { @0F9D revert(memory[0x00:0x00]); } // Block terminates label_0F9E: // Incoming jump from 0x0F99, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & address(this)) // Inputs[1] { @0FA1 stack[-3] } 0F9E 5B JUMPDEST 0F9F 60 PUSH1 0x00 0FA1 83 DUP4 0FA2 14 EQ 0FA3 15 ISZERO 0FA4 61 PUSH2 0x12e1 0FA7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12e1, if !(stack[-3] == 0x00) label_0FA8: // Incoming jump from 0x0FA7, if not !(stack[-3] == 0x00) // Inputs[6] // { // @0FB2 stack[-1] // @0FEC memory[0x00:0x40] // @0FED storage[keccak256(memory[0x00:0x40])] // @0FFB memory[0x00:0x40] // @1003 storage[keccak256(memory[0x00:0x40])] // @103D stack[-3] // } 0FA8 60 PUSH1 0x00 0FAA 60 PUSH1 0x0b 0FAC 60 PUSH1 0x00 0FAE 60 PUSH1 0x0a 0FB0 60 PUSH1 0x00 0FB2 85 DUP6 0FB3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FC8 16 AND 0FC9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FDE 16 AND 0FDF 81 DUP2 0FE0 52 MSTORE 0FE1 60 PUSH1 0x20 0FE3 01 ADD 0FE4 90 SWAP1 0FE5 81 DUP2 0FE6 52 MSTORE 0FE7 60 PUSH1 0x20 0FE9 01 ADD 0FEA 60 PUSH1 0x00 0FEC 20 SHA3 0FED 54 SLOAD 0FEE 81 DUP2 0FEF 52 MSTORE 0FF0 60 PUSH1 0x20 0FF2 01 ADD 0FF3 90 SWAP1 0FF4 81 DUP2 0FF5 52 MSTORE 0FF6 60 PUSH1 0x20 0FF8 01 ADD 0FF9 60 PUSH1 0x00 0FFB 20 SHA3 0FFC 60 PUSH1 0x00 0FFE 61 PUSH2 0x0100 1001 0A EXP 1002 81 DUP2 1003 54 SLOAD 1004 81 DUP2 1005 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 101A 02 MUL 101B 19 NOT 101C 16 AND 101D 90 SWAP1 101E 83 DUP4 101F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1034 16 AND 1035 02 MUL 1036 17 OR 1037 90 SWAP1 1038 55 SSTORE 1039 50 POP 103A 61 PUSH2 0x1042 103D 83 DUP4 103E 61 PUSH2 0x2c16 1041 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @0FE0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0FE6 memory[0x20:0x40] = 0x0a // @0FEF memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @0FF5 memory[0x20:0x40] = 0x0b // @1038 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @103A stack[0] = 0x1042 // @103D stack[1] = stack[-3] // } // Block ends with call to 0x2c16, returns to 0x1042 label_1042: // Incoming return from call to 0x2C16 at 0x1041 // Inputs[14] // { // @1047 stack[-1] // @1049 storage[0x09] // @1054 storage[0x09] // @1059 stack[-2] // @1093 memory[0x00:0x40] // @109F storage[0x09] // @10AD memory[0x00:0x40] // @10B5 storage[keccak256(memory[0x00:0x40])] // @10F3 msg.sender // @112D memory[0x00:0x40] // @112E storage[keccak256(memory[0x00:0x40])] // @1133 address(this) // @116D memory[0x00:0x40] // @116E storage[keccak256(memory[0x00:0x40])] // } 1042 5B JUMPDEST 1043 60 PUSH1 0x09 1045 60 PUSH1 0x00 1047 82 DUP3 1048 82 DUP3 1049 54 SLOAD 104A 01 ADD 104B 92 SWAP3 104C 50 POP 104D 50 POP 104E 81 DUP2 104F 90 SWAP1 1050 55 SSTORE 1051 50 POP 1052 60 PUSH1 0x09 1054 54 SLOAD 1055 60 PUSH1 0x0a 1057 60 PUSH1 0x00 1059 83 DUP4 105A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 106F 16 AND 1070 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1085 16 AND 1086 81 DUP2 1087 52 MSTORE 1088 60 PUSH1 0x20 108A 01 ADD 108B 90 SWAP1 108C 81 DUP2 108D 52 MSTORE 108E 60 PUSH1 0x20 1090 01 ADD 1091 60 PUSH1 0x00 1093 20 SHA3 1094 81 DUP2 1095 90 SWAP1 1096 55 SSTORE 1097 50 POP 1098 80 DUP1 1099 60 PUSH1 0x0b 109B 60 PUSH1 0x00 109D 60 PUSH1 0x09 109F 54 SLOAD 10A0 81 DUP2 10A1 52 MSTORE 10A2 60 PUSH1 0x20 10A4 01 ADD 10A5 90 SWAP1 10A6 81 DUP2 10A7 52 MSTORE 10A8 60 PUSH1 0x20 10AA 01 ADD 10AB 60 PUSH1 0x00 10AD 20 SHA3 10AE 60 PUSH1 0x00 10B0 61 PUSH2 0x0100 10B3 0A EXP 10B4 81 DUP2 10B5 54 SLOAD 10B6 81 DUP2 10B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10CC 02 MUL 10CD 19 NOT 10CE 16 AND 10CF 90 SWAP1 10D0 83 DUP4 10D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10E6 16 AND 10E7 02 MUL 10E8 17 OR 10E9 90 SWAP1 10EA 55 SSTORE 10EB 50 POP 10EC 61 PUSH2 0x117c 10EF 60 PUSH1 0x06 10F1 60 PUSH1 0x00 10F3 33 CALLER 10F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1109 16 AND 110A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 111F 16 AND 1120 81 DUP2 1121 52 MSTORE 1122 60 PUSH1 0x20 1124 01 ADD 1125 90 SWAP1 1126 81 DUP2 1127 52 MSTORE 1128 60 PUSH1 0x20 112A 01 ADD 112B 60 PUSH1 0x00 112D 20 SHA3 112E 54 SLOAD 112F 60 PUSH1 0x04 1131 60 PUSH1 0x00 1133 30 ADDRESS 1134 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1149 16 AND 114A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 115F 16 AND 1160 81 DUP2 1161 52 MSTORE 1162 60 PUSH1 0x20 1164 01 ADD 1165 90 SWAP1 1166 81 DUP2 1167 52 MSTORE 1168 60 PUSH1 0x20 116A 01 ADD 116B 60 PUSH1 0x00 116D 20 SHA3 116E 54 SLOAD 116F 61 PUSH2 0x3002 1172 90 SWAP1 1173 91 SWAP2 1174 90 SWAP1 1175 63 PUSH4 0xffffffff 117A 16 AND 117B 56 *JUMP // Stack delta = +2 // Outputs[14] // { // @1050 storage[0x09] = storage[0x09] + stack[-1] // @1087 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @108D memory[0x20:0x40] = 0x0a // @1096 storage[keccak256(memory[0x00:0x40])] = storage[0x09] // @10A1 memory[0x00:0x20] = storage[0x09] // @10A7 memory[0x20:0x40] = 0x0b // @10EA storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @10EC stack[-1] = 0x117c // @1121 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1127 memory[0x20:0x40] = 0x06 // @1161 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1167 memory[0x20:0x40] = 0x04 // @1173 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1174 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x117C label_117C: // Incoming return from call to 0x3002 at 0x117B // Inputs[9] // { // @1181 address(this) // @11BB memory[0x00:0x40] // @11BC stack[-1] // @11C7 msg.sender // @1201 memory[0x00:0x40] // @1202 storage[keccak256(memory[0x00:0x40])] // @1207 stack[-2] // @1241 memory[0x00:0x40] // @1242 storage[keccak256(memory[0x00:0x40])] // } 117C 5B JUMPDEST 117D 60 PUSH1 0x04 117F 60 PUSH1 0x00 1181 30 ADDRESS 1182 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1197 16 AND 1198 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11AD 16 AND 11AE 81 DUP2 11AF 52 MSTORE 11B0 60 PUSH1 0x20 11B2 01 ADD 11B3 90 SWAP1 11B4 81 DUP2 11B5 52 MSTORE 11B6 60 PUSH1 0x20 11B8 01 ADD 11B9 60 PUSH1 0x00 11BB 20 SHA3 11BC 81 DUP2 11BD 90 SWAP1 11BE 55 SSTORE 11BF 50 POP 11C0 61 PUSH2 0x1250 11C3 60 PUSH1 0x06 11C5 60 PUSH1 0x00 11C7 33 CALLER 11C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11DD 16 AND 11DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11F3 16 AND 11F4 81 DUP2 11F5 52 MSTORE 11F6 60 PUSH1 0x20 11F8 01 ADD 11F9 90 SWAP1 11FA 81 DUP2 11FB 52 MSTORE 11FC 60 PUSH1 0x20 11FE 01 ADD 11FF 60 PUSH1 0x00 1201 20 SHA3 1202 54 SLOAD 1203 60 PUSH1 0x04 1205 60 PUSH1 0x00 1207 84 DUP5 1208 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 121D 16 AND 121E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1233 16 AND 1234 81 DUP2 1235 52 MSTORE 1236 60 PUSH1 0x20 1238 01 ADD 1239 90 SWAP1 123A 81 DUP2 123B 52 MSTORE 123C 60 PUSH1 0x20 123E 01 ADD 123F 60 PUSH1 0x00 1241 20 SHA3 1242 54 SLOAD 1243 61 PUSH2 0x3023 1246 90 SWAP1 1247 91 SWAP2 1248 90 SWAP1 1249 63 PUSH4 0xffffffff 124E 16 AND 124F 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @11AF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @11B5 memory[0x20:0x40] = 0x04 // @11BE storage[keccak256(memory[0x00:0x40])] = stack[-1] // @11C0 stack[-1] = 0x1250 // @11F5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @11FB memory[0x20:0x40] = 0x06 // @1235 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @123B memory[0x20:0x40] = 0x04 // @1247 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1248 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0xffffffff & 0x3023, returns to 0x1250 label_1250: // Incoming return from call to 0x3023 at 0x124F // Inputs[6] // { // @1255 stack[-2] // @128F memory[0x00:0x40] // @1290 stack[-1] // @129A msg.sender // @12D4 memory[0x00:0x40] // @12DB stack[-3] // } 1250 5B JUMPDEST 1251 60 PUSH1 0x04 1253 60 PUSH1 0x00 1255 83 DUP4 1256 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 126B 16 AND 126C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1281 16 AND 1282 81 DUP2 1283 52 MSTORE 1284 60 PUSH1 0x20 1286 01 ADD 1287 90 SWAP1 1288 81 DUP2 1289 52 MSTORE 128A 60 PUSH1 0x20 128C 01 ADD 128D 60 PUSH1 0x00 128F 20 SHA3 1290 81 DUP2 1291 90 SWAP1 1292 55 SSTORE 1293 50 POP 1294 60 PUSH1 0x00 1296 60 PUSH1 0x06 1298 60 PUSH1 0x00 129A 33 CALLER 129B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12B0 16 AND 12B1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12C6 16 AND 12C7 81 DUP2 12C8 52 MSTORE 12C9 60 PUSH1 0x20 12CB 01 ADD 12CC 90 SWAP1 12CD 81 DUP2 12CE 52 MSTORE 12CF 60 PUSH1 0x20 12D1 01 ADD 12D2 60 PUSH1 0x00 12D4 20 SHA3 12D5 81 DUP2 12D6 90 SWAP1 12D7 55 SSTORE 12D8 50 POP 12D9 60 PUSH1 0x01 12DB 91 SWAP2 12DC 50 POP 12DD 61 PUSH2 0x1554 12E0 56 *JUMP // Stack delta = -1 // Outputs[7] // { // @1283 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1289 memory[0x20:0x40] = 0x04 // @1292 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @12C8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @12CE memory[0x20:0x40] = 0x06 // @12D7 storage[keccak256(memory[0x00:0x40])] = 0x00 // @12DB stack[-3] = 0x01 // } // Block ends with unconditional jump to 0x1554 label_12E1: // Incoming jump from 0x0FA7, if !(stack[-3] == 0x00) // Inputs[4] // { // @12E5 stack[-3] // @12EA msg.sender // @1324 memory[0x00:0x40] // @1325 storage[keccak256(memory[0x00:0x40])] // } 12E1 5B JUMPDEST 12E2 61 PUSH2 0x1333 12E5 83 DUP4 12E6 60 PUSH1 0x04 12E8 60 PUSH1 0x00 12EA 33 CALLER 12EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1300 16 AND 1301 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1316 16 AND 1317 81 DUP2 1318 52 MSTORE 1319 60 PUSH1 0x20 131B 01 ADD 131C 90 SWAP1 131D 81 DUP2 131E 52 MSTORE 131F 60 PUSH1 0x20 1321 01 ADD 1322 60 PUSH1 0x00 1324 20 SHA3 1325 54 SLOAD 1326 61 PUSH2 0x3002 1329 90 SWAP1 132A 91 SWAP2 132B 90 SWAP1 132C 63 PUSH4 0xffffffff 1331 16 AND 1332 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @12E2 stack[0] = 0x1333 // @1318 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @131E memory[0x20:0x40] = 0x04 // @132A stack[1] = storage[keccak256(memory[0x00:0x40])] // @132B stack[2] = stack[-3] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x1333 label_1333: // Incoming return from call to 0x3002 at 0x1332 // Inputs[7] // { // @1338 msg.sender // @1372 memory[0x00:0x40] // @1373 stack[-1] // @137A stack[-4] // @137F stack[-2] // @13B9 memory[0x00:0x40] // @13BA storage[keccak256(memory[0x00:0x40])] // } 1333 5B JUMPDEST 1334 60 PUSH1 0x04 1336 60 PUSH1 0x00 1338 33 CALLER 1339 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 134E 16 AND 134F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1364 16 AND 1365 81 DUP2 1366 52 MSTORE 1367 60 PUSH1 0x20 1369 01 ADD 136A 90 SWAP1 136B 81 DUP2 136C 52 MSTORE 136D 60 PUSH1 0x20 136F 01 ADD 1370 60 PUSH1 0x00 1372 20 SHA3 1373 81 DUP2 1374 90 SWAP1 1375 55 SSTORE 1376 50 POP 1377 61 PUSH2 0x13c8 137A 83 DUP4 137B 60 PUSH1 0x04 137D 60 PUSH1 0x00 137F 84 DUP5 1380 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1395 16 AND 1396 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13AB 16 AND 13AC 81 DUP2 13AD 52 MSTORE 13AE 60 PUSH1 0x20 13B0 01 ADD 13B1 90 SWAP1 13B2 81 DUP2 13B3 52 MSTORE 13B4 60 PUSH1 0x20 13B6 01 ADD 13B7 60 PUSH1 0x00 13B9 20 SHA3 13BA 54 SLOAD 13BB 61 PUSH2 0x3023 13BE 90 SWAP1 13BF 91 SWAP2 13C0 90 SWAP1 13C1 63 PUSH4 0xffffffff 13C6 16 AND 13C7 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1366 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @136C memory[0x20:0x40] = 0x04 // @1375 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1377 stack[-1] = 0x13c8 // @13AD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @13B3 memory[0x20:0x40] = 0x04 // @13BF stack[0] = storage[keccak256(memory[0x00:0x40])] // @13C0 stack[1] = stack[-4] // } // Block ends with call to 0xffffffff & 0x3023, returns to 0x13C8 label_13C8: // Incoming return from call to 0x3023 at 0x13C7 // Inputs[8] // { // @13CD stack[-2] // @1407 memory[0x00:0x40] // @1408 stack[-1] // @1450 memory[0x00:0x40] // @1451 storage[keccak256(memory[0x00:0x40])] // @145F memory[0x00:0x40] // @1467 storage[keccak256(memory[0x00:0x40])] // @14A1 stack[-4] // } 13C8 5B JUMPDEST 13C9 60 PUSH1 0x04 13CB 60 PUSH1 0x00 13CD 83 DUP4 13CE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13E3 16 AND 13E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13F9 16 AND 13FA 81 DUP2 13FB 52 MSTORE 13FC 60 PUSH1 0x20 13FE 01 ADD 13FF 90 SWAP1 1400 81 DUP2 1401 52 MSTORE 1402 60 PUSH1 0x20 1404 01 ADD 1405 60 PUSH1 0x00 1407 20 SHA3 1408 81 DUP2 1409 90 SWAP1 140A 55 SSTORE 140B 50 POP 140C 60 PUSH1 0x00 140E 60 PUSH1 0x0b 1410 60 PUSH1 0x00 1412 60 PUSH1 0x0a 1414 60 PUSH1 0x00 1416 85 DUP6 1417 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 142C 16 AND 142D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1442 16 AND 1443 81 DUP2 1444 52 MSTORE 1445 60 PUSH1 0x20 1447 01 ADD 1448 90 SWAP1 1449 81 DUP2 144A 52 MSTORE 144B 60 PUSH1 0x20 144D 01 ADD 144E 60 PUSH1 0x00 1450 20 SHA3 1451 54 SLOAD 1452 81 DUP2 1453 52 MSTORE 1454 60 PUSH1 0x20 1456 01 ADD 1457 90 SWAP1 1458 81 DUP2 1459 52 MSTORE 145A 60 PUSH1 0x20 145C 01 ADD 145D 60 PUSH1 0x00 145F 20 SHA3 1460 60 PUSH1 0x00 1462 61 PUSH2 0x0100 1465 0A EXP 1466 81 DUP2 1467 54 SLOAD 1468 81 DUP2 1469 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 147E 02 MUL 147F 19 NOT 1480 16 AND 1481 90 SWAP1 1482 83 DUP4 1483 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1498 16 AND 1499 02 MUL 149A 17 OR 149B 90 SWAP1 149C 55 SSTORE 149D 50 POP 149E 61 PUSH2 0x14a6 14A1 83 DUP4 14A2 61 PUSH2 0x2c16 14A5 56 *JUMP // Stack delta = +1 // Outputs[10] // { // @13FB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1401 memory[0x20:0x40] = 0x04 // @140A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1444 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @144A memory[0x20:0x40] = 0x0a // @1453 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @1459 memory[0x20:0x40] = 0x0b // @149C storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @149E stack[-1] = 0x14a6 // @14A1 stack[0] = stack[-4] // } // Block ends with call to 0x2c16, returns to 0x14A6 label_14A6: // Incoming return from call to 0x2C16 at 0x14A5 // Inputs[11] // { // @14AB stack[-1] // @14AD storage[0x09] // @14B8 storage[0x09] // @14BD stack[-2] // @14F7 memory[0x00:0x40] // @1503 storage[0x09] // @1511 memory[0x00:0x40] // @1519 storage[keccak256(memory[0x00:0x40])] // @1552 stack[-3] // @1556 stack[-6] // @1557 stack[-5] // } 14A6 5B JUMPDEST 14A7 60 PUSH1 0x09 14A9 60 PUSH1 0x00 14AB 82 DUP3 14AC 82 DUP3 14AD 54 SLOAD 14AE 01 ADD 14AF 92 SWAP3 14B0 50 POP 14B1 50 POP 14B2 81 DUP2 14B3 90 SWAP1 14B4 55 SSTORE 14B5 50 POP 14B6 60 PUSH1 0x09 14B8 54 SLOAD 14B9 60 PUSH1 0x0a 14BB 60 PUSH1 0x00 14BD 83 DUP4 14BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14D3 16 AND 14D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14E9 16 AND 14EA 81 DUP2 14EB 52 MSTORE 14EC 60 PUSH1 0x20 14EE 01 ADD 14EF 90 SWAP1 14F0 81 DUP2 14F1 52 MSTORE 14F2 60 PUSH1 0x20 14F4 01 ADD 14F5 60 PUSH1 0x00 14F7 20 SHA3 14F8 81 DUP2 14F9 90 SWAP1 14FA 55 SSTORE 14FB 50 POP 14FC 80 DUP1 14FD 60 PUSH1 0x0b 14FF 60 PUSH1 0x00 1501 60 PUSH1 0x09 1503 54 SLOAD 1504 81 DUP2 1505 52 MSTORE 1506 60 PUSH1 0x20 1508 01 ADD 1509 90 SWAP1 150A 81 DUP2 150B 52 MSTORE 150C 60 PUSH1 0x20 150E 01 ADD 150F 60 PUSH1 0x00 1511 20 SHA3 1512 60 PUSH1 0x00 1514 61 PUSH2 0x0100 1517 0A EXP 1518 81 DUP2 1519 54 SLOAD 151A 81 DUP2 151B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1530 02 MUL 1531 19 NOT 1532 16 AND 1533 90 SWAP1 1534 83 DUP4 1535 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 154A 16 AND 154B 02 MUL 154C 17 OR 154D 90 SWAP1 154E 55 SSTORE 154F 50 POP 1550 60 PUSH1 0x01 1552 91 SWAP2 1553 50 POP 1554 5B JUMPDEST 1555 50 POP 1556 92 SWAP3 1557 91 SWAP2 1558 50 POP 1559 50 POP 155A 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @14B4 storage[0x09] = storage[0x09] + stack[-1] // @14EB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @14F1 memory[0x20:0x40] = 0x0a // @14FA storage[keccak256(memory[0x00:0x40])] = storage[0x09] // @1505 memory[0x00:0x20] = storage[0x09] // @150B memory[0x20:0x40] = 0x0b // @154E storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1556 stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_155B: // Incoming call from 0x0370, returns to 0x0371 // Inputs[1] { @1575 stack[-2] } 155B 5B JUMPDEST 155C 60 PUSH1 0x00 155E 80 DUP1 155F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1574 16 AND 1575 83 DUP4 1576 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 158B 16 AND 158C 14 EQ 158D 15 ISZERO 158E 15 ISZERO 158F 15 ISZERO 1590 61 PUSH2 0x1598 1593 57 *JUMPI // Stack delta = +1 // Outputs[1] { @155C stack[0] = 0x00 } // Block ends with conditional jump to 0x1598, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1594: // Incoming jump from 0x1593, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1597 memory[0x00:0x00] } 1594 60 PUSH1 0x00 1596 80 DUP1 1597 FD *REVERT // Stack delta = +0 // Outputs[1] { @1597 revert(memory[0x00:0x00]); } // Block terminates label_1598: // Incoming jump from 0x1593, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @159C stack[-2] // @15A1 msg.sender // @15DB memory[0x00:0x40] // @15DE stack[-3] // @1618 memory[0x00:0x40] // @1619 storage[keccak256(memory[0x00:0x40])] // } 1598 5B JUMPDEST 1599 61 PUSH2 0x1627 159C 82 DUP3 159D 60 PUSH1 0x05 159F 60 PUSH1 0x00 15A1 33 CALLER 15A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15B7 16 AND 15B8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15CD 16 AND 15CE 81 DUP2 15CF 52 MSTORE 15D0 60 PUSH1 0x20 15D2 01 ADD 15D3 90 SWAP1 15D4 81 DUP2 15D5 52 MSTORE 15D6 60 PUSH1 0x20 15D8 01 ADD 15D9 60 PUSH1 0x00 15DB 20 SHA3 15DC 60 PUSH1 0x00 15DE 86 DUP7 15DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15F4 16 AND 15F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 160A 16 AND 160B 81 DUP2 160C 52 MSTORE 160D 60 PUSH1 0x20 160F 01 ADD 1610 90 SWAP1 1611 81 DUP2 1612 52 MSTORE 1613 60 PUSH1 0x20 1615 01 ADD 1616 60 PUSH1 0x00 1618 20 SHA3 1619 54 SLOAD 161A 61 PUSH2 0x3023 161D 90 SWAP1 161E 91 SWAP2 161F 90 SWAP1 1620 63 PUSH4 0xffffffff 1625 16 AND 1626 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1599 stack[0] = 0x1627 // @15CF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @15D5 memory[0x20:0x40] = 0x05 // @160C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1612 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @161E stack[1] = storage[keccak256(memory[0x00:0x40])] // @161F stack[2] = stack[-2] // } // Block ends with call to 0xffffffff & 0x3023, returns to 0x1627 label_1627: // Incoming return from call to 0x3023 at 0x1626 // Inputs[15] // { // @162C msg.sender // @1666 memory[0x00:0x40] // @1669 stack[-4] // @16A3 memory[0x00:0x40] // @16A4 stack[-1] // @16BF msg.sender // @16FB msg.sender // @1735 memory[0x00:0x40] // @1772 memory[0x00:0x40] // @1773 storage[keccak256(memory[0x00:0x40])] // @1776 memory[0x40:0x60] // @1783 memory[0x40:0x60] // @1788 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @178B stack[-2] // @178D stack[-5] // } 1627 5B JUMPDEST 1628 60 PUSH1 0x05 162A 60 PUSH1 0x00 162C 33 CALLER 162D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1642 16 AND 1643 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1658 16 AND 1659 81 DUP2 165A 52 MSTORE 165B 60 PUSH1 0x20 165D 01 ADD 165E 90 SWAP1 165F 81 DUP2 1660 52 MSTORE 1661 60 PUSH1 0x20 1663 01 ADD 1664 60 PUSH1 0x00 1666 20 SHA3 1667 60 PUSH1 0x00 1669 85 DUP6 166A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 167F 16 AND 1680 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1695 16 AND 1696 81 DUP2 1697 52 MSTORE 1698 60 PUSH1 0x20 169A 01 ADD 169B 90 SWAP1 169C 81 DUP2 169D 52 MSTORE 169E 60 PUSH1 0x20 16A0 01 ADD 16A1 60 PUSH1 0x00 16A3 20 SHA3 16A4 81 DUP2 16A5 90 SWAP1 16A6 55 SSTORE 16A7 50 POP 16A8 82 DUP3 16A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16BE 16 AND 16BF 33 CALLER 16C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16D5 16 AND 16D6 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 16F7 60 PUSH1 0x05 16F9 60 PUSH1 0x00 16FB 33 CALLER 16FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1711 16 AND 1712 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1727 16 AND 1728 81 DUP2 1729 52 MSTORE 172A 60 PUSH1 0x20 172C 01 ADD 172D 90 SWAP1 172E 81 DUP2 172F 52 MSTORE 1730 60 PUSH1 0x20 1732 01 ADD 1733 60 PUSH1 0x00 1735 20 SHA3 1736 60 PUSH1 0x00 1738 87 DUP8 1739 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 174E 16 AND 174F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1764 16 AND 1765 81 DUP2 1766 52 MSTORE 1767 60 PUSH1 0x20 1769 01 ADD 176A 90 SWAP1 176B 81 DUP2 176C 52 MSTORE 176D 60 PUSH1 0x20 176F 01 ADD 1770 60 PUSH1 0x00 1772 20 SHA3 1773 54 SLOAD 1774 60 PUSH1 0x40 1776 51 MLOAD 1777 80 DUP1 1778 82 DUP3 1779 81 DUP2 177A 52 MSTORE 177B 60 PUSH1 0x20 177D 01 ADD 177E 91 SWAP2 177F 50 POP 1780 50 POP 1781 60 PUSH1 0x40 1783 51 MLOAD 1784 80 DUP1 1785 91 SWAP2 1786 03 SUB 1787 90 SWAP1 1788 A3 LOG3 1789 60 PUSH1 0x01 178B 90 SWAP1 178C 50 POP 178D 92 SWAP3 178E 91 SWAP2 178F 50 POP 1790 50 POP 1791 56 *JUMP // Stack delta = -4 // Outputs[12] // { // @165A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1660 memory[0x20:0x40] = 0x05 // @1697 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @169D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @16A6 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1729 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @172F memory[0x20:0x40] = 0x05 // @1766 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @176C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @177A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1788 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @178D stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_1792: // Incoming call from 0x03B5, returns to 0x03B6 // Incoming call from 0x0E7F, returns to 0x0E80 // Inputs[4] // { // @1799 stack[-1] // @17A7 memory[0x00:0x40] // @17AB storage[keccak256(memory[0x00:0x40])] // @17CB stack[-2] // } 1792 5B JUMPDEST 1793 60 PUSH1 0x00 1795 60 PUSH1 0x0b 1797 60 PUSH1 0x00 1799 83 DUP4 179A 81 DUP2 179B 52 MSTORE 179C 60 PUSH1 0x20 179E 01 ADD 179F 90 SWAP1 17A0 81 DUP2 17A1 52 MSTORE 17A2 60 PUSH1 0x20 17A4 01 ADD 17A5 60 PUSH1 0x00 17A7 20 SHA3 17A8 60 PUSH1 0x00 17AA 90 SWAP1 17AB 54 SLOAD 17AC 90 SWAP1 17AD 61 PUSH2 0x0100 17B0 0A EXP 17B1 90 SWAP1 17B2 04 DIV 17B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17C8 16 AND 17C9 90 SWAP1 17CA 50 POP 17CB 91 SWAP2 17CC 90 SWAP1 17CD 50 POP 17CE 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @179B memory[0x00:0x20] = stack[-1] // @17A1 memory[0x20:0x40] = 0x0b // @17CB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_17CF: // Incoming call from 0x0422, returns to 0x0423 // Incoming call from 0x1CD9, returns to 0x1CDA // Incoming call from 0x0ED6, returns to 0x0ED7 // Inputs[1] { @17D6 stack[-1] } 17CF 5B JUMPDEST 17D0 60 PUSH1 0x00 17D2 62 PUSH3 0x32df70 17D6 82 DUP3 17D7 14 EQ 17D8 15 ISZERO 17D9 61 PUSH2 0x17ec 17DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x17ec, if !(stack[-1] == 0x32df70) label_17DD: // Incoming jump from 0x17DC, if not !(stack[-1] == 0x32df70) // Inputs[1] { @17E0 msg.sender } 17DD 61 PUSH2 0x17e5 17E0 33 CALLER 17E1 61 PUSH2 0x1843 17E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @17DD stack[0] = 0x17e5 // @17E0 stack[1] = msg.sender // } // Block ends with call to 0x1843, returns to 0x17E5 label_17E5: // Incoming return from call to 0x1843 at 0x17E4 // Inputs[2] // { // @17E6 stack[-2] // @17E6 stack[-1] // } 17E5 5B JUMPDEST 17E6 90 SWAP1 17E7 50 POP 17E8 61 PUSH2 0x183e 17EB 56 *JUMP // Stack delta = -1 // Outputs[1] { @17E6 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x183e label_17EC: // Incoming jump from 0x17DC, if !(stack[-1] == 0x32df70) // Inputs[1] { @17F1 stack[-2] } 17EC 5B JUMPDEST 17ED 62 PUSH3 0x32e358 17F1 82 DUP3 17F2 14 EQ 17F3 15 ISZERO 17F4 61 PUSH2 0x1813 17F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1813, if !(stack[-2] == 0x32e358) label_17F8: // Incoming jump from 0x17F7, if not !(stack[-2] == 0x32e358) // Inputs[1] { @17FD msg.sender } 17F8 60 PUSH1 0x02 17FA 61 PUSH2 0x1802 17FD 33 CALLER 17FE 61 PUSH2 0x1843 1801 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17F8 stack[0] = 0x02 // @17FA stack[1] = 0x1802 // @17FD stack[2] = msg.sender // } // Block ends with call to 0x1843, returns to 0x1802 label_1802: // Incoming return from call to 0x1843 at 0x1801 // Inputs[1] { @1803 stack[-2] } 1802 5B JUMPDEST 1803 81 DUP2 1804 15 ISZERO 1805 15 ISZERO 1806 61 PUSH2 0x180b 1809 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x180b, if !!stack[-2] label_180A: // Incoming jump from 0x1809, if not !!stack[-2] 180A FE *ASSERT // Stack delta = +0 // Outputs[1] { @180A assert(); } // Block terminates label_180B: // Incoming jump from 0x1809, if !!stack[-2] // Inputs[3] // { // @180C stack[-1] // @180C stack[-2] // @180D stack[-3] // } 180B 5B JUMPDEST 180C 04 DIV 180D 90 SWAP1 180E 50 POP 180F 61 PUSH2 0x183e 1812 56 *JUMP // Stack delta = -2 // Outputs[1] { @180D stack[-3] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x183e label_1813: // Incoming jump from 0x17F7, if !(stack[-2] == 0x32e358) // Inputs[1] { @1818 stack[-2] } 1813 5B JUMPDEST 1814 62 PUSH3 0x32e740 1818 82 DUP3 1819 14 EQ 181A 15 ISZERO 181B 61 PUSH2 0x183a 181E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x183a, if !(stack[-2] == 0x32e740) label_181F: // Incoming jump from 0x181E, if not !(stack[-2] == 0x32e740) // Inputs[1] { @1824 msg.sender } 181F 60 PUSH1 0x04 1821 61 PUSH2 0x1829 1824 33 CALLER 1825 61 PUSH2 0x1843 1828 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @181F stack[0] = 0x04 // @1821 stack[1] = 0x1829 // @1824 stack[2] = msg.sender // } // Block ends with call to 0x1843, returns to 0x1829 label_1829: // Incoming return from call to 0x1843 at 0x1828 // Inputs[1] { @182A stack[-2] } 1829 5B JUMPDEST 182A 81 DUP2 182B 15 ISZERO 182C 15 ISZERO 182D 61 PUSH2 0x1832 1830 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1832, if !!stack[-2] label_1831: // Incoming jump from 0x1830, if not !!stack[-2] 1831 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1831 assert(); } // Block terminates label_1832: // Incoming jump from 0x1830, if !!stack[-2] // Inputs[3] // { // @1833 stack[-2] // @1833 stack[-1] // @1834 stack[-3] // } 1832 5B JUMPDEST 1833 04 DIV 1834 90 SWAP1 1835 50 POP 1836 61 PUSH2 0x183e 1839 56 *JUMP // Stack delta = -2 // Outputs[1] { @1834 stack[-3] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x183e label_183A: // Incoming jump from 0x181E, if !(stack[-2] == 0x32e740) // Inputs[3] // { // @183B stack[-2] // @183C stack[-1] // @183F stack[-3] // } 183A 5B JUMPDEST 183B 81 DUP2 183C 90 SWAP1 183D 50 POP 183E 5B JUMPDEST 183F 91 SWAP2 1840 90 SWAP1 1841 50 POP 1842 56 *JUMP // Stack delta = -2 // Outputs[1] { @183F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1843: // Incoming call from 0x1828, returns to 0x1829 // Incoming jump from 0x2BF9 // Incoming call from 0x17E4, returns to 0x17E5 // Incoming call from 0x1801, returns to 0x1802 // Incoming jump from 0x2AFA // Incoming jump from 0x2FE5 // Incoming jump from 0x2EE6 // Incoming call from 0x0479, returns to 0x047A // Inputs[4] // { // @184A stack[-1] // @1884 memory[0x00:0x40] // @1885 storage[keccak256(memory[0x00:0x40])] // @1888 stack[-2] // } 1843 5B JUMPDEST 1844 60 PUSH1 0x00 1846 60 PUSH1 0x04 1848 60 PUSH1 0x00 184A 83 DUP4 184B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1860 16 AND 1861 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1876 16 AND 1877 81 DUP2 1878 52 MSTORE 1879 60 PUSH1 0x20 187B 01 ADD 187C 90 SWAP1 187D 81 DUP2 187E 52 MSTORE 187F 60 PUSH1 0x20 1881 01 ADD 1882 60 PUSH1 0x00 1884 20 SHA3 1885 54 SLOAD 1886 90 SWAP1 1887 50 POP 1888 91 SWAP2 1889 90 SWAP1 188A 50 POP 188B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1878 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @187E memory[0x20:0x40] = 0x04 // @1888 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_188C: // Incoming call from 0x04D0, returns to 0x04D1 // Inputs[4] // { // @1893 stack[-1] // @18CD memory[0x00:0x40] // @18CE storage[keccak256(memory[0x00:0x40])] // @18D1 stack[-2] // } 188C 5B JUMPDEST 188D 60 PUSH1 0x00 188F 60 PUSH1 0x0a 1891 60 PUSH1 0x00 1893 83 DUP4 1894 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18A9 16 AND 18AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18BF 16 AND 18C0 81 DUP2 18C1 52 MSTORE 18C2 60 PUSH1 0x20 18C4 01 ADD 18C5 90 SWAP1 18C6 81 DUP2 18C7 52 MSTORE 18C8 60 PUSH1 0x20 18CA 01 ADD 18CB 60 PUSH1 0x00 18CD 20 SHA3 18CE 54 SLOAD 18CF 90 SWAP1 18D0 50 POP 18D1 91 SWAP2 18D2 90 SWAP1 18D3 50 POP 18D4 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @18C1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @18C7 memory[0x20:0x40] = 0x0a // @18D1 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_18D5: // Incoming call from 0x04FB, returns to 0x04FC // Inputs[3] // { // @18DB storage[0x01] // @18FC memory[0x40:0x60] // @190F storage[0x01] // } 18D5 5B JUMPDEST 18D6 60 PUSH1 0x60 18D8 60 PUSH1 0x01 18DA 80 DUP1 18DB 54 SLOAD 18DC 60 PUSH1 0x01 18DE 81 DUP2 18DF 60 PUSH1 0x01 18E1 16 AND 18E2 15 ISZERO 18E3 61 PUSH2 0x0100 18E6 02 MUL 18E7 03 SUB 18E8 16 AND 18E9 60 PUSH1 0x02 18EB 90 SWAP1 18EC 04 DIV 18ED 80 DUP1 18EE 60 PUSH1 0x1f 18F0 01 ADD 18F1 60 PUSH1 0x20 18F3 80 DUP1 18F4 91 SWAP2 18F5 04 DIV 18F6 02 MUL 18F7 60 PUSH1 0x20 18F9 01 ADD 18FA 60 PUSH1 0x40 18FC 51 MLOAD 18FD 90 SWAP1 18FE 81 DUP2 18FF 01 ADD 1900 60 PUSH1 0x40 1902 52 MSTORE 1903 80 DUP1 1904 92 SWAP3 1905 91 SWAP2 1906 90 SWAP1 1907 81 DUP2 1908 81 DUP2 1909 52 MSTORE 190A 60 PUSH1 0x20 190C 01 ADD 190D 82 DUP3 190E 80 DUP1 190F 54 SLOAD 1910 60 PUSH1 0x01 1912 81 DUP2 1913 60 PUSH1 0x01 1915 16 AND 1916 15 ISZERO 1917 61 PUSH2 0x0100 191A 02 MUL 191B 03 SUB 191C 16 AND 191D 60 PUSH1 0x02 191F 90 SWAP1 1920 04 DIV 1921 80 DUP1 1922 15 ISZERO 1923 61 PUSH2 0x196d 1926 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @18D6 stack[0] = 0x60 // @1902 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) / 0x20 * 0x20 // @1904 stack[1] = memory[0x40:0x60] // @1905 stack[2] = 0x01 // @1906 stack[3] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @1909 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @190C stack[4] = 0x20 + memory[0x40:0x60] // @190D stack[5] = 0x01 // @1920 stack[6] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // } // Block ends with conditional jump to 0x196d, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) label_1927: // Incoming jump from 0x1926, if not !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Inputs[1] { @1927 stack[-1] } 1927 80 DUP1 1928 60 PUSH1 0x1f 192A 10 LT 192B 61 PUSH2 0x1942 192E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1942, if 0x1f < stack[-1] label_192F: // Incoming jump from 0x192E, if not 0x1f < stack[-1] // Inputs[4] // { // @1933 stack[-2] // @1934 storage[stack[-2]] // @1937 stack[-3] // @1939 stack[-1] // } 192F 61 PUSH2 0x0100 1932 80 DUP1 1933 83 DUP4 1934 54 SLOAD 1935 04 DIV 1936 02 MUL 1937 83 DUP4 1938 52 MSTORE 1939 91 SWAP2 193A 60 PUSH1 0x20 193C 01 ADD 193D 91 SWAP2 193E 61 PUSH2 0x196d 1941 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1938 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @193D stack[-1] = stack[-1] // @193D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x196d label_1942: // Incoming jump from 0x192E, if 0x1f < stack[-1] // Inputs[5] // { // @1943 stack[-3] // @1944 stack[-1] // @1946 stack[-2] // @194E memory[0x00:0x20] // @1952 storage[keccak256(memory[0x00:0x20])] // } 1942 5B JUMPDEST 1943 82 DUP3 1944 01 ADD 1945 91 SWAP2 1946 90 SWAP1 1947 60 PUSH1 0x00 1949 52 MSTORE 194A 60 PUSH1 0x20 194C 60 PUSH1 0x00 194E 20 SHA3 194F 90 SWAP1 1950 5B JUMPDEST 1951 81 DUP2 1952 54 SLOAD 1953 81 DUP2 1954 52 MSTORE 1955 90 SWAP1 1956 60 PUSH1 0x01 1958 01 ADD 1959 90 SWAP1 195A 60 PUSH1 0x20 195C 01 ADD 195D 80 DUP1 195E 83 DUP4 195F 11 GT 1960 61 PUSH2 0x1950 1963 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1945 stack[-3] = stack[-3] + stack[-1] // @1949 memory[0x00:0x20] = stack[-2] // @1954 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1959 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @195C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1950, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1964: // Incoming jump from 0x1963, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1963, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1964 stack[-3] // @1965 stack[-1] // } 1964 82 DUP3 1965 90 SWAP1 1966 03 SUB 1967 60 PUSH1 0x1f 1969 16 AND 196A 82 DUP3 196B 01 ADD 196C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @196C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @196C stack[-1] = stack[-3] // } // Block continues label_196D: // Incoming jump from 0x196C // Incoming jump from 0x1926, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Incoming jump from 0x1941 // Inputs[3] // { // @1973 stack[-7] // @1973 stack[-6] // @1975 stack[-8] // } 196D 5B JUMPDEST 196E 50 POP 196F 50 POP 1970 50 POP 1971 50 POP 1972 50 POP 1973 90 SWAP1 1974 50 POP 1975 90 SWAP1 1976 56 *JUMP // Stack delta = -7 // Outputs[1] { @1975 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1977: // Incoming call from 0x05C1, returns to 0x05C2 // Inputs[1] { @1991 stack[-2] } 1977 5B JUMPDEST 1978 60 PUSH1 0x00 197A 80 DUP1 197B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1990 16 AND 1991 83 DUP4 1992 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19A7 16 AND 19A8 14 EQ 19A9 15 ISZERO 19AA 15 ISZERO 19AB 15 ISZERO 19AC 61 PUSH2 0x19b4 19AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1978 stack[0] = 0x00 } // Block ends with conditional jump to 0x19b4, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_19B0: // Incoming jump from 0x19AF, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @19B3 memory[0x00:0x00] } 19B0 60 PUSH1 0x00 19B2 80 DUP1 19B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @19B3 revert(memory[0x00:0x00]); } // Block terminates label_19B4: // Incoming jump from 0x19AF, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @19B8 stack[-2] // @19BD msg.sender // @19F7 memory[0x00:0x40] // @19FA stack[-3] // @1A34 memory[0x00:0x40] // @1A35 storage[keccak256(memory[0x00:0x40])] // } 19B4 5B JUMPDEST 19B5 61 PUSH2 0x1a43 19B8 82 DUP3 19B9 60 PUSH1 0x05 19BB 60 PUSH1 0x00 19BD 33 CALLER 19BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19D3 16 AND 19D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19E9 16 AND 19EA 81 DUP2 19EB 52 MSTORE 19EC 60 PUSH1 0x20 19EE 01 ADD 19EF 90 SWAP1 19F0 81 DUP2 19F1 52 MSTORE 19F2 60 PUSH1 0x20 19F4 01 ADD 19F5 60 PUSH1 0x00 19F7 20 SHA3 19F8 60 PUSH1 0x00 19FA 86 DUP7 19FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A10 16 AND 1A11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A26 16 AND 1A27 81 DUP2 1A28 52 MSTORE 1A29 60 PUSH1 0x20 1A2B 01 ADD 1A2C 90 SWAP1 1A2D 81 DUP2 1A2E 52 MSTORE 1A2F 60 PUSH1 0x20 1A31 01 ADD 1A32 60 PUSH1 0x00 1A34 20 SHA3 1A35 54 SLOAD 1A36 61 PUSH2 0x3002 1A39 90 SWAP1 1A3A 91 SWAP2 1A3B 90 SWAP1 1A3C 63 PUSH4 0xffffffff 1A41 16 AND 1A42 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @19B5 stack[0] = 0x1a43 // @19EB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @19F1 memory[0x20:0x40] = 0x05 // @1A28 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1A2E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1A3A stack[1] = storage[keccak256(memory[0x00:0x40])] // @1A3B stack[2] = stack[-2] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x1A43 label_1A43: // Incoming return from call to 0x3002 at 0x1A42 // Inputs[15] // { // @1A48 msg.sender // @1A82 memory[0x00:0x40] // @1A85 stack[-4] // @1ABF memory[0x00:0x40] // @1AC0 stack[-1] // @1ADB msg.sender // @1B17 msg.sender // @1B51 memory[0x00:0x40] // @1B8E memory[0x00:0x40] // @1B8F storage[keccak256(memory[0x00:0x40])] // @1B92 memory[0x40:0x60] // @1B9F memory[0x40:0x60] // @1BA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1BA7 stack[-2] // @1BA9 stack[-5] // } 1A43 5B JUMPDEST 1A44 60 PUSH1 0x05 1A46 60 PUSH1 0x00 1A48 33 CALLER 1A49 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A5E 16 AND 1A5F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A74 16 AND 1A75 81 DUP2 1A76 52 MSTORE 1A77 60 PUSH1 0x20 1A79 01 ADD 1A7A 90 SWAP1 1A7B 81 DUP2 1A7C 52 MSTORE 1A7D 60 PUSH1 0x20 1A7F 01 ADD 1A80 60 PUSH1 0x00 1A82 20 SHA3 1A83 60 PUSH1 0x00 1A85 85 DUP6 1A86 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A9B 16 AND 1A9C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AB1 16 AND 1AB2 81 DUP2 1AB3 52 MSTORE 1AB4 60 PUSH1 0x20 1AB6 01 ADD 1AB7 90 SWAP1 1AB8 81 DUP2 1AB9 52 MSTORE 1ABA 60 PUSH1 0x20 1ABC 01 ADD 1ABD 60 PUSH1 0x00 1ABF 20 SHA3 1AC0 81 DUP2 1AC1 90 SWAP1 1AC2 55 SSTORE 1AC3 50 POP 1AC4 82 DUP3 1AC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1ADA 16 AND 1ADB 33 CALLER 1ADC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AF1 16 AND 1AF2 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1B13 60 PUSH1 0x05 1B15 60 PUSH1 0x00 1B17 33 CALLER 1B18 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B2D 16 AND 1B2E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B43 16 AND 1B44 81 DUP2 1B45 52 MSTORE 1B46 60 PUSH1 0x20 1B48 01 ADD 1B49 90 SWAP1 1B4A 81 DUP2 1B4B 52 MSTORE 1B4C 60 PUSH1 0x20 1B4E 01 ADD 1B4F 60 PUSH1 0x00 1B51 20 SHA3 1B52 60 PUSH1 0x00 1B54 87 DUP8 1B55 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B6A 16 AND 1B6B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B80 16 AND 1B81 81 DUP2 1B82 52 MSTORE 1B83 60 PUSH1 0x20 1B85 01 ADD 1B86 90 SWAP1 1B87 81 DUP2 1B88 52 MSTORE 1B89 60 PUSH1 0x20 1B8B 01 ADD 1B8C 60 PUSH1 0x00 1B8E 20 SHA3 1B8F 54 SLOAD 1B90 60 PUSH1 0x40 1B92 51 MLOAD 1B93 80 DUP1 1B94 82 DUP3 1B95 81 DUP2 1B96 52 MSTORE 1B97 60 PUSH1 0x20 1B99 01 ADD 1B9A 91 SWAP2 1B9B 50 POP 1B9C 50 POP 1B9D 60 PUSH1 0x40 1B9F 51 MLOAD 1BA0 80 DUP1 1BA1 91 SWAP2 1BA2 03 SUB 1BA3 90 SWAP1 1BA4 A3 LOG3 1BA5 60 PUSH1 0x01 1BA7 90 SWAP1 1BA8 50 POP 1BA9 92 SWAP3 1BAA 91 SWAP2 1BAB 50 POP 1BAC 50 POP 1BAD 56 *JUMP // Stack delta = -4 // Outputs[12] // { // @1A76 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1A7C memory[0x20:0x40] = 0x05 // @1AB3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1AB9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1AC2 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1B45 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1B4B memory[0x20:0x40] = 0x05 // @1B82 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1B88 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1B96 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1BA4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @1BA9 stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_1BAE: // Incoming call from 0x0626, returns to 0x0627 // Inputs[4] // { // @1BB8 msg.sender // @1BF2 memory[0x00:0x40] // @1BF3 storage[keccak256(memory[0x00:0x40])] // @1BF4 stack[-1] // } 1BAE 5B JUMPDEST 1BAF 60 PUSH1 0x00 1BB1 80 DUP1 1BB2 60 PUSH1 0x00 1BB4 60 PUSH1 0x04 1BB6 60 PUSH1 0x00 1BB8 33 CALLER 1BB9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BCE 16 AND 1BCF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BE4 16 AND 1BE5 81 DUP2 1BE6 52 MSTORE 1BE7 60 PUSH1 0x20 1BE9 01 ADD 1BEA 90 SWAP1 1BEB 81 DUP2 1BEC 52 MSTORE 1BED 60 PUSH1 0x20 1BEF 01 ADD 1BF0 60 PUSH1 0x00 1BF2 20 SHA3 1BF3 54 SLOAD 1BF4 84 DUP5 1BF5 11 GT 1BF6 15 ISZERO 1BF7 15 ISZERO 1BF8 15 ISZERO 1BF9 61 PUSH2 0x1c01 1BFC 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @1BAF stack[0] = 0x00 // @1BB1 stack[1] = 0x00 // @1BB2 stack[2] = 0x00 // @1BE6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1BEC memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x1c01, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) label_1BFD: // Incoming jump from 0x1BFC, if not !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1C00 memory[0x00:0x00] } 1BFD 60 PUSH1 0x00 1BFF 80 DUP1 1C00 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C00 revert(memory[0x00:0x00]); } // Block terminates label_1C01: // Incoming jump from 0x1BFC, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1C1A stack[-5] } 1C01 5B JUMPDEST 1C02 60 PUSH1 0x00 1C04 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C19 16 AND 1C1A 85 DUP6 1C1B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C30 16 AND 1C31 14 EQ 1C32 15 ISZERO 1C33 15 ISZERO 1C34 15 ISZERO 1C35 61 PUSH2 0x1c3d 1C38 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c3d, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1C39: // Incoming jump from 0x1C38, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1C3C memory[0x00:0x00] } 1C39 60 PUSH1 0x00 1C3B 80 DUP1 1C3C FD *REVERT // Stack delta = +0 // Outputs[1] { @1C3C revert(memory[0x00:0x00]); } // Block terminates label_1C3D: // Incoming jump from 0x1C38, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1C43 storage[0x08] // @1C50 address(this) // @1C67 stack[-5] // } 1C3D 5B JUMPDEST 1C3E 60 PUSH1 0x08 1C40 60 PUSH1 0x00 1C42 81 DUP2 1C43 54 SLOAD 1C44 80 DUP1 1C45 92 SWAP3 1C46 91 SWAP2 1C47 90 SWAP1 1C48 60 PUSH1 0x01 1C4A 01 ADD 1C4B 91 SWAP2 1C4C 90 SWAP1 1C4D 50 POP 1C4E 55 SSTORE 1C4F 50 POP 1C50 30 ADDRESS 1C51 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C66 16 AND 1C67 85 DUP6 1C68 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C7D 16 AND 1C7E 14 EQ 1C7F 15 ISZERO 1C80 61 PUSH2 0x1d25 1C83 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C4E storage[0x08] = 0x01 + storage[0x08] } // Block ends with conditional jump to 0x1d25, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & address(this)) label_1C84: // Incoming jump from 0x1C83, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & address(this)) // Inputs[3] // { // @1C8A msg.sender // @1CC4 memory[0x00:0x40] // @1CC5 storage[keccak256(memory[0x00:0x40])] // } 1C84 60 PUSH1 0x00 1C86 60 PUSH1 0x06 1C88 60 PUSH1 0x00 1C8A 33 CALLER 1C8B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CA0 16 AND 1CA1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CB6 16 AND 1CB7 81 DUP2 1CB8 52 MSTORE 1CB9 60 PUSH1 0x20 1CBB 01 ADD 1CBC 90 SWAP1 1CBD 81 DUP2 1CBE 52 MSTORE 1CBF 60 PUSH1 0x20 1CC1 01 ADD 1CC2 60 PUSH1 0x00 1CC4 20 SHA3 1CC5 54 SLOAD 1CC6 14 EQ 1CC7 15 ISZERO 1CC8 15 ISZERO 1CC9 61 PUSH2 0x1cd1 1CCC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1CB8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1CBE memory[0x20:0x40] = 0x06 // } // Block ends with conditional jump to 0x1cd1, if !!(storage[keccak256(memory[0x00:0x40])] == 0x00) label_1CCD: // Incoming jump from 0x1CCC, if not !!(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[1] { @1CD0 memory[0x00:0x00] } 1CCD 60 PUSH1 0x00 1CCF 80 DUP1 1CD0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CD0 revert(memory[0x00:0x00]); } // Block terminates label_1CD1: // Incoming jump from 0x1CCC, if !!(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[1] { @1CD5 stack[-4] } 1CD1 5B JUMPDEST 1CD2 61 PUSH2 0x1cda 1CD5 84 DUP5 1CD6 61 PUSH2 0x17cf 1CD9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CD2 stack[0] = 0x1cda // @1CD5 stack[1] = stack[-4] // } // Block ends with call to 0x17cf, returns to 0x1CDA label_1CDA: // Incoming return from call to 0x17CF at 0x1CD9 // Incoming return from call to 0x17CF at 0x1CD9 // Inputs[4] // { // @1CDB stack[-5] // @1CDB stack[-1] // @1CE2 msg.sender // @1D1C memory[0x00:0x40] // } 1CDA 5B JUMPDEST 1CDB 93 SWAP4 1CDC 50 POP 1CDD 83 DUP4 1CDE 60 PUSH1 0x06 1CE0 60 PUSH1 0x00 1CE2 33 CALLER 1CE3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CF8 16 AND 1CF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D0E 16 AND 1D0F 81 DUP2 1D10 52 MSTORE 1D11 60 PUSH1 0x20 1D13 01 ADD 1D14 90 SWAP1 1D15 81 DUP2 1D16 52 MSTORE 1D17 60 PUSH1 0x20 1D19 01 ADD 1D1A 60 PUSH1 0x00 1D1C 20 SHA3 1D1D 81 DUP2 1D1E 90 SWAP1 1D1F 55 SSTORE 1D20 50 POP 1D21 61 PUSH2 0x2793 1D24 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1CDB stack[-5] = stack[-1] // @1D10 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1D16 memory[0x20:0x40] = 0x06 // @1D1F storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to 0x2793 label_1D25: // Incoming jump from 0x1C83, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & address(this)) // Inputs[2] // { // @1D26 msg.sender // @1D3D stack[-5] // } 1D25 5B JUMPDEST 1D26 33 CALLER 1D27 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D3C 16 AND 1D3D 85 DUP6 1D3E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D53 16 AND 1D54 14 EQ 1D55 15 ISZERO 1D56 61 PUSH2 0x20d8 1D59 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20d8, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) label_1D5A: // Incoming jump from 0x1D59, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[1] { @1D5D stack[-4] } 1D5A 61 PUSH2 0x1d62 1D5D 84 DUP5 1D5E 61 PUSH2 0x2a0e 1D61 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D5A stack[0] = 0x1d62 // @1D5D stack[1] = stack[-4] // } // Block ends with call to 0x2a0e, returns to 0x1D62 label_1D62: // Incoming return from call to 0x2A0E at 0x1D61 // Inputs[2] // { // @1D63 stack[-3] // @1D63 stack[-1] // } 1D62 5B JUMPDEST 1D63 91 SWAP2 1D64 50 POP 1D65 60 PUSH1 0x00 1D67 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D7C 16 AND 1D7D 82 DUP3 1D7E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D93 16 AND 1D94 14 EQ 1D95 15 ISZERO 1D96 61 PUSH2 0x1d9e 1D99 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1D63 stack[-3] = stack[-1] } // Block ends with conditional jump to 0x1d9e, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1D9A: // Incoming jump from 0x1D99, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1D9D memory[0x00:0x00] } 1D9A 60 PUSH1 0x00 1D9C 80 DUP1 1D9D FD *REVERT // Stack delta = +0 // Outputs[1] { @1D9D revert(memory[0x00:0x00]); } // Block terminates label_1D9E: // Incoming jump from 0x1D99, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @1DA6 msg.sender // @1DE0 memory[0x00:0x40] // @1DE1 storage[keccak256(memory[0x00:0x40])] // @1DE6 address(this) // @1E20 memory[0x00:0x40] // @1E21 storage[keccak256(memory[0x00:0x40])] // } 1D9E 5B JUMPDEST 1D9F 61 PUSH2 0x1e2f 1DA2 60 PUSH1 0x06 1DA4 60 PUSH1 0x00 1DA6 33 CALLER 1DA7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DBC 16 AND 1DBD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DD2 16 AND 1DD3 81 DUP2 1DD4 52 MSTORE 1DD5 60 PUSH1 0x20 1DD7 01 ADD 1DD8 90 SWAP1 1DD9 81 DUP2 1DDA 52 MSTORE 1DDB 60 PUSH1 0x20 1DDD 01 ADD 1DDE 60 PUSH1 0x00 1DE0 20 SHA3 1DE1 54 SLOAD 1DE2 60 PUSH1 0x04 1DE4 60 PUSH1 0x00 1DE6 30 ADDRESS 1DE7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DFC 16 AND 1DFD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E12 16 AND 1E13 81 DUP2 1E14 52 MSTORE 1E15 60 PUSH1 0x20 1E17 01 ADD 1E18 90 SWAP1 1E19 81 DUP2 1E1A 52 MSTORE 1E1B 60 PUSH1 0x20 1E1D 01 ADD 1E1E 60 PUSH1 0x00 1E20 20 SHA3 1E21 54 SLOAD 1E22 61 PUSH2 0x3002 1E25 90 SWAP1 1E26 91 SWAP2 1E27 90 SWAP1 1E28 63 PUSH4 0xffffffff 1E2D 16 AND 1E2E 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1D9F stack[0] = 0x1e2f // @1DD4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1DDA memory[0x20:0x40] = 0x06 // @1E14 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1E1A memory[0x20:0x40] = 0x04 // @1E26 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1E27 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x1E2F label_1E2F: // Incoming return from call to 0x3002 at 0x1E2E // Inputs[9] // { // @1E34 address(this) // @1E6E memory[0x00:0x40] // @1E6F stack[-1] // @1E7A msg.sender // @1EB4 memory[0x00:0x40] // @1EB5 storage[keccak256(memory[0x00:0x40])] // @1EBA stack[-3] // @1EF4 memory[0x00:0x40] // @1EF5 storage[keccak256(memory[0x00:0x40])] // } 1E2F 5B JUMPDEST 1E30 60 PUSH1 0x04 1E32 60 PUSH1 0x00 1E34 30 ADDRESS 1E35 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E4A 16 AND 1E4B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E60 16 AND 1E61 81 DUP2 1E62 52 MSTORE 1E63 60 PUSH1 0x20 1E65 01 ADD 1E66 90 SWAP1 1E67 81 DUP2 1E68 52 MSTORE 1E69 60 PUSH1 0x20 1E6B 01 ADD 1E6C 60 PUSH1 0x00 1E6E 20 SHA3 1E6F 81 DUP2 1E70 90 SWAP1 1E71 55 SSTORE 1E72 50 POP 1E73 61 PUSH2 0x1f03 1E76 60 PUSH1 0x06 1E78 60 PUSH1 0x00 1E7A 33 CALLER 1E7B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E90 16 AND 1E91 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EA6 16 AND 1EA7 81 DUP2 1EA8 52 MSTORE 1EA9 60 PUSH1 0x20 1EAB 01 ADD 1EAC 90 SWAP1 1EAD 81 DUP2 1EAE 52 MSTORE 1EAF 60 PUSH1 0x20 1EB1 01 ADD 1EB2 60 PUSH1 0x00 1EB4 20 SHA3 1EB5 54 SLOAD 1EB6 60 PUSH1 0x04 1EB8 60 PUSH1 0x00 1EBA 85 DUP6 1EBB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1ED0 16 AND 1ED1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EE6 16 AND 1EE7 81 DUP2 1EE8 52 MSTORE 1EE9 60 PUSH1 0x20 1EEB 01 ADD 1EEC 90 SWAP1 1EED 81 DUP2 1EEE 52 MSTORE 1EEF 60 PUSH1 0x20 1EF1 01 ADD 1EF2 60 PUSH1 0x00 1EF4 20 SHA3 1EF5 54 SLOAD 1EF6 61 PUSH2 0x3023 1EF9 90 SWAP1 1EFA 91 SWAP2 1EFB 90 SWAP1 1EFC 63 PUSH4 0xffffffff 1F01 16 AND 1F02 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @1E62 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1E68 memory[0x20:0x40] = 0x04 // @1E71 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1E73 stack[-1] = 0x1f03 // @1EA8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1EAE memory[0x20:0x40] = 0x06 // @1EE8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1EEE memory[0x20:0x40] = 0x04 // @1EFA stack[0] = storage[keccak256(memory[0x00:0x40])] // @1EFB stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0xffffffff & 0x3023, returns to 0x1F03 label_1F03: // Incoming return from call to 0x3023 at 0x1F02 // Inputs[11] // { // @1F08 stack[-3] // @1F42 memory[0x00:0x40] // @1F43 stack[-1] // @1F4D msg.sender // @1F87 memory[0x00:0x40] // @1F96 stack[-6] // @1FD0 memory[0x00:0x40] // @1FD1 storage[keccak256(memory[0x00:0x40])] // @1FDF memory[0x00:0x40] // @1FE7 storage[keccak256(memory[0x00:0x40])] // @2021 stack[-5] // } 1F03 5B JUMPDEST 1F04 60 PUSH1 0x04 1F06 60 PUSH1 0x00 1F08 84 DUP5 1F09 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F1E 16 AND 1F1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F34 16 AND 1F35 81 DUP2 1F36 52 MSTORE 1F37 60 PUSH1 0x20 1F39 01 ADD 1F3A 90 SWAP1 1F3B 81 DUP2 1F3C 52 MSTORE 1F3D 60 PUSH1 0x20 1F3F 01 ADD 1F40 60 PUSH1 0x00 1F42 20 SHA3 1F43 81 DUP2 1F44 90 SWAP1 1F45 55 SSTORE 1F46 50 POP 1F47 60 PUSH1 0x00 1F49 60 PUSH1 0x06 1F4B 60 PUSH1 0x00 1F4D 33 CALLER 1F4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F63 16 AND 1F64 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F79 16 AND 1F7A 81 DUP2 1F7B 52 MSTORE 1F7C 60 PUSH1 0x20 1F7E 01 ADD 1F7F 90 SWAP1 1F80 81 DUP2 1F81 52 MSTORE 1F82 60 PUSH1 0x20 1F84 01 ADD 1F85 60 PUSH1 0x00 1F87 20 SHA3 1F88 81 DUP2 1F89 90 SWAP1 1F8A 55 SSTORE 1F8B 50 POP 1F8C 60 PUSH1 0x00 1F8E 60 PUSH1 0x0b 1F90 60 PUSH1 0x00 1F92 60 PUSH1 0x0a 1F94 60 PUSH1 0x00 1F96 89 DUP10 1F97 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FAC 16 AND 1FAD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FC2 16 AND 1FC3 81 DUP2 1FC4 52 MSTORE 1FC5 60 PUSH1 0x20 1FC7 01 ADD 1FC8 90 SWAP1 1FC9 81 DUP2 1FCA 52 MSTORE 1FCB 60 PUSH1 0x20 1FCD 01 ADD 1FCE 60 PUSH1 0x00 1FD0 20 SHA3 1FD1 54 SLOAD 1FD2 81 DUP2 1FD3 52 MSTORE 1FD4 60 PUSH1 0x20 1FD6 01 ADD 1FD7 90 SWAP1 1FD8 81 DUP2 1FD9 52 MSTORE 1FDA 60 PUSH1 0x20 1FDC 01 ADD 1FDD 60 PUSH1 0x00 1FDF 20 SHA3 1FE0 60 PUSH1 0x00 1FE2 61 PUSH2 0x0100 1FE5 0A EXP 1FE6 81 DUP2 1FE7 54 SLOAD 1FE8 81 DUP2 1FE9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FFE 02 MUL 1FFF 19 NOT 2000 16 AND 2001 90 SWAP1 2002 83 DUP4 2003 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2018 16 AND 2019 02 MUL 201A 17 OR 201B 90 SWAP1 201C 55 SSTORE 201D 50 POP 201E 61 PUSH2 0x2026 2021 84 DUP5 2022 61 PUSH2 0x2c16 2025 56 *JUMP // Stack delta = +1 // Outputs[13] // { // @1F36 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1F3C memory[0x20:0x40] = 0x04 // @1F45 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1F7B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1F81 memory[0x20:0x40] = 0x06 // @1F8A storage[keccak256(memory[0x00:0x40])] = 0x00 // @1FC4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1FCA memory[0x20:0x40] = 0x0a // @1FD3 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @1FD9 memory[0x20:0x40] = 0x0b // @201C storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @201E stack[-1] = 0x2026 // @2021 stack[0] = stack[-5] // } // Block ends with call to 0x2c16, returns to 0x2026 label_2026: // Incoming return from call to 0x2C16 at 0x2025 // Inputs[9] // { // @202B stack[-1] // @202D storage[0x09] // @2038 storage[0x09] // @203D stack[-6] // @2077 memory[0x00:0x40] // @2083 storage[0x09] // @2091 memory[0x00:0x40] // @2099 storage[keccak256(memory[0x00:0x40])] // @20D2 stack[-4] // } 2026 5B JUMPDEST 2027 60 PUSH1 0x09 2029 60 PUSH1 0x00 202B 82 DUP3 202C 82 DUP3 202D 54 SLOAD 202E 01 ADD 202F 92 SWAP3 2030 50 POP 2031 50 POP 2032 81 DUP2 2033 90 SWAP1 2034 55 SSTORE 2035 50 POP 2036 60 PUSH1 0x09 2038 54 SLOAD 2039 60 PUSH1 0x0a 203B 60 PUSH1 0x00 203D 87 DUP8 203E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2053 16 AND 2054 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2069 16 AND 206A 81 DUP2 206B 52 MSTORE 206C 60 PUSH1 0x20 206E 01 ADD 206F 90 SWAP1 2070 81 DUP2 2071 52 MSTORE 2072 60 PUSH1 0x20 2074 01 ADD 2075 60 PUSH1 0x00 2077 20 SHA3 2078 81 DUP2 2079 90 SWAP1 207A 55 SSTORE 207B 50 POP 207C 84 DUP5 207D 60 PUSH1 0x0b 207F 60 PUSH1 0x00 2081 60 PUSH1 0x09 2083 54 SLOAD 2084 81 DUP2 2085 52 MSTORE 2086 60 PUSH1 0x20 2088 01 ADD 2089 90 SWAP1 208A 81 DUP2 208B 52 MSTORE 208C 60 PUSH1 0x20 208E 01 ADD 208F 60 PUSH1 0x00 2091 20 SHA3 2092 60 PUSH1 0x00 2094 61 PUSH2 0x0100 2097 0A EXP 2098 81 DUP2 2099 54 SLOAD 209A 81 DUP2 209B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20B0 02 MUL 20B1 19 NOT 20B2 16 AND 20B3 90 SWAP1 20B4 83 DUP4 20B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20CA 16 AND 20CB 02 MUL 20CC 17 OR 20CD 90 SWAP1 20CE 55 SSTORE 20CF 50 POP 20D0 60 PUSH1 0x01 20D2 92 SWAP3 20D3 50 POP 20D4 61 PUSH2 0x2a06 20D7 56 *JUMP // Stack delta = -1 // Outputs[8] // { // @2034 storage[0x09] = storage[0x09] + stack[-1] // @206B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2071 memory[0x20:0x40] = 0x0a // @207A storage[keccak256(memory[0x00:0x40])] = storage[0x09] // @2085 memory[0x00:0x20] = storage[0x09] // @208B memory[0x20:0x40] = 0x0b // @20CE storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-6]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @20D2 stack[-4] = 0x01 // } // Block ends with unconditional jump to 0x2a06 label_20D8: // Incoming jump from 0x1D59, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[2] // { // @20DE storage[0x07] // @2112 stack[-5] // } 20D8 5B JUMPDEST 20D9 60 PUSH1 0x07 20DB 60 PUSH1 0x00 20DD 90 SWAP1 20DE 54 SLOAD 20DF 90 SWAP1 20E0 61 PUSH2 0x0100 20E3 0A EXP 20E4 90 SWAP1 20E5 04 DIV 20E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20FB 16 AND 20FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2111 16 AND 2112 85 DUP6 2113 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2128 16 AND 2129 14 EQ 212A 15 ISZERO 212B 61 PUSH2 0x24ad 212E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x24ad, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00) label_212F: // Incoming jump from 0x212E, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00) // Inputs[1] { @2132 stack[-4] } 212F 61 PUSH2 0x2137 2132 84 DUP5 2133 61 PUSH2 0x2df8 2136 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @212F stack[0] = 0x2137 // @2132 stack[1] = stack[-4] // } // Block ends with call to 0x2df8, returns to 0x2137 label_2137: // Incoming return from call to 0x2DF8 at 0x2136 // Inputs[2] // { // @2138 stack[-2] // @2138 stack[-1] // } 2137 5B JUMPDEST 2138 90 SWAP1 2139 50 POP 213A 60 PUSH1 0x00 213C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2151 16 AND 2152 81 DUP2 2153 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2168 16 AND 2169 14 EQ 216A 15 ISZERO 216B 61 PUSH2 0x2173 216E 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2138 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2173, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_216F: // Incoming jump from 0x216E, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2172 memory[0x00:0x00] } 216F 60 PUSH1 0x00 2171 80 DUP1 2172 FD *REVERT // Stack delta = +0 // Outputs[1] { @2172 revert(memory[0x00:0x00]); } // Block terminates label_2173: // Incoming jump from 0x216E, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @217B msg.sender // @21B5 memory[0x00:0x40] // @21B6 storage[keccak256(memory[0x00:0x40])] // @21BB address(this) // @21F5 memory[0x00:0x40] // @21F6 storage[keccak256(memory[0x00:0x40])] // } 2173 5B JUMPDEST 2174 61 PUSH2 0x2204 2177 60 PUSH1 0x06 2179 60 PUSH1 0x00 217B 33 CALLER 217C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2191 16 AND 2192 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21A7 16 AND 21A8 81 DUP2 21A9 52 MSTORE 21AA 60 PUSH1 0x20 21AC 01 ADD 21AD 90 SWAP1 21AE 81 DUP2 21AF 52 MSTORE 21B0 60 PUSH1 0x20 21B2 01 ADD 21B3 60 PUSH1 0x00 21B5 20 SHA3 21B6 54 SLOAD 21B7 60 PUSH1 0x04 21B9 60 PUSH1 0x00 21BB 30 ADDRESS 21BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21D1 16 AND 21D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21E7 16 AND 21E8 81 DUP2 21E9 52 MSTORE 21EA 60 PUSH1 0x20 21EC 01 ADD 21ED 90 SWAP1 21EE 81 DUP2 21EF 52 MSTORE 21F0 60 PUSH1 0x20 21F2 01 ADD 21F3 60 PUSH1 0x00 21F5 20 SHA3 21F6 54 SLOAD 21F7 61 PUSH2 0x3002 21FA 90 SWAP1 21FB 91 SWAP2 21FC 90 SWAP1 21FD 63 PUSH4 0xffffffff 2202 16 AND 2203 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @2174 stack[0] = 0x2204 // @21A9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @21AF memory[0x20:0x40] = 0x06 // @21E9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @21EF memory[0x20:0x40] = 0x04 // @21FB stack[1] = storage[keccak256(memory[0x00:0x40])] // @21FC stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x2204 label_2204: // Incoming return from call to 0x3002 at 0x2203 // Inputs[9] // { // @2209 address(this) // @2243 memory[0x00:0x40] // @2244 stack[-1] // @224F msg.sender // @2289 memory[0x00:0x40] // @228A storage[keccak256(memory[0x00:0x40])] // @228F stack[-2] // @22C9 memory[0x00:0x40] // @22CA storage[keccak256(memory[0x00:0x40])] // } 2204 5B JUMPDEST 2205 60 PUSH1 0x04 2207 60 PUSH1 0x00 2209 30 ADDRESS 220A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 221F 16 AND 2220 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2235 16 AND 2236 81 DUP2 2237 52 MSTORE 2238 60 PUSH1 0x20 223A 01 ADD 223B 90 SWAP1 223C 81 DUP2 223D 52 MSTORE 223E 60 PUSH1 0x20 2240 01 ADD 2241 60 PUSH1 0x00 2243 20 SHA3 2244 81 DUP2 2245 90 SWAP1 2246 55 SSTORE 2247 50 POP 2248 61 PUSH2 0x22d8 224B 60 PUSH1 0x06 224D 60 PUSH1 0x00 224F 33 CALLER 2250 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2265 16 AND 2266 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 227B 16 AND 227C 81 DUP2 227D 52 MSTORE 227E 60 PUSH1 0x20 2280 01 ADD 2281 90 SWAP1 2282 81 DUP2 2283 52 MSTORE 2284 60 PUSH1 0x20 2286 01 ADD 2287 60 PUSH1 0x00 2289 20 SHA3 228A 54 SLOAD 228B 60 PUSH1 0x04 228D 60 PUSH1 0x00 228F 84 DUP5 2290 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22A5 16 AND 22A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22BB 16 AND 22BC 81 DUP2 22BD 52 MSTORE 22BE 60 PUSH1 0x20 22C0 01 ADD 22C1 90 SWAP1 22C2 81 DUP2 22C3 52 MSTORE 22C4 60 PUSH1 0x20 22C6 01 ADD 22C7 60 PUSH1 0x00 22C9 20 SHA3 22CA 54 SLOAD 22CB 61 PUSH2 0x3023 22CE 90 SWAP1 22CF 91 SWAP2 22D0 90 SWAP1 22D1 63 PUSH4 0xffffffff 22D6 16 AND 22D7 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @2237 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @223D memory[0x20:0x40] = 0x04 // @2246 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2248 stack[-1] = 0x22d8 // @227D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2283 memory[0x20:0x40] = 0x06 // @22BD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @22C3 memory[0x20:0x40] = 0x04 // @22CF stack[0] = storage[keccak256(memory[0x00:0x40])] // @22D0 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0xffffffff & 0x3023, returns to 0x22D8 label_22D8: // Incoming return from call to 0x3023 at 0x22D7 // Inputs[11] // { // @22DD stack[-2] // @2317 memory[0x00:0x40] // @2318 stack[-1] // @2322 msg.sender // @235C memory[0x00:0x40] // @236B stack[-6] // @23A5 memory[0x00:0x40] // @23A6 storage[keccak256(memory[0x00:0x40])] // @23B4 memory[0x00:0x40] // @23BC storage[keccak256(memory[0x00:0x40])] // @23F6 stack[-5] // } 22D8 5B JUMPDEST 22D9 60 PUSH1 0x04 22DB 60 PUSH1 0x00 22DD 83 DUP4 22DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22F3 16 AND 22F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2309 16 AND 230A 81 DUP2 230B 52 MSTORE 230C 60 PUSH1 0x20 230E 01 ADD 230F 90 SWAP1 2310 81 DUP2 2311 52 MSTORE 2312 60 PUSH1 0x20 2314 01 ADD 2315 60 PUSH1 0x00 2317 20 SHA3 2318 81 DUP2 2319 90 SWAP1 231A 55 SSTORE 231B 50 POP 231C 60 PUSH1 0x00 231E 60 PUSH1 0x06 2320 60 PUSH1 0x00 2322 33 CALLER 2323 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2338 16 AND 2339 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 234E 16 AND 234F 81 DUP2 2350 52 MSTORE 2351 60 PUSH1 0x20 2353 01 ADD 2354 90 SWAP1 2355 81 DUP2 2356 52 MSTORE 2357 60 PUSH1 0x20 2359 01 ADD 235A 60 PUSH1 0x00 235C 20 SHA3 235D 81 DUP2 235E 90 SWAP1 235F 55 SSTORE 2360 50 POP 2361 60 PUSH1 0x00 2363 60 PUSH1 0x0b 2365 60 PUSH1 0x00 2367 60 PUSH1 0x0a 2369 60 PUSH1 0x00 236B 89 DUP10 236C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2381 16 AND 2382 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2397 16 AND 2398 81 DUP2 2399 52 MSTORE 239A 60 PUSH1 0x20 239C 01 ADD 239D 90 SWAP1 239E 81 DUP2 239F 52 MSTORE 23A0 60 PUSH1 0x20 23A2 01 ADD 23A3 60 PUSH1 0x00 23A5 20 SHA3 23A6 54 SLOAD 23A7 81 DUP2 23A8 52 MSTORE 23A9 60 PUSH1 0x20 23AB 01 ADD 23AC 90 SWAP1 23AD 81 DUP2 23AE 52 MSTORE 23AF 60 PUSH1 0x20 23B1 01 ADD 23B2 60 PUSH1 0x00 23B4 20 SHA3 23B5 60 PUSH1 0x00 23B7 61 PUSH2 0x0100 23BA 0A EXP 23BB 81 DUP2 23BC 54 SLOAD 23BD 81 DUP2 23BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23D3 02 MUL 23D4 19 NOT 23D5 16 AND 23D6 90 SWAP1 23D7 83 DUP4 23D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23ED 16 AND 23EE 02 MUL 23EF 17 OR 23F0 90 SWAP1 23F1 55 SSTORE 23F2 50 POP 23F3 61 PUSH2 0x23fb 23F6 84 DUP5 23F7 61 PUSH2 0x2c16 23FA 56 *JUMP // Stack delta = +1 // Outputs[13] // { // @230B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2311 memory[0x20:0x40] = 0x04 // @231A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2350 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2356 memory[0x20:0x40] = 0x06 // @235F storage[keccak256(memory[0x00:0x40])] = 0x00 // @2399 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @239F memory[0x20:0x40] = 0x0a // @23A8 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @23AE memory[0x20:0x40] = 0x0b // @23F1 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @23F3 stack[-1] = 0x23fb // @23F6 stack[0] = stack[-5] // } // Block ends with call to 0x2c16, returns to 0x23FB label_23FB: // Incoming return from call to 0x2C16 at 0x23FA // Inputs[9] // { // @2400 stack[-1] // @2402 storage[0x09] // @240D storage[0x09] // @2412 stack[-6] // @244C memory[0x00:0x40] // @2458 storage[0x09] // @2466 memory[0x00:0x40] // @246E storage[keccak256(memory[0x00:0x40])] // @24A7 stack[-4] // } 23FB 5B JUMPDEST 23FC 60 PUSH1 0x09 23FE 60 PUSH1 0x00 2400 82 DUP3 2401 82 DUP3 2402 54 SLOAD 2403 01 ADD 2404 92 SWAP3 2405 50 POP 2406 50 POP 2407 81 DUP2 2408 90 SWAP1 2409 55 SSTORE 240A 50 POP 240B 60 PUSH1 0x09 240D 54 SLOAD 240E 60 PUSH1 0x0a 2410 60 PUSH1 0x00 2412 87 DUP8 2413 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2428 16 AND 2429 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 243E 16 AND 243F 81 DUP2 2440 52 MSTORE 2441 60 PUSH1 0x20 2443 01 ADD 2444 90 SWAP1 2445 81 DUP2 2446 52 MSTORE 2447 60 PUSH1 0x20 2449 01 ADD 244A 60 PUSH1 0x00 244C 20 SHA3 244D 81 DUP2 244E 90 SWAP1 244F 55 SSTORE 2450 50 POP 2451 84 DUP5 2452 60 PUSH1 0x0b 2454 60 PUSH1 0x00 2456 60 PUSH1 0x09 2458 54 SLOAD 2459 81 DUP2 245A 52 MSTORE 245B 60 PUSH1 0x20 245D 01 ADD 245E 90 SWAP1 245F 81 DUP2 2460 52 MSTORE 2461 60 PUSH1 0x20 2463 01 ADD 2464 60 PUSH1 0x00 2466 20 SHA3 2467 60 PUSH1 0x00 2469 61 PUSH2 0x0100 246C 0A EXP 246D 81 DUP2 246E 54 SLOAD 246F 81 DUP2 2470 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2485 02 MUL 2486 19 NOT 2487 16 AND 2488 90 SWAP1 2489 83 DUP4 248A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 249F 16 AND 24A0 02 MUL 24A1 17 OR 24A2 90 SWAP1 24A3 55 SSTORE 24A4 50 POP 24A5 60 PUSH1 0x01 24A7 92 SWAP3 24A8 50 POP 24A9 61 PUSH2 0x2a06 24AC 56 *JUMP // Stack delta = -1 // Outputs[8] // { // @2409 storage[0x09] = storage[0x09] + stack[-1] // @2440 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2446 memory[0x20:0x40] = 0x0a // @244F storage[keccak256(memory[0x00:0x40])] = storage[0x09] // @245A memory[0x00:0x20] = storage[0x09] // @2460 memory[0x20:0x40] = 0x0b // @24A3 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-6]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @24A7 stack[-4] = 0x01 // } // Block ends with unconditional jump to 0x2a06 label_24AD: // Incoming jump from 0x212E, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00) // Inputs[1] { @24B0 stack[-4] } 24AD 5B JUMPDEST 24AE 60 PUSH1 0x00 24B0 84 DUP5 24B1 14 EQ 24B2 15 ISZERO 24B3 61 PUSH2 0x2792 24B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2792, if !(stack[-4] == 0x00) label_24B7: // Incoming jump from 0x24B6, if not !(stack[-4] == 0x00) // Inputs[3] // { // @24BD msg.sender // @24F7 memory[0x00:0x40] // @24F9 storage[keccak256(memory[0x00:0x40])] // } 24B7 60 PUSH1 0x00 24B9 60 PUSH1 0x0c 24BB 60 PUSH1 0x00 24BD 33 CALLER 24BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24D3 16 AND 24D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24E9 16 AND 24EA 81 DUP2 24EB 52 MSTORE 24EC 60 PUSH1 0x20 24EE 01 ADD 24EF 90 SWAP1 24F0 81 DUP2 24F1 52 MSTORE 24F2 60 PUSH1 0x20 24F4 01 ADD 24F5 60 PUSH1 0x00 24F7 20 SHA3 24F8 80 DUP1 24F9 54 SLOAD 24FA 90 SWAP1 24FB 50 POP 24FC 14 EQ 24FD 15 ISZERO 24FE 61 PUSH2 0x26ee 2501 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @24EB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @24F1 memory[0x20:0x40] = 0x0c // } // Block ends with conditional jump to 0x26ee, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_2502: // Incoming jump from 0x2501, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[21] // { // @2506 msg.sender // @2540 memory[0x00:0x40] // @2548 storage[keccak256(memory[0x00:0x40])] // @255E memory[0x00:0x20] // @256E storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] // @25AA msg.sender // @25E4 memory[0x00:0x40] // @25EC storage[keccak256(memory[0x00:0x40])] // @2602 memory[0x00:0x20] // @2612 storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] // @264E msg.sender // @2688 memory[0x00:0x40] // @2690 storage[keccak256(memory[0x00:0x40])] // @26A6 memory[0x00:0x20] // @26B6 storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] // @26F3 msg.sender // @272D memory[0x00:0x40] // @272E stack[-5] // @2734 storage[keccak256(memory[0x00:0x40])] // @274A memory[0x00:0x20] // @275A storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] // } 2502 60 PUSH1 0x0c 2504 60 PUSH1 0x00 2506 33 CALLER 2507 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 251C 16 AND 251D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2532 16 AND 2533 81 DUP2 2534 52 MSTORE 2535 60 PUSH1 0x20 2537 01 ADD 2538 90 SWAP1 2539 81 DUP2 253A 52 MSTORE 253B 60 PUSH1 0x20 253D 01 ADD 253E 60 PUSH1 0x00 2540 20 SHA3 2541 60 PUSH1 0x00 2543 90 SWAP1 2544 80 DUP1 2545 60 PUSH1 0x01 2547 81 DUP2 2548 54 SLOAD 2549 01 ADD 254A 80 DUP1 254B 82 DUP3 254C 55 SSTORE 254D 80 DUP1 254E 91 SWAP2 254F 50 POP 2550 50 POP 2551 90 SWAP1 2552 60 PUSH1 0x01 2554 82 DUP3 2555 03 SUB 2556 90 SWAP1 2557 60 PUSH1 0x00 2559 52 MSTORE 255A 60 PUSH1 0x20 255C 60 PUSH1 0x00 255E 20 SHA3 255F 01 ADD 2560 60 PUSH1 0x00 2562 90 SWAP1 2563 91 SWAP2 2564 92 SWAP3 2565 90 SWAP1 2566 91 SWAP2 2567 90 SWAP1 2568 91 SWAP2 2569 61 PUSH2 0x0100 256C 0A EXP 256D 81 DUP2 256E 54 SLOAD 256F 81 DUP2 2570 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2585 02 MUL 2586 19 NOT 2587 16 AND 2588 90 SWAP1 2589 83 DUP4 258A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 259F 16 AND 25A0 02 MUL 25A1 17 OR 25A2 90 SWAP1 25A3 55 SSTORE 25A4 50 POP 25A5 50 POP 25A6 60 PUSH1 0x0c 25A8 60 PUSH1 0x00 25AA 33 CALLER 25AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25C0 16 AND 25C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25D6 16 AND 25D7 81 DUP2 25D8 52 MSTORE 25D9 60 PUSH1 0x20 25DB 01 ADD 25DC 90 SWAP1 25DD 81 DUP2 25DE 52 MSTORE 25DF 60 PUSH1 0x20 25E1 01 ADD 25E2 60 PUSH1 0x00 25E4 20 SHA3 25E5 60 PUSH1 0x00 25E7 90 SWAP1 25E8 80 DUP1 25E9 60 PUSH1 0x01 25EB 81 DUP2 25EC 54 SLOAD 25ED 01 ADD 25EE 80 DUP1 25EF 82 DUP3 25F0 55 SSTORE 25F1 80 DUP1 25F2 91 SWAP2 25F3 50 POP 25F4 50 POP 25F5 90 SWAP1 25F6 60 PUSH1 0x01 25F8 82 DUP3 25F9 03 SUB 25FA 90 SWAP1 25FB 60 PUSH1 0x00 25FD 52 MSTORE 25FE 60 PUSH1 0x20 2600 60 PUSH1 0x00 2602 20 SHA3 2603 01 ADD 2604 60 PUSH1 0x00 2606 90 SWAP1 2607 91 SWAP2 2608 92 SWAP3 2609 90 SWAP1 260A 91 SWAP2 260B 90 SWAP1 260C 91 SWAP2 260D 61 PUSH2 0x0100 2610 0A EXP 2611 81 DUP2 2612 54 SLOAD 2613 81 DUP2 2614 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2629 02 MUL 262A 19 NOT 262B 16 AND 262C 90 SWAP1 262D 83 DUP4 262E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2643 16 AND 2644 02 MUL 2645 17 OR 2646 90 SWAP1 2647 55 SSTORE 2648 50 POP 2649 50 POP 264A 60 PUSH1 0x0c 264C 60 PUSH1 0x00 264E 33 CALLER 264F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2664 16 AND 2665 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 267A 16 AND 267B 81 DUP2 267C 52 MSTORE 267D 60 PUSH1 0x20 267F 01 ADD 2680 90 SWAP1 2681 81 DUP2 2682 52 MSTORE 2683 60 PUSH1 0x20 2685 01 ADD 2686 60 PUSH1 0x00 2688 20 SHA3 2689 60 PUSH1 0x00 268B 90 SWAP1 268C 80 DUP1 268D 60 PUSH1 0x01 268F 81 DUP2 2690 54 SLOAD 2691 01 ADD 2692 80 DUP1 2693 82 DUP3 2694 55 SSTORE 2695 80 DUP1 2696 91 SWAP2 2697 50 POP 2698 50 POP 2699 90 SWAP1 269A 60 PUSH1 0x01 269C 82 DUP3 269D 03 SUB 269E 90 SWAP1 269F 60 PUSH1 0x00 26A1 52 MSTORE 26A2 60 PUSH1 0x20 26A4 60 PUSH1 0x00 26A6 20 SHA3 26A7 01 ADD 26A8 60 PUSH1 0x00 26AA 90 SWAP1 26AB 91 SWAP2 26AC 92 SWAP3 26AD 90 SWAP1 26AE 91 SWAP2 26AF 90 SWAP1 26B0 91 SWAP2 26B1 61 PUSH2 0x0100 26B4 0A EXP 26B5 81 DUP2 26B6 54 SLOAD 26B7 81 DUP2 26B8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26CD 02 MUL 26CE 19 NOT 26CF 16 AND 26D0 90 SWAP1 26D1 83 DUP4 26D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26E7 16 AND 26E8 02 MUL 26E9 17 OR 26EA 90 SWAP1 26EB 55 SSTORE 26EC 50 POP 26ED 50 POP 26EE 5B JUMPDEST 26EF 60 PUSH1 0x0c 26F1 60 PUSH1 0x00 26F3 33 CALLER 26F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2709 16 AND 270A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 271F 16 AND 2720 81 DUP2 2721 52 MSTORE 2722 60 PUSH1 0x20 2724 01 ADD 2725 90 SWAP1 2726 81 DUP2 2727 52 MSTORE 2728 60 PUSH1 0x20 272A 01 ADD 272B 60 PUSH1 0x00 272D 20 SHA3 272E 85 DUP6 272F 90 SWAP1 2730 80 DUP1 2731 60 PUSH1 0x01 2733 81 DUP2 2734 54 SLOAD 2735 01 ADD 2736 80 DUP1 2737 82 DUP3 2738 55 SSTORE 2739 80 DUP1 273A 91 SWAP2 273B 50 POP 273C 50 POP 273D 90 SWAP1 273E 60 PUSH1 0x01 2740 82 DUP3 2741 03 SUB 2742 90 SWAP1 2743 60 PUSH1 0x00 2745 52 MSTORE 2746 60 PUSH1 0x20 2748 60 PUSH1 0x00 274A 20 SHA3 274B 01 ADD 274C 60 PUSH1 0x00 274E 90 SWAP1 274F 91 SWAP2 2750 92 SWAP3 2751 90 SWAP1 2752 91 SWAP2 2753 90 SWAP1 2754 91 SWAP2 2755 61 PUSH2 0x0100 2758 0A EXP 2759 81 DUP2 275A 54 SLOAD 275B 81 DUP2 275C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2771 02 MUL 2772 19 NOT 2773 16 AND 2774 90 SWAP1 2775 83 DUP4 2776 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 278B 16 AND 278C 02 MUL 278D 17 OR 278E 90 SWAP1 278F 55 SSTORE 2790 50 POP 2791 50 POP // Stack delta = +0 // Outputs[20] // { // @2534 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @253A memory[0x20:0x40] = 0x0c // @254C storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @2559 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @25A3 storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)]) // @25D8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @25DE memory[0x20:0x40] = 0x0c // @25F0 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @25FD memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @2647 storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)]) // @267C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2682 memory[0x20:0x40] = 0x0c // @2694 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @26A1 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @26EB storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)]) // @2721 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2727 memory[0x20:0x40] = 0x0c // @2738 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @2745 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @278F storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-5]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x20]) + ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01)]) // } // Block continues label_2792: // Incoming jump from 0x2791 // Incoming jump from 0x2791 // Incoming jump from 0x24B6, if !(stack[-4] == 0x00) // Inputs[6] // { // @279E stack[-5] // @27D8 memory[0x00:0x40] // @27D9 storage[keccak256(memory[0x00:0x40])] // @27E7 memory[0x00:0x40] // @27EF storage[keccak256(memory[0x00:0x40])] // @2829 stack[-4] // } 2792 5B JUMPDEST 2793 5B JUMPDEST 2794 60 PUSH1 0x00 2796 60 PUSH1 0x0b 2798 60 PUSH1 0x00 279A 60 PUSH1 0x0a 279C 60 PUSH1 0x00 279E 89 DUP10 279F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27B4 16 AND 27B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27CA 16 AND 27CB 81 DUP2 27CC 52 MSTORE 27CD 60 PUSH1 0x20 27CF 01 ADD 27D0 90 SWAP1 27D1 81 DUP2 27D2 52 MSTORE 27D3 60 PUSH1 0x20 27D5 01 ADD 27D6 60 PUSH1 0x00 27D8 20 SHA3 27D9 54 SLOAD 27DA 81 DUP2 27DB 52 MSTORE 27DC 60 PUSH1 0x20 27DE 01 ADD 27DF 90 SWAP1 27E0 81 DUP2 27E1 52 MSTORE 27E2 60 PUSH1 0x20 27E4 01 ADD 27E5 60 PUSH1 0x00 27E7 20 SHA3 27E8 60 PUSH1 0x00 27EA 61 PUSH2 0x0100 27ED 0A EXP 27EE 81 DUP2 27EF 54 SLOAD 27F0 81 DUP2 27F1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2806 02 MUL 2807 19 NOT 2808 16 AND 2809 90 SWAP1 280A 83 DUP4 280B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2820 16 AND 2821 02 MUL 2822 17 OR 2823 90 SWAP1 2824 55 SSTORE 2825 50 POP 2826 61 PUSH2 0x282e 2829 84 DUP5 282A 61 PUSH2 0x2c16 282D 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @27CC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @27D2 memory[0x20:0x40] = 0x0a // @27DB memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @27E1 memory[0x20:0x40] = 0x0b // @2824 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2826 stack[0] = 0x282e // @2829 stack[1] = stack[-4] // } // Block ends with call to 0x2c16, returns to 0x282E label_282E: // Incoming return from call to 0x2C16 at 0x282D // Incoming return from call to 0x2C16 at 0x282D // Inputs[12] // { // @2833 stack[-1] // @2835 storage[0x09] // @2840 storage[0x09] // @2845 stack[-6] // @287F memory[0x00:0x40] // @288B storage[0x09] // @2899 memory[0x00:0x40] // @28A1 storage[keccak256(memory[0x00:0x40])] // @28DB stack[-5] // @28E0 msg.sender // @291A memory[0x00:0x40] // @291B storage[keccak256(memory[0x00:0x40])] // } 282E 5B JUMPDEST 282F 60 PUSH1 0x09 2831 60 PUSH1 0x00 2833 82 DUP3 2834 82 DUP3 2835 54 SLOAD 2836 01 ADD 2837 92 SWAP3 2838 50 POP 2839 50 POP 283A 81 DUP2 283B 90 SWAP1 283C 55 SSTORE 283D 50 POP 283E 60 PUSH1 0x09 2840 54 SLOAD 2841 60 PUSH1 0x0a 2843 60 PUSH1 0x00 2845 87 DUP8 2846 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 285B 16 AND 285C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2871 16 AND 2872 81 DUP2 2873 52 MSTORE 2874 60 PUSH1 0x20 2876 01 ADD 2877 90 SWAP1 2878 81 DUP2 2879 52 MSTORE 287A 60 PUSH1 0x20 287C 01 ADD 287D 60 PUSH1 0x00 287F 20 SHA3 2880 81 DUP2 2881 90 SWAP1 2882 55 SSTORE 2883 50 POP 2884 84 DUP5 2885 60 PUSH1 0x0b 2887 60 PUSH1 0x00 2889 60 PUSH1 0x09 288B 54 SLOAD 288C 81 DUP2 288D 52 MSTORE 288E 60 PUSH1 0x20 2890 01 ADD 2891 90 SWAP1 2892 81 DUP2 2893 52 MSTORE 2894 60 PUSH1 0x20 2896 01 ADD 2897 60 PUSH1 0x00 2899 20 SHA3 289A 60 PUSH1 0x00 289C 61 PUSH2 0x0100 289F 0A EXP 28A0 81 DUP2 28A1 54 SLOAD 28A2 81 DUP2 28A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28B8 02 MUL 28B9 19 NOT 28BA 16 AND 28BB 90 SWAP1 28BC 83 DUP4 28BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28D2 16 AND 28D3 02 MUL 28D4 17 OR 28D5 90 SWAP1 28D6 55 SSTORE 28D7 50 POP 28D8 61 PUSH2 0x2929 28DB 84 DUP5 28DC 60 PUSH1 0x04 28DE 60 PUSH1 0x00 28E0 33 CALLER 28E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28F6 16 AND 28F7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 290C 16 AND 290D 81 DUP2 290E 52 MSTORE 290F 60 PUSH1 0x20 2911 01 ADD 2912 90 SWAP1 2913 81 DUP2 2914 52 MSTORE 2915 60 PUSH1 0x20 2917 01 ADD 2918 60 PUSH1 0x00 291A 20 SHA3 291B 54 SLOAD 291C 61 PUSH2 0x3002 291F 90 SWAP1 2920 91 SWAP2 2921 90 SWAP1 2922 63 PUSH4 0xffffffff 2927 16 AND 2928 56 *JUMP // Stack delta = +2 // Outputs[12] // { // @283C storage[0x09] = storage[0x09] + stack[-1] // @2873 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2879 memory[0x20:0x40] = 0x0a // @2882 storage[keccak256(memory[0x00:0x40])] = storage[0x09] // @288D memory[0x00:0x20] = storage[0x09] // @2893 memory[0x20:0x40] = 0x0b // @28D6 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-6]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @28D8 stack[-1] = 0x2929 // @290E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2914 memory[0x20:0x40] = 0x04 // @2920 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2921 stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x3002, returns to 0x2929 label_2929: // Incoming return from call to 0x3002 at 0x2928 // Inputs[7] // { // @292E msg.sender // @2968 memory[0x00:0x40] // @2969 stack[-1] // @2970 stack[-5] // @2975 stack[-6] // @29AF memory[0x00:0x40] // @29B0 storage[keccak256(memory[0x00:0x40])] // } 2929 5B JUMPDEST 292A 60 PUSH1 0x04 292C 60 PUSH1 0x00 292E 33 CALLER 292F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2944 16 AND 2945 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 295A 16 AND 295B 81 DUP2 295C 52 MSTORE 295D 60 PUSH1 0x20 295F 01 ADD 2960 90 SWAP1 2961 81 DUP2 2962 52 MSTORE 2963 60 PUSH1 0x20 2965 01 ADD 2966 60 PUSH1 0x00 2968 20 SHA3 2969 81 DUP2 296A 90 SWAP1 296B 55 SSTORE 296C 50 POP 296D 61 PUSH2 0x29be 2970 84 DUP5 2971 60 PUSH1 0x04 2973 60 PUSH1 0x00 2975 88 DUP9 2976 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 298B 16 AND 298C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29A1 16 AND 29A2 81 DUP2 29A3 52 MSTORE 29A4 60 PUSH1 0x20 29A6 01 ADD 29A7 90 SWAP1 29A8 81 DUP2 29A9 52 MSTORE 29AA 60 PUSH1 0x20 29AC 01 ADD 29AD 60 PUSH1 0x00 29AF 20 SHA3 29B0 54 SLOAD 29B1 61 PUSH2 0x3023 29B4 90 SWAP1 29B5 91 SWAP2 29B6 90 SWAP1 29B7 63 PUSH4 0xffffffff 29BC 16 AND 29BD 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @295C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2962 memory[0x20:0x40] = 0x04 // @296B storage[keccak256(memory[0x00:0x40])] = stack[-1] // @296D stack[-1] = 0x29be // @29A3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @29A9 memory[0x20:0x40] = 0x04 // @29B5 stack[0] = storage[keccak256(memory[0x00:0x40])] // @29B6 stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x3023, returns to 0x29BE label_29BE: // Incoming return from call to 0x3023 at 0x29BD // Inputs[5] // { // @29C3 stack[-6] // @29FD memory[0x00:0x40] // @29FE stack[-1] // @2A04 stack[-4] // @2A09 stack[-7] // } 29BE 5B JUMPDEST 29BF 60 PUSH1 0x04 29C1 60 PUSH1 0x00 29C3 87 DUP8 29C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29D9 16 AND 29DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29EF 16 AND 29F0 81 DUP2 29F1 52 MSTORE 29F2 60 PUSH1 0x20 29F4 01 ADD 29F5 90 SWAP1 29F6 81 DUP2 29F7 52 MSTORE 29F8 60 PUSH1 0x20 29FA 01 ADD 29FB 60 PUSH1 0x00 29FD 20 SHA3 29FE 81 DUP2 29FF 90 SWAP1 2A00 55 SSTORE 2A01 50 POP 2A02 60 PUSH1 0x01 2A04 92 SWAP3 2A05 50 POP 2A06 5B JUMPDEST 2A07 50 POP 2A08 50 POP 2A09 92 SWAP3 2A0A 91 SWAP2 2A0B 50 POP 2A0C 50 POP 2A0D 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @29F1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @29F7 memory[0x20:0x40] = 0x04 // @2A00 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2A09 stack[-7] = 0x01 // } // Block ends with unconditional jump to stack[-7] label_2A0E: // Incoming call from 0x1D61, returns to 0x1D62 // Incoming call from 0x066B, returns to 0x066C // Inputs[3] // { // @2A22 msg.sender // @2A5C memory[0x00:0x40] // @2A5E storage[keccak256(memory[0x00:0x40])] // } 2A0E 5B JUMPDEST 2A0F 60 PUSH1 0x00 2A11 80 DUP1 2A12 60 PUSH1 0x00 2A14 80 DUP1 2A15 60 PUSH1 0x00 2A17 92 SWAP3 2A18 50 POP 2A19 60 PUSH1 0x03 2A1B 90 SWAP1 2A1C 50 POP 2A1D 5B JUMPDEST 2A1E 60 PUSH1 0x0c 2A20 60 PUSH1 0x00 2A22 33 CALLER 2A23 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A38 16 AND 2A39 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A4E 16 AND 2A4F 81 DUP2 2A50 52 MSTORE 2A51 60 PUSH1 0x20 2A53 01 ADD 2A54 90 SWAP1 2A55 81 DUP2 2A56 52 MSTORE 2A57 60 PUSH1 0x20 2A59 01 ADD 2A5A 60 PUSH1 0x00 2A5C 20 SHA3 2A5D 80 DUP1 2A5E 54 SLOAD 2A5F 90 SWAP1 2A60 50 POP 2A61 81 DUP2 2A62 10 LT 2A63 15 ISZERO 2A64 61 PUSH2 0x2c0b 2A67 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @2A0F stack[0] = 0x00 // @2A12 stack[2] = 0x00 // @2A17 stack[1] = 0x00 // @2A1B stack[3] = 0x03 // @2A50 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2A56 memory[0x20:0x40] = 0x0c // } // Block ends with conditional jump to 0x2c0b, if !(0x03 < storage[keccak256(memory[0x00:0x40])]) label_2A68: // Incoming jump from 0x2A67, if not !(0x03 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x2A67, if not !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @2A6A stack[-1] // @2A6B stack[-5] // } 2A68 60 PUSH1 0x00 2A6A 81 DUP2 2A6B 86 DUP7 2A6C 81 DUP2 2A6D 15 ISZERO 2A6E 15 ISZERO 2A6F 61 PUSH2 0x2a74 2A72 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2A68 stack[0] = 0x00 // @2A6A stack[1] = stack[-1] // @2A6B stack[2] = stack[-5] // } // Block ends with conditional jump to 0x2a74, if !!stack[-1] label_2A73: // Incoming jump from 0x2A72, if not !!stack[-1] 2A73 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2A73 assert(); } // Block terminates label_2A74: // Incoming jump from 0x2A72, if !!stack[-1] // Inputs[3] // { // @2A75 stack[-1] // @2A75 stack[-2] // @2A76 stack[-3] // } 2A74 5B JUMPDEST 2A75 06 MOD 2A76 14 EQ 2A77 15 ISZERO 2A78 61 PUSH2 0x2bfe 2A7B 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2bfe, if !(stack[-1] % stack[-2] == stack[-3]) label_2A7C: // Incoming jump from 0x2A7B, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[5] // { // @2A7C stack[-3] // @2A84 msg.sender // @2ABE memory[0x00:0x40] // @2ABF stack[-1] // @2AC1 storage[keccak256(memory[0x00:0x40])] // } 2A7C 82 DUP3 2A7D 61 PUSH2 0x2afb 2A80 60 PUSH1 0x0c 2A82 60 PUSH1 0x00 2A84 33 CALLER 2A85 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A9A 16 AND 2A9B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AB0 16 AND 2AB1 81 DUP2 2AB2 52 MSTORE 2AB3 60 PUSH1 0x20 2AB5 01 ADD 2AB6 90 SWAP1 2AB7 81 DUP2 2AB8 52 MSTORE 2AB9 60 PUSH1 0x20 2ABB 01 ADD 2ABC 60 PUSH1 0x00 2ABE 20 SHA3 2ABF 83 DUP4 2AC0 81 DUP2 2AC1 54 SLOAD 2AC2 81 DUP2 2AC3 10 LT 2AC4 15 ISZERO 2AC5 15 ISZERO 2AC6 61 PUSH2 0x2acb 2AC9 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @2A7C stack[0] = stack[-3] // @2A7D stack[1] = 0x2afb // @2AB2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2AB8 memory[0x20:0x40] = 0x0c // @2ABE stack[2] = keccak256(memory[0x00:0x40]) // @2ABF stack[3] = stack[-1] // } // Block ends with conditional call to 0x2acb, returns to 0x2AFB, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) label_2ACA: // Incoming jump from 0x2AC9, if not !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) 2ACA FE *ASSERT // Stack delta = +0 // Outputs[1] { @2ACA assert(); } // Block terminates label_2ACB: // Incoming call from 0x2AC9, returns to 0x2AFB, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2ACC stack[-2] // @2ACC stack[-1] // @2AD4 memory[0x00:0x20] // @2AD9 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } 2ACB 5B JUMPDEST 2ACC 90 SWAP1 2ACD 60 PUSH1 0x00 2ACF 52 MSTORE 2AD0 60 PUSH1 0x20 2AD2 60 PUSH1 0x00 2AD4 20 SHA3 2AD5 01 ADD 2AD6 60 PUSH1 0x00 2AD8 90 SWAP1 2AD9 54 SLOAD 2ADA 90 SWAP1 2ADB 61 PUSH2 0x0100 2ADE 0A EXP 2ADF 90 SWAP1 2AE0 04 DIV 2AE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AF6 16 AND 2AF7 61 PUSH2 0x1843 2AFA 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2ACF memory[0x00:0x20] = stack[-2] // @2AF6 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20]) + stack[-1]] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to 0x1843 label_2AFB: // Incoming return from call to 0x2ACB at 0x2AC9 // Inputs[2] // { // @2AFC stack[-2] // @2AFC stack[-1] // } 2AFB 5B JUMPDEST 2AFC 10 LT 2AFD 15 ISZERO 2AFE 15 ISZERO 2AFF 61 PUSH2 0x2bfd 2B02 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2bfd, if !!(stack[-1] < stack[-2]) label_2B03: // Incoming jump from 0x2B02, if not !!(stack[-1] < stack[-2]) // Inputs[4] // { // @2B07 msg.sender // @2B41 memory[0x00:0x40] // @2B42 stack[-1] // @2B44 storage[keccak256(memory[0x00:0x40])] // } 2B03 60 PUSH1 0x0c 2B05 60 PUSH1 0x00 2B07 33 CALLER 2B08 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B1D 16 AND 2B1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B33 16 AND 2B34 81 DUP2 2B35 52 MSTORE 2B36 60 PUSH1 0x20 2B38 01 ADD 2B39 90 SWAP1 2B3A 81 DUP2 2B3B 52 MSTORE 2B3C 60 PUSH1 0x20 2B3E 01 ADD 2B3F 60 PUSH1 0x00 2B41 20 SHA3 2B42 81 DUP2 2B43 81 DUP2 2B44 54 SLOAD 2B45 81 DUP2 2B46 10 LT 2B47 15 ISZERO 2B48 15 ISZERO 2B49 61 PUSH2 0x2b4e 2B4C 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2B35 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2B3B memory[0x20:0x40] = 0x0c // @2B41 stack[0] = keccak256(memory[0x00:0x40]) // @2B42 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2b4e, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) label_2B4D: // Incoming jump from 0x2B4C, if not !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) 2B4D FE *ASSERT // Stack delta = +0 // Outputs[1] { @2B4D assert(); } // Block terminates label_2B4E: // Incoming jump from 0x2B4C, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @2B4F stack[-1] // @2B4F stack[-2] // @2B57 memory[0x00:0x20] // @2B5C storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2B7A stack[-4] // @2B83 msg.sender // @2BBD memory[0x00:0x40] // @2BBE stack[-3] // @2BC0 storage[keccak256(memory[0x00:0x40])] // } 2B4E 5B JUMPDEST 2B4F 90 SWAP1 2B50 60 PUSH1 0x00 2B52 52 MSTORE 2B53 60 PUSH1 0x20 2B55 60 PUSH1 0x00 2B57 20 SHA3 2B58 01 ADD 2B59 60 PUSH1 0x00 2B5B 90 SWAP1 2B5C 54 SLOAD 2B5D 90 SWAP1 2B5E 61 PUSH2 0x0100 2B61 0A EXP 2B62 90 SWAP1 2B63 04 DIV 2B64 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B79 16 AND 2B7A 91 SWAP2 2B7B 50 POP 2B7C 61 PUSH2 0x2bfa 2B7F 60 PUSH1 0x0c 2B81 60 PUSH1 0x00 2B83 33 CALLER 2B84 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B99 16 AND 2B9A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BAF 16 AND 2BB0 81 DUP2 2BB1 52 MSTORE 2BB2 60 PUSH1 0x20 2BB4 01 ADD 2BB5 90 SWAP1 2BB6 81 DUP2 2BB7 52 MSTORE 2BB8 60 PUSH1 0x20 2BBA 01 ADD 2BBB 60 PUSH1 0x00 2BBD 20 SHA3 2BBE 82 DUP3 2BBF 81 DUP2 2BC0 54 SLOAD 2BC1 81 DUP2 2BC2 10 LT 2BC3 15 ISZERO 2BC4 15 ISZERO 2BC5 61 PUSH2 0x2bca 2BC8 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @2B52 memory[0x00:0x20] = stack[-2] // @2B7A stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20]) + stack[-1]] / 0x0100 ** 0x00 // @2B7C stack[-2] = 0x2bfa // @2BB1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2BB7 memory[0x20:0x40] = 0x0c // @2BBD stack[-1] = keccak256(memory[0x00:0x40]) // @2BBE stack[0] = stack[-3] // } // Block ends with conditional call to 0x2bca, returns to 0x2BFA, if !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) label_2BC9: // Incoming jump from 0x2BC8, if not !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) 2BC9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2BC9 assert(); } // Block terminates label_2BCA: // Incoming call from 0x2BC8, returns to 0x2BFA, if !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2BCB stack[-1] // @2BCB stack[-2] // @2BD3 memory[0x00:0x20] // @2BD8 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } 2BCA 5B JUMPDEST 2BCB 90 SWAP1 2BCC 60 PUSH1 0x00 2BCE 52 MSTORE 2BCF 60 PUSH1 0x20 2BD1 60 PUSH1 0x00 2BD3 20 SHA3 2BD4 01 ADD 2BD5 60 PUSH1 0x00 2BD7 90 SWAP1 2BD8 54 SLOAD 2BD9 90 SWAP1 2BDA 61 PUSH2 0x0100 2BDD 0A EXP 2BDE 90 SWAP1 2BDF 04 DIV 2BE0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BF5 16 AND 2BF6 61 PUSH2 0x1843 2BF9 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2BCE memory[0x00:0x20] = stack[-2] // @2BF5 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20]) + stack[-1]] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to 0x1843 label_2BFA: // Incoming return from call to 0x2BCA at 0x2BC8 // Inputs[2] // { // @2BFB stack[-1] // @2BFB stack[-4] // } 2BFA 5B JUMPDEST 2BFB 92 SWAP3 2BFC 50 POP // Stack delta = -1 // Outputs[1] { @2BFB stack[-4] = stack[-1] } // Block continues label_2BFD: // Incoming jump from 0x2BFC // Incoming jump from 0x2B02, if !!(stack[-1] < stack[-2]) 2BFD 5B JUMPDEST // Stack delta = +0 // Block continues label_2BFE: // Incoming jump from 0x2BFD // Incoming jump from 0x2A7B, if !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2BFF stack[-1] } 2BFE 5B JUMPDEST 2BFF 80 DUP1 2C00 80 DUP1 2C01 60 PUSH1 0x01 2C03 01 ADD 2C04 91 SWAP2 2C05 50 POP 2C06 50 POP 2C07 61 PUSH2 0x2a1d 2C0A 56 *JUMP // Stack delta = +0 // Outputs[1] { @2C04 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x2a1d label_2C0B: // Incoming jump from 0x2A67, if !(0x03 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x2A67, if !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2C0C stack[-2] // @2C0D stack[-4] // @2C12 stack[-6] // @2C13 stack[-5] // } 2C0B 5B JUMPDEST 2C0C 81 DUP2 2C0D 93 SWAP4 2C0E 50 POP 2C0F 50 POP 2C10 50 POP 2C11 50 POP 2C12 91 SWAP2 2C13 90 SWAP1 2C14 50 POP 2C15 56 *JUMP // Stack delta = -5 // Outputs[1] { @2C12 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_2C16: // Incoming call from 0x14A5, returns to 0x14A6 // Incoming call from 0x282D, returns to 0x282E // Incoming call from 0x06D8, returns to 0x06D9 // Incoming call from 0x282D, returns to 0x282E // Incoming call from 0x2025, returns to 0x2026 // Incoming call from 0x0B6F, returns to 0x0B70 // Incoming call from 0x1041, returns to 0x1042 // Incoming call from 0x23FA, returns to 0x23FB // Inputs[1] { @2C1C msg.sender } 2C16 5B JUMPDEST 2C17 60 PUSH1 0x00 2C19 80 DUP1 2C1A 60 PUSH1 0x10 2C1C 33 CALLER 2C1D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C32 16 AND 2C33 81 DUP2 2C34 15 ISZERO 2C35 15 ISZERO 2C36 61 PUSH2 0x2c3b 2C39 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2C17 stack[0] = 0x00 // @2C19 stack[1] = 0x00 // @2C1A stack[2] = 0x10 // @2C32 stack[3] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // } // Block ends with conditional jump to 0x2c3b, if !!0x10 label_2C3A: // Incoming jump from 0x2C39, if not !!0x10 2C3A FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C3A assert(); } // Block terminates label_2C3B: // Incoming jump from 0x2C39, if !!0x10 // Inputs[5] // { // @2C3C stack[-1] // @2C3C stack[-2] // @2C3D stack[-3] // @2C44 storage[0x08] // @2C53 stack[-5] // } 2C3B 5B JUMPDEST 2C3C 06 MOD 2C3D 90 SWAP1 2C3E 50 POP 2C3F 60 PUSH1 0x08 2C41 60 PUSH1 0x00 2C43 81 DUP2 2C44 54 SLOAD 2C45 80 DUP1 2C46 92 SWAP3 2C47 91 SWAP2 2C48 90 SWAP1 2C49 60 PUSH1 0x01 2C4B 01 ADD 2C4C 91 SWAP2 2C4D 90 SWAP1 2C4E 50 POP 2C4F 55 SSTORE 2C50 50 POP 2C51 60 PUSH1 0x00 2C53 83 DUP4 2C54 14 EQ 2C55 15 ISZERO 2C56 61 PUSH2 0x2c64 2C59 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2C3D stack[-3] = stack[-1] % stack[-2] // @2C4F storage[0x08] = 0x01 + storage[0x08] // } // Block ends with conditional jump to 0x2c64, if !(stack[-5] == 0x00) label_2C5A: // Incoming jump from 0x2C59, if not !(stack[-5] == 0x00) // Inputs[1] { @2C5C stack[-1] } 2C5A 60 PUSH1 0x01 2C5C 81 DUP2 2C5D 01 ADD 2C5E 90 SWAP1 2C5F 50 POP 2C60 61 PUSH2 0x2c94 2C63 56 *JUMP // Stack delta = +0 // Outputs[1] { @2C5E stack[-1] = stack[-1] + 0x01 } // Block ends with unconditional jump to 0x2c94 label_2C64: // Incoming jump from 0x2C59, if !(stack[-5] == 0x00) // Inputs[1] { @2C6B stack[-3] } 2C64 5B JUMPDEST 2C65 64 PUSH5 0x174876e800 2C6B 83 DUP4 2C6C 10 LT 2C6D 15 ISZERO 2C6E 15 ISZERO 2C6F 61 PUSH2 0x2c7d 2C72 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2c7d, if !!(stack[-3] < 0x174876e800) label_2C73: // Incoming jump from 0x2C72, if not !!(stack[-3] < 0x174876e800) // Inputs[1] { @2C75 stack[-1] } 2C73 60 PUSH1 0x02 2C75 81 DUP2 2C76 01 ADD 2C77 90 SWAP1 2C78 50 POP 2C79 61 PUSH2 0x2c93 2C7C 56 *JUMP // Stack delta = +0 // Outputs[1] { @2C77 stack[-1] = stack[-1] + 0x02 } // Block ends with unconditional jump to 0x2c93 label_2C7D: // Incoming jump from 0x2C72, if !!(stack[-3] < 0x174876e800) // Inputs[1] { @2C84 stack[-3] } 2C7D 5B JUMPDEST 2C7E 64 PUSH5 0x174876e800 2C84 83 DUP4 2C85 11 GT 2C86 15 ISZERO 2C87 15 ISZERO 2C88 61 PUSH2 0x2c92 2C8B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2c92, if !!(stack[-3] > 0x174876e800) label_2C8C: // Incoming jump from 0x2C8B, if not !!(stack[-3] > 0x174876e800) // Inputs[1] { @2C8E stack[-1] } 2C8C 60 PUSH1 0x03 2C8E 81 DUP2 2C8F 01 ADD 2C90 90 SWAP1 2C91 50 POP 2C92 5B JUMPDEST 2C93 5B JUMPDEST // Stack delta = +0 // Outputs[1] { @2C90 stack[-1] = stack[-1] + 0x03 } // Block continues label_2C94: // Incoming jump from 0x2C63 // Incoming jump from 0x2C93 // Incoming jump from 0x2C93 // Incoming jump from 0x2C93 // Inputs[1] { @2C99 block.timestamp } 2C94 5B JUMPDEST 2C95 60 PUSH1 0x00 2C97 60 PUSH1 0x02 2C99 42 TIMESTAMP 2C9A 81 DUP2 2C9B 15 ISZERO 2C9C 15 ISZERO 2C9D 61 PUSH2 0x2ca2 2CA0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2C95 stack[0] = 0x00 // @2C97 stack[1] = 0x02 // @2C99 stack[2] = block.timestamp // } // Block ends with conditional jump to 0x2ca2, if !!0x02 label_2CA1: // Incoming jump from 0x2CA0, if not !!0x02 2CA1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2CA1 assert(); } // Block terminates label_2CA2: // Incoming jump from 0x2CA0, if !!0x02 // Inputs[3] // { // @2CA3 stack[-2] // @2CA3 stack[-1] // @2CA4 stack[-3] // } 2CA2 5B JUMPDEST 2CA3 06 MOD 2CA4 14 EQ 2CA5 15 ISZERO 2CA6 61 PUSH2 0x2cb4 2CA9 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2cb4, if !(stack[-1] % stack[-2] == stack[-3]) label_2CAA: // Incoming jump from 0x2CA9, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2CAC stack[-1] } 2CAA 60 PUSH1 0x02 2CAC 81 DUP2 2CAD 02 MUL 2CAE 90 SWAP1 2CAF 50 POP 2CB0 61 PUSH2 0x2cf2 2CB3 56 *JUMP // Stack delta = +0 // Outputs[1] { @2CAE stack[-1] = stack[-1] * 0x02 } // Block ends with unconditional jump to 0x2cf2 label_2CB4: // Incoming jump from 0x2CA9, if !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2CB9 block.timestamp } 2CB4 5B JUMPDEST 2CB5 60 PUSH1 0x00 2CB7 60 PUSH1 0x03 2CB9 42 TIMESTAMP 2CBA 81 DUP2 2CBB 15 ISZERO 2CBC 15 ISZERO 2CBD 61 PUSH2 0x2cc2 2CC0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2CB5 stack[0] = 0x00 // @2CB7 stack[1] = 0x03 // @2CB9 stack[2] = block.timestamp // } // Block ends with conditional jump to 0x2cc2, if !!0x03 label_2CC1: // Incoming jump from 0x2CC0, if not !!0x03 2CC1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2CC1 assert(); } // Block terminates label_2CC2: // Incoming jump from 0x2CC0, if !!0x03 // Inputs[3] // { // @2CC3 stack[-2] // @2CC3 stack[-1] // @2CC4 stack[-3] // } 2CC2 5B JUMPDEST 2CC3 06 MOD 2CC4 14 EQ 2CC5 15 ISZERO 2CC6 61 PUSH2 0x2cd4 2CC9 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2cd4, if !(stack[-1] % stack[-2] == stack[-3]) label_2CCA: // Incoming jump from 0x2CC9, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2CCC stack[-1] } 2CCA 60 PUSH1 0x03 2CCC 81 DUP2 2CCD 02 MUL 2CCE 90 SWAP1 2CCF 50 POP 2CD0 61 PUSH2 0x2cf1 2CD3 56 *JUMP // Stack delta = +0 // Outputs[1] { @2CCE stack[-1] = stack[-1] * 0x03 } // Block ends with unconditional jump to 0x2cf1 label_2CD4: // Incoming jump from 0x2CC9, if !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2CD9 block.timestamp } 2CD4 5B JUMPDEST 2CD5 60 PUSH1 0x00 2CD7 60 PUSH1 0x07 2CD9 42 TIMESTAMP 2CDA 81 DUP2 2CDB 15 ISZERO 2CDC 15 ISZERO 2CDD 61 PUSH2 0x2ce2 2CE0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2CD5 stack[0] = 0x00 // @2CD7 stack[1] = 0x07 // @2CD9 stack[2] = block.timestamp // } // Block ends with conditional jump to 0x2ce2, if !!0x07 label_2CE1: // Incoming jump from 0x2CE0, if not !!0x07 2CE1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2CE1 assert(); } // Block terminates label_2CE2: // Incoming jump from 0x2CE0, if !!0x07 // Inputs[3] // { // @2CE3 stack[-1] // @2CE3 stack[-2] // @2CE4 stack[-3] // } 2CE2 5B JUMPDEST 2CE3 06 MOD 2CE4 14 EQ 2CE5 15 ISZERO 2CE6 61 PUSH2 0x2cf0 2CE9 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2cf0, if !(stack[-1] % stack[-2] == stack[-3]) label_2CEA: // Incoming jump from 0x2CE9, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2CEC stack[-1] } 2CEA 60 PUSH1 0x07 2CEC 81 DUP2 2CED 02 MUL 2CEE 90 SWAP1 2CEF 50 POP 2CF0 5B JUMPDEST // Stack delta = +0 // Outputs[1] { @2CEE stack[-1] = stack[-1] * 0x07 } // Block continues label_2CF1: // Incoming jump from 0x2CD3 // Incoming jump from 0x2CF0 // Incoming jump from 0x2CF0 // Inputs[1] { @2CF9 storage[0x08] } 2CF1 5B JUMPDEST 2CF2 5B JUMPDEST 2CF3 60 PUSH1 0x00 2CF5 60 PUSH1 0x0a 2CF7 60 PUSH1 0x08 2CF9 54 SLOAD 2CFA 81 DUP2 2CFB 15 ISZERO 2CFC 15 ISZERO 2CFD 61 PUSH2 0x2d02 2D00 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2CF3 stack[0] = 0x00 // @2CF5 stack[1] = 0x0a // @2CF9 stack[2] = storage[0x08] // } // Block ends with conditional jump to 0x2d02, if !!0x0a label_2D01: // Incoming jump from 0x2D00, if not !!0x0a // Incoming jump from 0x2D00, if not !!0x0a 2D01 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2D01 assert(); } // Block terminates label_2D02: // Incoming jump from 0x2D00, if !!0x0a // Incoming jump from 0x2D00, if !!0x0a // Inputs[3] // { // @2D03 stack[-2] // @2D03 stack[-1] // @2D04 stack[-3] // } 2D02 5B JUMPDEST 2D03 06 MOD 2D04 14 EQ 2D05 15 ISZERO 2D06 61 PUSH2 0x2d14 2D09 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2d14, if !(stack[-1] % stack[-2] == stack[-3]) label_2D0A: // Incoming jump from 0x2D09, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2D0C stack[-1] } 2D0A 60 PUSH1 0x0a 2D0C 81 DUP2 2D0D 02 MUL 2D0E 90 SWAP1 2D0F 50 POP 2D10 61 PUSH2 0x2d68 2D13 56 *JUMP // Stack delta = +0 // Outputs[1] { @2D0E stack[-1] = stack[-1] * 0x0a } // Block ends with unconditional jump to 0x2d68 label_2D14: // Incoming jump from 0x2D09, if !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2D1B storage[0x08] } 2D14 5B JUMPDEST 2D15 60 PUSH1 0x00 2D17 60 PUSH1 0x02 2D19 60 PUSH1 0x08 2D1B 54 SLOAD 2D1C 81 DUP2 2D1D 15 ISZERO 2D1E 15 ISZERO 2D1F 61 PUSH2 0x2d24 2D22 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2D15 stack[0] = 0x00 // @2D17 stack[1] = 0x02 // @2D1B stack[2] = storage[0x08] // } // Block ends with conditional jump to 0x2d24, if !!0x02 label_2D23: // Incoming jump from 0x2D22, if not !!0x02 2D23 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2D23 assert(); } // Block terminates label_2D24: // Incoming jump from 0x2D22, if !!0x02 // Inputs[3] // { // @2D25 stack[-2] // @2D25 stack[-1] // @2D26 stack[-3] // } 2D24 5B JUMPDEST 2D25 06 MOD 2D26 14 EQ 2D27 15 ISZERO 2D28 61 PUSH2 0x2d3f 2D2B 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2d3f, if !(stack[-1] % stack[-2] == stack[-3]) label_2D2C: // Incoming jump from 0x2D2B, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2D2E stack[-1] } 2D2C 60 PUSH1 0x02 2D2E 81 DUP2 2D2F 81 DUP2 2D30 15 ISZERO 2D31 15 ISZERO 2D32 61 PUSH2 0x2d37 2D35 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2D2C stack[0] = 0x02 // @2D2E stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2d37, if !!0x02 label_2D36: // Incoming jump from 0x2D35, if not !!0x02 2D36 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2D36 assert(); } // Block terminates label_2D37: // Incoming jump from 0x2D35, if !!0x02 // Inputs[3] // { // @2D38 stack[-2] // @2D38 stack[-1] // @2D39 stack[-3] // } 2D37 5B JUMPDEST 2D38 04 DIV 2D39 90 SWAP1 2D3A 50 POP 2D3B 61 PUSH2 0x2d67 2D3E 56 *JUMP // Stack delta = -2 // Outputs[1] { @2D39 stack[-3] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x2d67 label_2D3F: // Incoming jump from 0x2D2B, if !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2D46 storage[0x08] } 2D3F 5B JUMPDEST 2D40 60 PUSH1 0x00 2D42 60 PUSH1 0x03 2D44 60 PUSH1 0x08 2D46 54 SLOAD 2D47 81 DUP2 2D48 15 ISZERO 2D49 15 ISZERO 2D4A 61 PUSH2 0x2d4f 2D4D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2D40 stack[0] = 0x00 // @2D42 stack[1] = 0x03 // @2D46 stack[2] = storage[0x08] // } // Block ends with conditional jump to 0x2d4f, if !!0x03 label_2D4E: // Incoming jump from 0x2D4D, if not !!0x03 2D4E FE *ASSERT // Stack delta = +0 // Outputs[1] { @2D4E assert(); } // Block terminates label_2D4F: // Incoming jump from 0x2D4D, if !!0x03 // Inputs[3] // { // @2D50 stack[-2] // @2D50 stack[-1] // @2D51 stack[-3] // } 2D4F 5B JUMPDEST 2D50 06 MOD 2D51 14 EQ 2D52 15 ISZERO 2D53 61 PUSH2 0x2d66 2D56 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2d66, if !(stack[-1] % stack[-2] == stack[-3]) label_2D57: // Incoming jump from 0x2D56, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[1] { @2D59 stack[-1] } 2D57 60 PUSH1 0x03 2D59 81 DUP2 2D5A 81 DUP2 2D5B 15 ISZERO 2D5C 15 ISZERO 2D5D 61 PUSH2 0x2d62 2D60 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2D57 stack[0] = 0x03 // @2D59 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2d62, if !!0x03 label_2D61: // Incoming jump from 0x2D60, if not !!0x03 2D61 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2D61 assert(); } // Block terminates label_2D62: // Incoming jump from 0x2D60, if !!0x03 // Inputs[3] // { // @2D63 stack[-2] // @2D63 stack[-1] // @2D64 stack[-3] // } 2D62 5B JUMPDEST 2D63 04 DIV 2D64 90 SWAP1 2D65 50 POP // Stack delta = -2 // Outputs[1] { @2D64 stack[-3] = stack[-1] / stack[-2] } // Block continues label_2D66: // Incoming jump from 0x2D56, if !(stack[-1] % stack[-2] == stack[-3]) // Incoming jump from 0x2D65 2D66 5B JUMPDEST 2D67 5B JUMPDEST // Stack delta = +0 // Block continues label_2D68: // Incoming jump from 0x2D13 // Incoming jump from 0x2D67 // Incoming jump from 0x2D67 // Inputs[4] // { // @2D69 stack[-1] // @2D6A stack[-2] // @2D6D stack[-4] // @2D6E stack[-3] // } 2D68 5B JUMPDEST 2D69 80 DUP1 2D6A 91 SWAP2 2D6B 50 POP 2D6C 50 POP 2D6D 91 SWAP2 2D6E 90 SWAP1 2D6F 50 POP 2D70 56 *JUMP // Stack delta = -3 // Outputs[1] { @2D6D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2D71: // Incoming call from 0x074F, returns to 0x0750 // Inputs[6] // { // @2D78 stack[-2] // @2DB2 memory[0x00:0x40] // @2DB5 stack[-1] // @2DEF memory[0x00:0x40] // @2DF0 storage[keccak256(memory[0x00:0x40])] // @2DF3 stack[-3] // } 2D71 5B JUMPDEST 2D72 60 PUSH1 0x00 2D74 60 PUSH1 0x05 2D76 60 PUSH1 0x00 2D78 84 DUP5 2D79 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D8E 16 AND 2D8F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DA4 16 AND 2DA5 81 DUP2 2DA6 52 MSTORE 2DA7 60 PUSH1 0x20 2DA9 01 ADD 2DAA 90 SWAP1 2DAB 81 DUP2 2DAC 52 MSTORE 2DAD 60 PUSH1 0x20 2DAF 01 ADD 2DB0 60 PUSH1 0x00 2DB2 20 SHA3 2DB3 60 PUSH1 0x00 2DB5 83 DUP4 2DB6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DCB 16 AND 2DCC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DE1 16 AND 2DE2 81 DUP2 2DE3 52 MSTORE 2DE4 60 PUSH1 0x20 2DE6 01 ADD 2DE7 90 SWAP1 2DE8 81 DUP2 2DE9 52 MSTORE 2DEA 60 PUSH1 0x20 2DEC 01 ADD 2DED 60 PUSH1 0x00 2DEF 20 SHA3 2DF0 54 SLOAD 2DF1 90 SWAP1 2DF2 50 POP 2DF3 92 SWAP3 2DF4 91 SWAP2 2DF5 50 POP 2DF6 50 POP 2DF7 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @2DA6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2DAC memory[0x20:0x40] = 0x05 // @2DE3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2DE9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2DF3 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_2DF8: // Incoming call from 0x2136, returns to 0x2137 // Incoming call from 0x0790, returns to 0x0791 // Inputs[3] // { // @2E0E msg.sender // @2E48 memory[0x00:0x40] // @2E4A storage[keccak256(memory[0x00:0x40])] // } 2DF8 5B JUMPDEST 2DF9 60 PUSH1 0x00 2DFB 80 DUP1 2DFC 60 PUSH1 0x00 2DFE 80 DUP1 2DFF 62 PUSH3 0x989680 2E03 92 SWAP3 2E04 50 POP 2E05 60 PUSH1 0x03 2E07 90 SWAP1 2E08 50 POP 2E09 5B JUMPDEST 2E0A 60 PUSH1 0x0c 2E0C 60 PUSH1 0x00 2E0E 33 CALLER 2E0F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E24 16 AND 2E25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E3A 16 AND 2E3B 81 DUP2 2E3C 52 MSTORE 2E3D 60 PUSH1 0x20 2E3F 01 ADD 2E40 90 SWAP1 2E41 81 DUP2 2E42 52 MSTORE 2E43 60 PUSH1 0x20 2E45 01 ADD 2E46 60 PUSH1 0x00 2E48 20 SHA3 2E49 80 DUP1 2E4A 54 SLOAD 2E4B 90 SWAP1 2E4C 50 POP 2E4D 81 DUP2 2E4E 10 LT 2E4F 15 ISZERO 2E50 61 PUSH2 0x2ff7 2E53 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @2DF9 stack[0] = 0x00 // @2DFC stack[2] = 0x00 // @2E03 stack[1] = 0x989680 // @2E07 stack[3] = 0x03 // @2E3C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2E42 memory[0x20:0x40] = 0x0c // } // Block ends with conditional jump to 0x2ff7, if !(0x03 < storage[keccak256(memory[0x00:0x40])]) label_2E54: // Incoming jump from 0x2E53, if not !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x2E53, if not !(0x03 < storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @2E56 stack[-1] // @2E57 stack[-5] // } 2E54 60 PUSH1 0x00 2E56 81 DUP2 2E57 86 DUP7 2E58 81 DUP2 2E59 15 ISZERO 2E5A 15 ISZERO 2E5B 61 PUSH2 0x2e60 2E5E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2E54 stack[0] = 0x00 // @2E56 stack[1] = stack[-1] // @2E57 stack[2] = stack[-5] // } // Block ends with conditional jump to 0x2e60, if !!stack[-1] label_2E5F: // Incoming jump from 0x2E5E, if not !!stack[-1] 2E5F FE *ASSERT // Stack delta = +0 // Outputs[1] { @2E5F assert(); } // Block terminates label_2E60: // Incoming jump from 0x2E5E, if !!stack[-1] // Inputs[3] // { // @2E61 stack[-1] // @2E61 stack[-2] // @2E62 stack[-3] // } 2E60 5B JUMPDEST 2E61 06 MOD 2E62 14 EQ 2E63 15 ISZERO 2E64 61 PUSH2 0x2fea 2E67 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2fea, if !(stack[-1] % stack[-2] == stack[-3]) label_2E68: // Incoming jump from 0x2E67, if not !(stack[-1] % stack[-2] == stack[-3]) // Inputs[5] // { // @2E68 stack[-3] // @2E70 msg.sender // @2EAA memory[0x00:0x40] // @2EAB stack[-1] // @2EAD storage[keccak256(memory[0x00:0x40])] // } 2E68 82 DUP3 2E69 61 PUSH2 0x2ee7 2E6C 60 PUSH1 0x0c 2E6E 60 PUSH1 0x00 2E70 33 CALLER 2E71 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E86 16 AND 2E87 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E9C 16 AND 2E9D 81 DUP2 2E9E 52 MSTORE 2E9F 60 PUSH1 0x20 2EA1 01 ADD 2EA2 90 SWAP1 2EA3 81 DUP2 2EA4 52 MSTORE 2EA5 60 PUSH1 0x20 2EA7 01 ADD 2EA8 60 PUSH1 0x00 2EAA 20 SHA3 2EAB 83 DUP4 2EAC 81 DUP2 2EAD 54 SLOAD 2EAE 81 DUP2 2EAF 10 LT 2EB0 15 ISZERO 2EB1 15 ISZERO 2EB2 61 PUSH2 0x2eb7 2EB5 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @2E68 stack[0] = stack[-3] // @2E69 stack[1] = 0x2ee7 // @2E9E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2EA4 memory[0x20:0x40] = 0x0c // @2EAA stack[2] = keccak256(memory[0x00:0x40]) // @2EAB stack[3] = stack[-1] // } // Block ends with conditional call to 0x2eb7, returns to 0x2EE7, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) label_2EB6: // Incoming jump from 0x2EB5, if not !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) 2EB6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2EB6 assert(); } // Block terminates label_2EB7: // Incoming call from 0x2EB5, returns to 0x2EE7, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2EB8 stack[-2] // @2EB8 stack[-1] // @2EC0 memory[0x00:0x20] // @2EC5 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } 2EB7 5B JUMPDEST 2EB8 90 SWAP1 2EB9 60 PUSH1 0x00 2EBB 52 MSTORE 2EBC 60 PUSH1 0x20 2EBE 60 PUSH1 0x00 2EC0 20 SHA3 2EC1 01 ADD 2EC2 60 PUSH1 0x00 2EC4 90 SWAP1 2EC5 54 SLOAD 2EC6 90 SWAP1 2EC7 61 PUSH2 0x0100 2ECA 0A EXP 2ECB 90 SWAP1 2ECC 04 DIV 2ECD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EE2 16 AND 2EE3 61 PUSH2 0x1843 2EE6 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2EBB memory[0x00:0x20] = stack[-2] // @2EE2 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20]) + stack[-1]] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to 0x1843 label_2EE7: // Incoming return from call to 0x2EB7 at 0x2EB5 // Inputs[2] // { // @2EE8 stack[-1] // @2EE8 stack[-2] // } 2EE7 5B JUMPDEST 2EE8 11 GT 2EE9 15 ISZERO 2EEA 15 ISZERO 2EEB 61 PUSH2 0x2fe9 2EEE 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2fe9, if !!(stack[-1] > stack[-2]) label_2EEF: // Incoming jump from 0x2EEE, if not !!(stack[-1] > stack[-2]) // Inputs[4] // { // @2EF3 msg.sender // @2F2D memory[0x00:0x40] // @2F2E stack[-1] // @2F30 storage[keccak256(memory[0x00:0x40])] // } 2EEF 60 PUSH1 0x0c 2EF1 60 PUSH1 0x00 2EF3 33 CALLER 2EF4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F09 16 AND 2F0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F1F 16 AND 2F20 81 DUP2 2F21 52 MSTORE 2F22 60 PUSH1 0x20 2F24 01 ADD 2F25 90 SWAP1 2F26 81 DUP2 2F27 52 MSTORE 2F28 60 PUSH1 0x20 2F2A 01 ADD 2F2B 60 PUSH1 0x00 2F2D 20 SHA3 2F2E 81 DUP2 2F2F 81 DUP2 2F30 54 SLOAD 2F31 81 DUP2 2F32 10 LT 2F33 15 ISZERO 2F34 15 ISZERO 2F35 61 PUSH2 0x2f3a 2F38 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2F21 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2F27 memory[0x20:0x40] = 0x0c // @2F2D stack[0] = keccak256(memory[0x00:0x40]) // @2F2E stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2f3a, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) label_2F39: // Incoming jump from 0x2F38, if not !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) 2F39 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2F39 assert(); } // Block terminates label_2F3A: // Incoming jump from 0x2F38, if !!(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @2F3B stack[-2] // @2F3B stack[-1] // @2F43 memory[0x00:0x20] // @2F48 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2F66 stack[-4] // @2F6F msg.sender // @2FA9 memory[0x00:0x40] // @2FAA stack[-3] // @2FAC storage[keccak256(memory[0x00:0x40])] // } 2F3A 5B JUMPDEST 2F3B 90 SWAP1 2F3C 60 PUSH1 0x00 2F3E 52 MSTORE 2F3F 60 PUSH1 0x20 2F41 60 PUSH1 0x00 2F43 20 SHA3 2F44 01 ADD 2F45 60 PUSH1 0x00 2F47 90 SWAP1 2F48 54 SLOAD 2F49 90 SWAP1 2F4A 61 PUSH2 0x0100 2F4D 0A EXP 2F4E 90 SWAP1 2F4F 04 DIV 2F50 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F65 16 AND 2F66 91 SWAP2 2F67 50 POP 2F68 61 PUSH2 0x2fe6 2F6B 60 PUSH1 0x0c 2F6D 60 PUSH1 0x00 2F6F 33 CALLER 2F70 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F85 16 AND 2F86 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F9B 16 AND 2F9C 81 DUP2 2F9D 52 MSTORE 2F9E 60 PUSH1 0x20 2FA0 01 ADD 2FA1 90 SWAP1 2FA2 81 DUP2 2FA3 52 MSTORE 2FA4 60 PUSH1 0x20 2FA6 01 ADD 2FA7 60 PUSH1 0x00 2FA9 20 SHA3 2FAA 82 DUP3 2FAB 81 DUP2 2FAC 54 SLOAD 2FAD 81 DUP2 2FAE 10 LT 2FAF 15 ISZERO 2FB0 15 ISZERO 2FB1 61 PUSH2 0x2fb6 2FB4 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @2F3E memory[0x00:0x20] = stack[-2] // @2F66 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20]) + stack[-1]] / 0x0100 ** 0x00 // @2F68 stack[-2] = 0x2fe6 // @2F9D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2FA3 memory[0x20:0x40] = 0x0c // @2FA9 stack[-1] = keccak256(memory[0x00:0x40]) // @2FAA stack[0] = stack[-3] // } // Block ends with conditional call to 0x2fb6, returns to 0x2FE6, if !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) label_2FB5: // Incoming jump from 0x2FB4, if not !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) 2FB5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2FB5 assert(); } // Block terminates label_2FB6: // Incoming call from 0x2FB4, returns to 0x2FE6, if !!(stack[-3] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2FB7 stack[-1] // @2FB7 stack[-2] // @2FBF memory[0x00:0x20] // @2FC4 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } 2FB6 5B JUMPDEST 2FB7 90 SWAP1 2FB8 60 PUSH1 0x00 2FBA 52 MSTORE 2FBB 60 PUSH1 0x20 2FBD 60 PUSH1 0x00 2FBF 20 SHA3 2FC0 01 ADD 2FC1 60 PUSH1 0x00 2FC3 90 SWAP1 2FC4 54 SLOAD 2FC5 90 SWAP1 2FC6 61 PUSH2 0x0100 2FC9 0A EXP 2FCA 90 SWAP1 2FCB 04 DIV 2FCC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2FE1 16 AND 2FE2 61 PUSH2 0x1843 2FE5 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2FBA memory[0x00:0x20] = stack[-2] // @2FE1 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x20]) + stack[-1]] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to 0x1843 label_2FE6: // Incoming return from call to 0x2FB6 at 0x2FB4 // Inputs[2] // { // @2FE7 stack[-4] // @2FE7 stack[-1] // } 2FE6 5B JUMPDEST 2FE7 92 SWAP3 2FE8 50 POP // Stack delta = -1 // Outputs[1] { @2FE7 stack[-4] = stack[-1] } // Block continues label_2FE9: // Incoming jump from 0x2EEE, if !!(stack[-1] > stack[-2]) // Incoming jump from 0x2FE8 2FE9 5B JUMPDEST // Stack delta = +0 // Block continues label_2FEA: // Incoming jump from 0x2E67, if !(stack[-1] % stack[-2] == stack[-3]) // Incoming jump from 0x2FE9 // Inputs[1] { @2FEB stack[-1] } 2FEA 5B JUMPDEST 2FEB 80 DUP1 2FEC 80 DUP1 2FED 60 PUSH1 0x01 2FEF 01 ADD 2FF0 91 SWAP2 2FF1 50 POP 2FF2 50 POP 2FF3 61 PUSH2 0x2e09 2FF6 56 *JUMP // Stack delta = +0 // Outputs[1] { @2FF0 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x2e09 label_2FF7: // Incoming jump from 0x2E53, if !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x2E53, if !(0x03 < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2FF8 stack[-2] // @2FF9 stack[-4] // @2FFE stack[-6] // @2FFF stack[-5] // } 2FF7 5B JUMPDEST 2FF8 81 DUP2 2FF9 93 SWAP4 2FFA 50 POP 2FFB 50 POP 2FFC 50 POP 2FFD 50 POP 2FFE 91 SWAP2 2FFF 90 SWAP1 3000 50 POP 3001 56 *JUMP // Stack delta = -5 // Outputs[1] { @2FFE stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_3002: // Incoming call from 0x117B, returns to 0x117C // Incoming call from 0x2203, returns to 0x2204 // Incoming call from 0x1A42, returns to 0x1A43 // Incoming call from 0x0DD1, returns to 0x0DD2 // Incoming call from 0x1E2E, returns to 0x1E2F // Incoming call from 0x1332, returns to 0x1333 // Incoming call from 0x2928, returns to 0x2929 // Incoming call from 0x0C6A, returns to 0x0C6B // Inputs[2] // { // @3006 stack[-2] // @3007 stack[-1] // } 3002 5B JUMPDEST 3003 60 PUSH1 0x00 3005 80 DUP1 3006 83 DUP4 3007 83 DUP4 3008 11 GT 3009 15 ISZERO 300A 15 ISZERO 300B 15 ISZERO 300C 61 PUSH2 0x3014 300F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3003 stack[0] = 0x00 // @3005 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3014, if !!!(stack[-1] > stack[-2]) label_3010: // Incoming jump from 0x300F, if not !!!(stack[-1] > stack[-2]) // Inputs[1] { @3013 memory[0x00:0x00] } 3010 60 PUSH1 0x00 3012 80 DUP1 3013 FD *REVERT // Stack delta = +0 // Outputs[1] { @3013 revert(memory[0x00:0x00]); } // Block terminates label_3014: // Incoming jump from 0x300F, if !!!(stack[-1] > stack[-2]) // Inputs[5] // { // @3015 stack[-3] // @3016 stack[-4] // @3018 stack[-1] // @301B stack[-2] // @301E stack[-5] // } 3014 5B JUMPDEST 3015 82 DUP3 3016 84 DUP5 3017 03 SUB 3018 90 SWAP1 3019 50 POP 301A 80 DUP1 301B 91 SWAP2 301C 50 POP 301D 50 POP 301E 92 SWAP3 301F 91 SWAP2 3020 50 POP 3021 50 POP 3022 56 *JUMP // Stack delta = -4 // Outputs[1] { @301E stack[-5] = stack[-4] - stack[-3] } // Block ends with unconditional jump to stack[-5] label_3023: // Incoming call from 0x0CFF, returns to 0x0D00 // Incoming call from 0x22D7, returns to 0x22D8 // Incoming call from 0x13C7, returns to 0x13C8 // Incoming call from 0x124F, returns to 0x1250 // Incoming call from 0x1626, returns to 0x1627 // Incoming call from 0x29BD, returns to 0x29BE // Incoming call from 0x1F02, returns to 0x1F03 // Inputs[2] // { // @3027 stack[-1] // @3028 stack[-2] // } 3023 5B JUMPDEST 3024 60 PUSH1 0x00 3026 80 DUP1 3027 82 DUP3 3028 84 DUP5 3029 01 ADD 302A 90 SWAP1 302B 50 POP 302C 83 DUP4 302D 81 DUP2 302E 10 LT 302F 15 ISZERO 3030 15 ISZERO 3031 15 ISZERO 3032 61 PUSH2 0x303a 3035 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3024 stack[0] = 0x00 // @302A stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x303a, if !!!(stack[-2] + stack[-1] < stack[-2]) label_3036: // Incoming jump from 0x3035, if not !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @3039 memory[0x00:0x00] } 3036 60 PUSH1 0x00 3038 80 DUP1 3039 FD *REVERT // Stack delta = +0 // Outputs[1] { @3039 revert(memory[0x00:0x00]); } // Block terminates label_303A: // Incoming jump from 0x3035, if !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @303B stack[-1] // @303C stack[-2] // @303F stack[-5] // @3040 stack[-4] // } 303A 5B JUMPDEST 303B 80 DUP1 303C 91 SWAP2 303D 50 POP 303E 50 POP 303F 92 SWAP3 3040 91 SWAP2 3041 50 POP 3042 50 POP 3043 56 *JUMP // Stack delta = -4 // Outputs[1] { @303F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 3044 00 *STOP 3045 A1 LOG1 3046 65 PUSH6 0x627a7a723058 304D 20 SHA3 304E 2B 2B 304F 1B SHL 3050 CA CA 3051 65 PUSH6 0xccdc7748d2ca 3058 A0 LOG0 3059 0A EXP 305A B7 B7 305B C7 C7 305C D4 D4 305D 98 SWAP9 305E A4 LOG4 305F 13 SGT 3060 B9 B9 3061 DA DA 3062 64 PUSH5 0xbb070c7032 3068 FB FB 3069 58 PC 306A D3 D3 306B 4B 4B 306C 6C PUSH13 0xf00029