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 0x0174 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0174, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @0032 msg.data[0x00:0x20] } 000D 63 PUSH4 0xffffffff 0012 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0030 60 PUSH1 0x00 0032 35 CALLDATALOAD 0033 04 DIV 0034 16 AND 0035 63 PUSH4 0x01ffc9a7 003A 81 DUP2 003B 14 EQ 003C 61 PUSH2 0x0179 003F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0034 stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff } // Block ends with conditional jump to 0x0179, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x01ffc9a7 label_0040: // Incoming jump from 0x003F, if not msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x01ffc9a7 // Inputs[1] { @0040 stack[-1] } 0040 80 DUP1 0041 63 PUSH4 0x06fdde03 0046 14 EQ 0047 61 PUSH2 0x01c4 004A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c4, if 0x06fdde03 == stack[-1] label_004B: // Incoming jump from 0x004A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @004B stack[-1] } 004B 80 DUP1 004C 63 PUSH4 0x081812fc 0051 14 EQ 0052 61 PUSH2 0x024e 0055 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024e, if 0x081812fc == stack[-1] label_0056: // Incoming jump from 0x0055, if not 0x081812fc == stack[-1] // Inputs[1] { @0056 stack[-1] } 0056 80 DUP1 0057 63 PUSH4 0x095ea7b3 005C 14 EQ 005D 61 PUSH2 0x0282 0060 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0282, if 0x095ea7b3 == stack[-1] label_0061: // Incoming jump from 0x0060, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0061 stack[-1] } 0061 80 DUP1 0062 63 PUSH4 0x1785f53c 0067 14 EQ 0068 61 PUSH2 0x02a8 006B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a8, if 0x1785f53c == stack[-1] label_006C: // Incoming jump from 0x006B, if not 0x1785f53c == stack[-1] // Inputs[1] { @006C stack[-1] } 006C 80 DUP1 006D 63 PUSH4 0x18160ddd 0072 14 EQ 0073 61 PUSH2 0x02c9 0076 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c9, if 0x18160ddd == stack[-1] label_0077: // Incoming jump from 0x0076, if not 0x18160ddd == stack[-1] // Inputs[1] { @0077 stack[-1] } 0077 80 DUP1 0078 63 PUSH4 0x23b872dd 007D 14 EQ 007E 61 PUSH2 0x02f0 0081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f0, if 0x23b872dd == stack[-1] label_0082: // Incoming jump from 0x0081, if not 0x23b872dd == stack[-1] // Inputs[1] { @0082 stack[-1] } 0082 80 DUP1 0083 63 PUSH4 0x24d7806c 0088 14 EQ 0089 61 PUSH2 0x031a 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031a, if 0x24d7806c == stack[-1] label_008D: // Incoming jump from 0x008C, if not 0x24d7806c == stack[-1] // Inputs[1] { @008D stack[-1] } 008D 80 DUP1 008E 63 PUSH4 0x26b3b1ee 0093 14 EQ 0094 61 PUSH2 0x033b 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033b, if 0x26b3b1ee == stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x26b3b1ee == stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x2f745c59 009E 14 EQ 009F 61 PUSH2 0x035c 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035c, if 0x2f745c59 == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x2f745c59 == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x40abfe26 00A9 14 EQ 00AA 61 PUSH2 0x0380 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0380, if 0x40abfe26 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x40abfe26 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x40c10f19 00B4 14 EQ 00B5 61 PUSH2 0x03a1 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a1, if 0x40c10f19 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x40c10f19 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x42842e0e 00BF 14 EQ 00C0 61 PUSH2 0x03c5 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c5, if 0x42842e0e == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x42842e0e == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x42966c68 00CA 14 EQ 00CB 61 PUSH2 0x03e2 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e2, if 0x42966c68 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x42966c68 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x4f6ccce7 00D5 14 EQ 00D6 61 PUSH2 0x03fa 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fa, if 0x4f6ccce7 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x50bb4e7f 00E0 14 EQ 00E1 61 PUSH2 0x0412 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0412, if 0x50bb4e7f == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x50bb4e7f == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x6352211e 00EB 14 EQ 00EC 61 PUSH2 0x047b 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047b, if 0x6352211e == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x6352211e == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x70480275 00F6 14 EQ 00F7 61 PUSH2 0x0493 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0493, if 0x70480275 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x70480275 == stack[-1] // Inputs[1] { @00FB stack[-1] } 00FB 80 DUP1 00FC 63 PUSH4 0x706e7373 0101 14 EQ 0102 61 PUSH2 0x04b4 0105 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b4, if 0x706e7373 == stack[-1] label_0106: // Incoming jump from 0x0105, if not 0x706e7373 == stack[-1] // Inputs[1] { @0106 stack[-1] } 0106 80 DUP1 0107 63 PUSH4 0x70a08231 010C 14 EQ 010D 61 PUSH2 0x04c9 0110 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c9, if 0x70a08231 == stack[-1] label_0111: // Incoming jump from 0x0110, if not 0x70a08231 == stack[-1] // Inputs[1] { @0111 stack[-1] } 0111 80 DUP1 0112 63 PUSH4 0x95d89b41 0117 14 EQ 0118 61 PUSH2 0x04ea 011B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ea, if 0x95d89b41 == stack[-1] label_011C: // Incoming jump from 0x011B, if not 0x95d89b41 == stack[-1] // Inputs[1] { @011C stack[-1] } 011C 80 DUP1 011D 63 PUSH4 0xa07c7ce4 0122 14 EQ 0123 61 PUSH2 0x04ff 0126 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ff, if 0xa07c7ce4 == stack[-1] label_0127: // Incoming jump from 0x0126, if not 0xa07c7ce4 == stack[-1] // Inputs[1] { @0127 stack[-1] } 0127 80 DUP1 0128 63 PUSH4 0xa22cb465 012D 14 EQ 012E 61 PUSH2 0x0514 0131 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0514, if 0xa22cb465 == stack[-1] label_0132: // Incoming jump from 0x0131, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0132 stack[-1] } 0132 80 DUP1 0133 63 PUSH4 0xa75d5254 0138 14 EQ 0139 61 PUSH2 0x053a 013C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053a, if 0xa75d5254 == stack[-1] label_013D: // Incoming jump from 0x013C, if not 0xa75d5254 == stack[-1] // Inputs[1] { @013D stack[-1] } 013D 80 DUP1 013E 63 PUSH4 0xb88d4fde 0143 14 EQ 0144 61 PUSH2 0x055b 0147 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055b, if 0xb88d4fde == stack[-1] label_0148: // Incoming jump from 0x0147, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0148 stack[-1] } 0148 80 DUP1 0149 63 PUSH4 0xbc9ac68c 014E 14 EQ 014F 61 PUSH2 0x0587 0152 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0587, if 0xbc9ac68c == stack[-1] label_0153: // Incoming jump from 0x0152, if not 0xbc9ac68c == stack[-1] // Inputs[1] { @0153 stack[-1] } 0153 80 DUP1 0154 63 PUSH4 0xc87b56dd 0159 14 EQ 015A 61 PUSH2 0x05a8 015D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a8, if 0xc87b56dd == stack[-1] label_015E: // Incoming jump from 0x015D, if not 0xc87b56dd == stack[-1] // Inputs[1] { @015E stack[-1] } 015E 80 DUP1 015F 63 PUSH4 0xe19e4349 0164 14 EQ 0165 61 PUSH2 0x05c0 0168 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c0, if 0xe19e4349 == stack[-1] label_0169: // Incoming jump from 0x0168, if not 0xe19e4349 == stack[-1] // Inputs[1] { @0169 stack[-1] } 0169 80 DUP1 016A 63 PUSH4 0xe985e9c5 016F 14 EQ 0170 61 PUSH2 0x05d5 0173 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d5, if 0xe985e9c5 == stack[-1] label_0174: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0173, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0178 memory[0x00:0x00] } 0174 5B JUMPDEST 0175 60 PUSH1 0x00 0177 80 DUP1 0178 FD *REVERT // Stack delta = +0 // Outputs[1] { @0178 revert(memory[0x00:0x00]); } // Block terminates label_0179: // Incoming jump from 0x003F, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x01ffc9a7 // Inputs[1] { @017A msg.value } 0179 5B JUMPDEST 017A 34 CALLVALUE 017B 80 DUP1 017C 15 ISZERO 017D 61 PUSH2 0x0185 0180 57 *JUMPI // Stack delta = +1 // Outputs[1] { @017A stack[0] = msg.value } // Block ends with conditional jump to 0x0185, if !msg.value label_0181: // Incoming jump from 0x0180, if not !msg.value // Inputs[1] { @0184 memory[0x00:0x00] } 0181 60 PUSH1 0x00 0183 80 DUP1 0184 FD *REVERT // Stack delta = +0 // Outputs[1] { @0184 revert(memory[0x00:0x00]); } // Block terminates label_0185: // Incoming jump from 0x0180, if !msg.value // Inputs[1] { @01AA msg.data[0x04:0x24] } 0185 5B JUMPDEST 0186 50 POP 0187 61 PUSH2 0x01b0 018A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 01A7 19 NOT 01A8 60 PUSH1 0x04 01AA 35 CALLDATALOAD 01AB 16 AND 01AC 61 PUSH2 0x05fc 01AF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0187 stack[-1] = 0x01b0 // @01AB stack[0] = msg.data[0x04:0x24] & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff // } // Block ends with call to 0x05fc, returns to 0x01B0 label_01B0: // Incoming return from call to 0x0C70 at 0x0513 // Incoming return from call to 0x05FC at 0x01AF // Incoming return from call to 0x0E7D at 0x05FB // Incoming return from call to 0x0B55 at 0x04C8 // Inputs[4] // { // @01B4 memory[0x40:0x60] // @01B5 stack[-1] // @01BA memory[0x40:0x60] // @01C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 01B0 5B JUMPDEST 01B1 60 PUSH1 0x40 01B3 80 DUP1 01B4 51 MLOAD 01B5 91 SWAP2 01B6 15 ISZERO 01B7 15 ISZERO 01B8 82 DUP3 01B9 52 MSTORE 01BA 51 MLOAD 01BB 90 SWAP1 01BC 81 DUP2 01BD 90 SWAP1 01BE 03 SUB 01BF 60 PUSH1 0x20 01C1 01 ADD 01C2 90 SWAP1 01C3 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01C3 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_01C4: // Incoming jump from 0x004A, if 0x06fdde03 == stack[-1] // Inputs[1] { @01C5 msg.value } 01C4 5B JUMPDEST 01C5 34 CALLVALUE 01C6 80 DUP1 01C7 15 ISZERO 01C8 61 PUSH2 0x01d0 01CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01C5 stack[0] = msg.value } // Block ends with conditional jump to 0x01d0, if !msg.value label_01CC: // Incoming jump from 0x01CB, if not !msg.value // Inputs[1] { @01CF memory[0x00:0x00] } 01CC 60 PUSH1 0x00 01CE 80 DUP1 01CF FD *REVERT // Stack delta = +0 // Outputs[1] { @01CF revert(memory[0x00:0x00]); } // Block terminates label_01D0: // Incoming jump from 0x01CB, if !msg.value 01D0 5B JUMPDEST 01D1 50 POP 01D2 61 PUSH2 0x01d9 01D5 61 PUSH2 0x0630 01D8 56 *JUMP // Stack delta = +0 // Outputs[1] { @01D2 stack[-1] = 0x01d9 } // Block ends with call to 0x0630, returns to 0x01D9 label_01D9: // Incoming return from call to 0x0630 at 0x01D8 // Incoming return from call to 0x0C0F at 0x04FE // Incoming return from call to 0x0DBD at 0x05BF // Inputs[4] // { // @01DD memory[0x40:0x60] // @01E3 stack[-1] // @01E4 memory[stack[-1]:stack[-1] + 0x20] // @01EA memory[stack[-1]:stack[-1] + 0x20] // } 01D9 5B JUMPDEST 01DA 60 PUSH1 0x40 01DC 80 DUP1 01DD 51 MLOAD 01DE 60 PUSH1 0x20 01E0 80 DUP1 01E1 82 DUP3 01E2 52 MSTORE 01E3 83 DUP4 01E4 51 MLOAD 01E5 81 DUP2 01E6 83 DUP4 01E7 01 ADD 01E8 52 MSTORE 01E9 83 DUP4 01EA 51 MLOAD 01EB 91 SWAP2 01EC 92 SWAP3 01ED 83 DUP4 01EE 92 SWAP3 01EF 90 SWAP1 01F0 83 DUP4 01F1 01 ADD 01F2 91 SWAP2 01F3 85 DUP6 01F4 01 ADD 01F5 90 SWAP1 01F6 80 DUP1 01F7 83 DUP4 01F8 83 DUP4 01F9 60 PUSH1 0x00 01FB 5B JUMPDEST 01FC 83 DUP4 01FD 81 DUP2 01FE 10 LT 01FF 15 ISZERO 0200 61 PUSH2 0x0213 0203 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @01E8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @01EC stack[0] = memory[0x40:0x60] // @01EE stack[1] = memory[0x40:0x60] // @01F2 stack[2] = memory[0x40:0x60] + 0x40 // @01F5 stack[3] = stack[-1] + 0x20 // @01F5 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @01F6 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @01F7 stack[6] = memory[0x40:0x60] + 0x40 // @01F8 stack[7] = stack[-1] + 0x20 // @01F9 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0213, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0204: // Incoming jump from 0x0203, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0203, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0204 stack[-2] // @0205 stack[-1] // @0207 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0208 stack[-3] // } 0204 81 DUP2 0205 81 DUP2 0206 01 ADD 0207 51 MLOAD 0208 83 DUP4 0209 82 DUP3 020A 01 ADD 020B 52 MSTORE 020C 60 PUSH1 0x20 020E 01 ADD 020F 61 PUSH2 0x01fb 0212 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @020B memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @020E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x01fb label_0213: // Incoming jump from 0x0203, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0203, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0218 stack[-5] // @0218 stack[-6] // @021A stack[-7] // } 0213 5B JUMPDEST 0214 50 POP 0215 50 POP 0216 50 POP 0217 50 POP 0218 90 SWAP1 0219 50 POP 021A 90 SWAP1 021B 81 DUP2 021C 01 ADD 021D 90 SWAP1 021E 60 PUSH1 0x1f 0220 16 AND 0221 80 DUP1 0222 15 ISZERO 0223 61 PUSH2 0x0240 0226 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @021D stack[-7] = stack[-5] + stack[-7] // @0220 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0240, if !(0x1f & stack[-5]) label_0227: // Incoming jump from 0x0226, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0227 stack[-1] // @0228 stack[-2] // @022B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0242 stack[-5] // @0248 memory[0x40:0x60] // @024D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0227 80 DUP1 0228 82 DUP3 0229 03 SUB 022A 80 DUP1 022B 51 MLOAD 022C 60 PUSH1 0x01 022E 83 DUP4 022F 60 PUSH1 0x20 0231 03 SUB 0232 61 PUSH2 0x0100 0235 0A EXP 0236 03 SUB 0237 19 NOT 0238 16 AND 0239 81 DUP2 023A 52 MSTORE 023B 60 PUSH1 0x20 023D 01 ADD 023E 91 SWAP2 023F 50 POP 0240 5B JUMPDEST 0241 50 POP 0242 92 SWAP3 0243 50 POP 0244 50 POP 0245 50 POP 0246 60 PUSH1 0x40 0248 51 MLOAD 0249 80 DUP1 024A 91 SWAP2 024B 03 SUB 024C 90 SWAP1 024D F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @023A 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] // @024D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_024E: // Incoming jump from 0x0055, if 0x081812fc == stack[-1] // Inputs[1] { @024F msg.value } 024E 5B JUMPDEST 024F 34 CALLVALUE 0250 80 DUP1 0251 15 ISZERO 0252 61 PUSH2 0x025a 0255 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024F stack[0] = msg.value } // Block ends with conditional jump to 0x025a, if !msg.value label_0256: // Incoming jump from 0x0255, if not !msg.value // Inputs[1] { @0259 memory[0x00:0x00] } 0256 60 PUSH1 0x00 0258 80 DUP1 0259 FD *REVERT // Stack delta = +0 // Outputs[1] { @0259 revert(memory[0x00:0x00]); } // Block terminates label_025A: // Incoming jump from 0x0255, if !msg.value // Inputs[1] { @0261 msg.data[0x04:0x24] } 025A 5B JUMPDEST 025B 50 POP 025C 61 PUSH2 0x0266 025F 60 PUSH1 0x04 0261 35 CALLDATALOAD 0262 61 PUSH2 0x06c7 0265 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @025C stack[-1] = 0x0266 // @0261 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x06c7, returns to 0x0266 label_0266: // Incoming return from call to 0x0B14 at 0x0492 // Incoming return from call to 0x06C7 at 0x0265 // Inputs[4] // { // @026A memory[0x40:0x60] // @0274 stack[-1] // @0278 memory[0x40:0x60] // @0281 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0266 5B JUMPDEST 0267 60 PUSH1 0x40 0269 80 DUP1 026A 51 MLOAD 026B 60 PUSH1 0x01 026D 60 PUSH1 0xa0 026F 60 PUSH1 0x02 0271 0A EXP 0272 03 SUB 0273 90 SWAP1 0274 92 SWAP3 0275 16 AND 0276 82 DUP3 0277 52 MSTORE 0278 51 MLOAD 0279 90 SWAP1 027A 81 DUP2 027B 90 SWAP1 027C 03 SUB 027D 60 PUSH1 0x20 027F 01 ADD 0280 90 SWAP1 0281 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0277 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0x02 ** 0xa0 - 0x01 // @0281 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0282: // Incoming jump from 0x0060, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0283 msg.value } 0282 5B JUMPDEST 0283 34 CALLVALUE 0284 80 DUP1 0285 15 ISZERO 0286 61 PUSH2 0x028e 0289 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0283 stack[0] = msg.value } // Block ends with conditional jump to 0x028e, if !msg.value label_028A: // Incoming jump from 0x0289, if not !msg.value // Inputs[1] { @028D memory[0x00:0x00] } 028A 60 PUSH1 0x00 028C 80 DUP1 028D FD *REVERT // Stack delta = +0 // Outputs[1] { @028D revert(memory[0x00:0x00]); } // Block terminates label_028E: // Incoming jump from 0x0289, if !msg.value // Inputs[2] // { // @029D msg.data[0x04:0x24] // @02A1 msg.data[0x24:0x44] // } 028E 5B JUMPDEST 028F 50 POP 0290 61 PUSH2 0x02a6 0293 60 PUSH1 0x01 0295 60 PUSH1 0xa0 0297 60 PUSH1 0x02 0299 0A EXP 029A 03 SUB 029B 60 PUSH1 0x04 029D 35 CALLDATALOAD 029E 16 AND 029F 60 PUSH1 0x24 02A1 35 CALLDATALOAD 02A2 61 PUSH2 0x06f9 02A5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0290 stack[-1] = 0x02a6 // @029E stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // @02A1 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x06f9, returns to 0x02A6 label_02A6: // Incoming return from call to 0x0E72 at 0x05D4 // Incoming return from call to 0x0C79 at 0x0539 // Incoming return from call to 0x09C3 at 0x03E1 // Incoming return from call to 0x0D51 at 0x0586 // Incoming return from call to 0x06F9 at 0x02A5 // Incoming return from call to 0x07BC at 0x0319 02A6 5B JUMPDEST 02A7 00 *STOP // Stack delta = +0 // Outputs[1] { @02A7 stop(); } // Block terminates label_02A8: // Incoming jump from 0x006B, if 0x1785f53c == stack[-1] // Inputs[1] { @02A9 msg.value } 02A8 5B JUMPDEST 02A9 34 CALLVALUE 02AA 80 DUP1 02AB 15 ISZERO 02AC 61 PUSH2 0x02b4 02AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A9 stack[0] = msg.value } // Block ends with conditional jump to 0x02b4, if !msg.value label_02B0: // Incoming jump from 0x02AF, if not !msg.value // Inputs[1] { @02B3 memory[0x00:0x00] } 02B0 60 PUSH1 0x00 02B2 80 DUP1 02B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B3 revert(memory[0x00:0x00]); } // Block terminates label_02B4: // Incoming jump from 0x02AF, if !msg.value // Inputs[1] { @02C3 msg.data[0x04:0x24] } 02B4 5B JUMPDEST 02B5 50 POP 02B6 61 PUSH2 0x02a6 02B9 60 PUSH1 0x01 02BB 60 PUSH1 0xa0 02BD 60 PUSH1 0x02 02BF 0A EXP 02C0 03 SUB 02C1 60 PUSH1 0x04 02C3 35 CALLDATALOAD 02C4 16 AND 02C5 61 PUSH2 0x0796 02C8 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02B6 stack[-1] = 0x02a6 // @02C4 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with unconditional jump to 0x0796 label_02C9: // Incoming jump from 0x0076, if 0x18160ddd == stack[-1] // Inputs[1] { @02CA msg.value } 02C9 5B JUMPDEST 02CA 34 CALLVALUE 02CB 80 DUP1 02CC 15 ISZERO 02CD 61 PUSH2 0x02d5 02D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CA stack[0] = msg.value } // Block ends with conditional jump to 0x02d5, if !msg.value label_02D1: // Incoming jump from 0x02D0, if not !msg.value // Inputs[1] { @02D4 memory[0x00:0x00] } 02D1 60 PUSH1 0x00 02D3 80 DUP1 02D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D4 revert(memory[0x00:0x00]); } // Block terminates label_02D5: // Incoming jump from 0x02D0, if !msg.value 02D5 5B JUMPDEST 02D6 50 POP 02D7 61 PUSH2 0x02de 02DA 61 PUSH2 0x07b6 02DD 56 *JUMP // Stack delta = +0 // Outputs[1] { @02D7 stack[-1] = 0x02de } // Block ends with call to 0x07b6, returns to 0x02DE label_02DE: // Incoming return from call to 0x07B6 at 0x02DD // Incoming return from call to 0x0B63 at 0x04E9 // Incoming return from call to 0x0A32 at 0x0411 // Incoming return from call to 0x08B7 at 0x037F // Inputs[4] // { // @02E2 memory[0x40:0x60] // @02E3 stack[-1] // @02E6 memory[0x40:0x60] // @02EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 02DE 5B JUMPDEST 02DF 60 PUSH1 0x40 02E1 80 DUP1 02E2 51 MLOAD 02E3 91 SWAP2 02E4 82 DUP3 02E5 52 MSTORE 02E6 51 MLOAD 02E7 90 SWAP1 02E8 81 DUP2 02E9 90 SWAP1 02EA 03 SUB 02EB 60 PUSH1 0x20 02ED 01 ADD 02EE 90 SWAP1 02EF F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02EF return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_02F0: // Incoming jump from 0x0081, if 0x23b872dd == stack[-1] // Inputs[1] { @02F1 msg.value } 02F0 5B JUMPDEST 02F1 34 CALLVALUE 02F2 80 DUP1 02F3 15 ISZERO 02F4 61 PUSH2 0x02fc 02F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F1 stack[0] = msg.value } // Block ends with conditional jump to 0x02fc, if !msg.value label_02F8: // Incoming jump from 0x02F7, if not !msg.value // Inputs[1] { @02FB memory[0x00:0x00] } 02F8 60 PUSH1 0x00 02FA 80 DUP1 02FB FD *REVERT // Stack delta = +0 // Outputs[1] { @02FB revert(memory[0x00:0x00]); } // Block terminates label_02FC: // Incoming jump from 0x02F7, if !msg.value // Inputs[3] // { // @030B msg.data[0x04:0x24] // @0311 msg.data[0x24:0x44] // @0315 msg.data[0x44:0x64] // } 02FC 5B JUMPDEST 02FD 50 POP 02FE 61 PUSH2 0x02a6 0301 60 PUSH1 0x01 0303 60 PUSH1 0xa0 0305 60 PUSH1 0x02 0307 0A EXP 0308 03 SUB 0309 60 PUSH1 0x04 030B 35 CALLDATALOAD 030C 81 DUP2 030D 16 AND 030E 90 SWAP1 030F 60 PUSH1 0x24 0311 35 CALLDATALOAD 0312 16 AND 0313 60 PUSH1 0x44 0315 35 CALLDATALOAD 0316 61 PUSH2 0x07bc 0319 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02FE stack[-1] = 0x02a6 // @030E stack[0] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @0312 stack[1] = msg.data[0x24:0x44] & 0x02 ** 0xa0 - 0x01 // @0315 stack[2] = msg.data[0x44:0x64] // } // Block ends with call to 0x07bc, returns to 0x02A6 label_031A: // Incoming jump from 0x008C, if 0x24d7806c == stack[-1] // Inputs[1] { @031B msg.value } 031A 5B JUMPDEST 031B 34 CALLVALUE 031C 80 DUP1 031D 15 ISZERO 031E 61 PUSH2 0x0326 0321 57 *JUMPI // Stack delta = +1 // Outputs[1] { @031B stack[0] = msg.value } // Block ends with conditional jump to 0x0326, if !msg.value label_0322: // Incoming jump from 0x0321, if not !msg.value // Inputs[1] { @0325 memory[0x00:0x00] } 0322 60 PUSH1 0x00 0324 80 DUP1 0325 FD *REVERT // Stack delta = +0 // Outputs[1] { @0325 revert(memory[0x00:0x00]); } // Block terminates label_0326: // Incoming jump from 0x0321, if !msg.value // Inputs[1] { @0335 msg.data[0x04:0x24] } 0326 5B JUMPDEST 0327 50 POP 0328 61 PUSH2 0x01b0 032B 60 PUSH1 0x01 032D 60 PUSH1 0xa0 032F 60 PUSH1 0x02 0331 0A EXP 0332 03 SUB 0333 60 PUSH1 0x04 0335 35 CALLDATALOAD 0336 16 AND 0337 61 PUSH2 0x084a 033A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0328 stack[-1] = 0x01b0 // @0336 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with unconditional jump to 0x084a label_033B: // Incoming jump from 0x0097, if 0x26b3b1ee == stack[-1] // Inputs[1] { @033C msg.value } 033B 5B JUMPDEST 033C 34 CALLVALUE 033D 80 DUP1 033E 15 ISZERO 033F 61 PUSH2 0x0347 0342 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033C stack[0] = msg.value } // Block ends with conditional jump to 0x0347, if !msg.value label_0343: // Incoming jump from 0x0342, if not !msg.value // Inputs[1] { @0346 memory[0x00:0x00] } 0343 60 PUSH1 0x00 0345 80 DUP1 0346 FD *REVERT // Stack delta = +0 // Outputs[1] { @0346 revert(memory[0x00:0x00]); } // Block terminates label_0347: // Incoming jump from 0x0342, if !msg.value // Inputs[1] { @0356 msg.data[0x04:0x24] } 0347 5B JUMPDEST 0348 50 POP 0349 61 PUSH2 0x02a6 034C 60 PUSH1 0x01 034E 60 PUSH1 0xa0 0350 60 PUSH1 0x02 0352 0A EXP 0353 03 SUB 0354 60 PUSH1 0x04 0356 35 CALLDATALOAD 0357 16 AND 0358 61 PUSH2 0x0863 035B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0349 stack[-1] = 0x02a6 // @0357 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with unconditional jump to 0x0863 label_035C: // Incoming jump from 0x00A2, if 0x2f745c59 == stack[-1] // Inputs[1] { @035D msg.value } 035C 5B JUMPDEST 035D 34 CALLVALUE 035E 80 DUP1 035F 15 ISZERO 0360 61 PUSH2 0x0368 0363 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035D stack[0] = msg.value } // Block ends with conditional jump to 0x0368, if !msg.value label_0364: // Incoming jump from 0x0363, if not !msg.value // Inputs[1] { @0367 memory[0x00:0x00] } 0364 60 PUSH1 0x00 0366 80 DUP1 0367 FD *REVERT // Stack delta = +0 // Outputs[1] { @0367 revert(memory[0x00:0x00]); } // Block terminates label_0368: // Incoming jump from 0x0363, if !msg.value // Inputs[2] // { // @0377 msg.data[0x04:0x24] // @037B msg.data[0x24:0x44] // } 0368 5B JUMPDEST 0369 50 POP 036A 61 PUSH2 0x02de 036D 60 PUSH1 0x01 036F 60 PUSH1 0xa0 0371 60 PUSH1 0x02 0373 0A EXP 0374 03 SUB 0375 60 PUSH1 0x04 0377 35 CALLDATALOAD 0378 16 AND 0379 60 PUSH1 0x24 037B 35 CALLDATALOAD 037C 61 PUSH2 0x08b7 037F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @036A stack[-1] = 0x02de // @0378 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // @037B stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x08b7, returns to 0x02DE label_0380: // Incoming jump from 0x00AD, if 0x40abfe26 == stack[-1] // Inputs[1] { @0381 msg.value } 0380 5B JUMPDEST 0381 34 CALLVALUE 0382 80 DUP1 0383 15 ISZERO 0384 61 PUSH2 0x038c 0387 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0381 stack[0] = msg.value } // Block ends with conditional jump to 0x038c, if !msg.value label_0388: // Incoming jump from 0x0387, if not !msg.value // Inputs[1] { @038B memory[0x00:0x00] } 0388 60 PUSH1 0x00 038A 80 DUP1 038B FD *REVERT // Stack delta = +0 // Outputs[1] { @038B revert(memory[0x00:0x00]); } // Block terminates label_038C: // Incoming jump from 0x0387, if !msg.value // Inputs[1] { @039B msg.data[0x04:0x24] } 038C 5B JUMPDEST 038D 50 POP 038E 61 PUSH2 0x02a6 0391 60 PUSH1 0x01 0393 60 PUSH1 0xa0 0395 60 PUSH1 0x02 0397 0A EXP 0398 03 SUB 0399 60 PUSH1 0x04 039B 35 CALLDATALOAD 039C 16 AND 039D 61 PUSH2 0x097d 03A0 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @038E stack[-1] = 0x02a6 // @039C stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with unconditional jump to 0x097d label_03A1: // Incoming jump from 0x00B8, if 0x40c10f19 == stack[-1] // Inputs[1] { @03A2 msg.value } 03A1 5B JUMPDEST 03A2 34 CALLVALUE 03A3 80 DUP1 03A4 15 ISZERO 03A5 61 PUSH2 0x03ad 03A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A2 stack[0] = msg.value } // Block ends with conditional jump to 0x03ad, if !msg.value label_03A9: // Incoming jump from 0x03A8, if not !msg.value // Inputs[1] { @03AC memory[0x00:0x00] } 03A9 60 PUSH1 0x00 03AB 80 DUP1 03AC FD *REVERT // Stack delta = +0 // Outputs[1] { @03AC revert(memory[0x00:0x00]); } // Block terminates label_03AD: // Incoming jump from 0x03A8, if !msg.value // Inputs[2] // { // @03BC msg.data[0x04:0x24] // @03C0 msg.data[0x24:0x44] // } 03AD 5B JUMPDEST 03AE 50 POP 03AF 61 PUSH2 0x01b0 03B2 60 PUSH1 0x01 03B4 60 PUSH1 0xa0 03B6 60 PUSH1 0x02 03B8 0A EXP 03B9 03 SUB 03BA 60 PUSH1 0x04 03BC 35 CALLDATALOAD 03BD 16 AND 03BE 60 PUSH1 0x24 03C0 35 CALLDATALOAD 03C1 61 PUSH2 0x099a 03C4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03AF stack[-1] = 0x01b0 // @03BD stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // @03C0 stack[1] = msg.data[0x24:0x44] // } // Block ends with unconditional jump to 0x099a label_03C5: // Incoming jump from 0x00C3, if 0x42842e0e == stack[-1] // Inputs[3] // { // @03D3 msg.data[0x04:0x24] // @03D9 msg.data[0x24:0x44] // @03DD msg.data[0x44:0x64] // } 03C5 5B JUMPDEST 03C6 61 PUSH2 0x02a6 03C9 60 PUSH1 0x01 03CB 60 PUSH1 0xa0 03CD 60 PUSH1 0x02 03CF 0A EXP 03D0 03 SUB 03D1 60 PUSH1 0x04 03D3 35 CALLDATALOAD 03D4 81 DUP2 03D5 16 AND 03D6 90 SWAP1 03D7 60 PUSH1 0x24 03D9 35 CALLDATALOAD 03DA 16 AND 03DB 60 PUSH1 0x44 03DD 35 CALLDATALOAD 03DE 61 PUSH2 0x09c3 03E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C6 stack[0] = 0x02a6 // @03D6 stack[1] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @03DA stack[2] = msg.data[0x24:0x44] & 0x02 ** 0xa0 - 0x01 // @03DD stack[3] = msg.data[0x44:0x64] // } // Block ends with call to 0x09c3, returns to 0x02A6 label_03E2: // Incoming jump from 0x00CE, if 0x42966c68 == stack[-1] // Inputs[1] { @03E3 msg.value } 03E2 5B JUMPDEST 03E3 34 CALLVALUE 03E4 80 DUP1 03E5 15 ISZERO 03E6 61 PUSH2 0x03ee 03E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E3 stack[0] = msg.value } // Block ends with conditional jump to 0x03ee, if !msg.value label_03EA: // Incoming jump from 0x03E9, if not !msg.value // Inputs[1] { @03ED memory[0x00:0x00] } 03EA 60 PUSH1 0x00 03EC 80 DUP1 03ED FD *REVERT // Stack delta = +0 // Outputs[1] { @03ED revert(memory[0x00:0x00]); } // Block terminates label_03EE: // Incoming jump from 0x03E9, if !msg.value // Inputs[1] { @03F5 msg.data[0x04:0x24] } 03EE 5B JUMPDEST 03EF 50 POP 03F0 61 PUSH2 0x02a6 03F3 60 PUSH1 0x04 03F5 35 CALLDATALOAD 03F6 61 PUSH2 0x09fa 03F9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03F0 stack[-1] = 0x02a6 // @03F5 stack[0] = msg.data[0x04:0x24] // } // Block ends with unconditional jump to 0x09fa label_03FA: // Incoming jump from 0x00D9, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @03FB msg.value } 03FA 5B JUMPDEST 03FB 34 CALLVALUE 03FC 80 DUP1 03FD 15 ISZERO 03FE 61 PUSH2 0x0406 0401 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FB stack[0] = msg.value } // Block ends with conditional jump to 0x0406, if !msg.value label_0402: // Incoming jump from 0x0401, if not !msg.value // Inputs[1] { @0405 memory[0x00:0x00] } 0402 60 PUSH1 0x00 0404 80 DUP1 0405 FD *REVERT // Stack delta = +0 // Outputs[1] { @0405 revert(memory[0x00:0x00]); } // Block terminates label_0406: // Incoming jump from 0x0401, if !msg.value // Inputs[1] { @040D msg.data[0x04:0x24] } 0406 5B JUMPDEST 0407 50 POP 0408 61 PUSH2 0x02de 040B 60 PUSH1 0x04 040D 35 CALLDATALOAD 040E 61 PUSH2 0x0a32 0411 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0408 stack[-1] = 0x02de // @040D stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0a32, returns to 0x02DE label_0412: // Incoming jump from 0x00E4, if 0x50bb4e7f == stack[-1] // Inputs[1] { @0413 msg.value } 0412 5B JUMPDEST 0413 34 CALLVALUE 0414 80 DUP1 0415 15 ISZERO 0416 61 PUSH2 0x041e 0419 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0413 stack[0] = msg.value } // Block ends with conditional jump to 0x041e, if !msg.value label_041A: // Incoming jump from 0x0419, if not !msg.value // Inputs[1] { @041D memory[0x00:0x00] } 041A 60 PUSH1 0x00 041C 80 DUP1 041D FD *REVERT // Stack delta = +0 // Outputs[1] { @041D revert(memory[0x00:0x00]); } // Block terminates label_041E: // Incoming jump from 0x0419, if !msg.value // Inputs[7] // { // @0423 memory[0x40:0x60] // @042A msg.data[0x44:0x64] // @042E msg.data[msg.data[0x44:0x64] + 0x04:msg.data[0x44:0x64] + 0x04 + 0x20] // @0447 msg.data[0x04:0x24] // @0455 msg.data[0x24:0x44] // @0457 msg.data.length // @046A msg.data[0x24 + msg.data[0x44:0x64]:0x24 + msg.data[0x44:0x64] + msg.data[msg.data[0x44:0x64] + 0x04:msg.data[0x44:0x64] + 0x04 + 0x20]] // } 041E 5B JUMPDEST 041F 50 POP 0420 60 PUSH1 0x40 0422 80 DUP1 0423 51 MLOAD 0424 60 PUSH1 0x20 0426 60 PUSH1 0x04 0428 60 PUSH1 0x44 042A 35 CALLDATALOAD 042B 81 DUP2 042C 81 DUP2 042D 01 ADD 042E 35 CALLDATALOAD 042F 60 PUSH1 0x1f 0431 81 DUP2 0432 01 ADD 0433 84 DUP5 0434 90 SWAP1 0435 04 DIV 0436 84 DUP5 0437 02 MUL 0438 85 DUP6 0439 01 ADD 043A 84 DUP5 043B 01 ADD 043C 90 SWAP1 043D 95 SWAP6 043E 52 MSTORE 043F 84 DUP5 0440 84 DUP5 0441 52 MSTORE 0442 61 PUSH2 0x01b0 0445 94 SWAP5 0446 82 DUP3 0447 35 CALLDATALOAD 0448 60 PUSH1 0x01 044A 60 PUSH1 0xa0 044C 60 PUSH1 0x02 044E 0A EXP 044F 03 SUB 0450 16 AND 0451 94 SWAP5 0452 60 PUSH1 0x24 0454 80 DUP1 0455 35 CALLDATALOAD 0456 95 SWAP6 0457 36 CALLDATASIZE 0458 95 SWAP6 0459 94 SWAP5 045A 60 PUSH1 0x64 045C 94 SWAP5 045D 92 SWAP3 045E 01 ADD 045F 91 SWAP2 0460 90 SWAP1 0461 81 DUP2 0462 90 SWAP1 0463 84 DUP5 0464 01 ADD 0465 83 DUP4 0466 82 DUP3 0467 80 DUP1 0468 82 DUP3 0469 84 DUP5 046A 37 CALLDATACOPY 046B 50 POP 046C 94 SWAP5 046D 97 SWAP8 046E 50 POP 046F 61 PUSH2 0x0ae0 0472 96 SWAP7 0473 50 POP 0474 50 POP 0475 50 POP 0476 50 POP 0477 50 POP 0478 50 POP 0479 50 POP 047A 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @043E memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * ((msg.data[msg.data[0x44:0x64] + 0x04:msg.data[0x44:0x64] + 0x04 + 0x20] + 0x1f) / 0x20) // @0441 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[msg.data[0x44:0x64] + 0x04:msg.data[0x44:0x64] + 0x04 + 0x20] // @0445 stack[-1] = 0x01b0 // @0451 stack[0] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @0456 stack[1] = msg.data[0x24:0x44] // @046A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + msg.data[msg.data[0x44:0x64] + 0x04:msg.data[0x44:0x64] + 0x04 + 0x20]] = msg.data[0x24 + msg.data[0x44:0x64]:0x24 + msg.data[0x44:0x64] + msg.data[msg.data[0x44:0x64] + 0x04:msg.data[0x44:0x64] + 0x04 + 0x20]] // @046D stack[2] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ae0 label_047B: // Incoming jump from 0x00EF, if 0x6352211e == stack[-1] // Inputs[1] { @047C msg.value } 047B 5B JUMPDEST 047C 34 CALLVALUE 047D 80 DUP1 047E 15 ISZERO 047F 61 PUSH2 0x0487 0482 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047C stack[0] = msg.value } // Block ends with conditional jump to 0x0487, if !msg.value label_0483: // Incoming jump from 0x0482, if not !msg.value // Inputs[1] { @0486 memory[0x00:0x00] } 0483 60 PUSH1 0x00 0485 80 DUP1 0486 FD *REVERT // Stack delta = +0 // Outputs[1] { @0486 revert(memory[0x00:0x00]); } // Block terminates label_0487: // Incoming jump from 0x0482, if !msg.value // Inputs[1] { @048E msg.data[0x04:0x24] } 0487 5B JUMPDEST 0488 50 POP 0489 61 PUSH2 0x0266 048C 60 PUSH1 0x04 048E 35 CALLDATALOAD 048F 61 PUSH2 0x0b14 0492 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0489 stack[-1] = 0x0266 // @048E stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0b14, returns to 0x0266 label_0493: // Incoming jump from 0x00FA, if 0x70480275 == stack[-1] // Inputs[1] { @0494 msg.value } 0493 5B JUMPDEST 0494 34 CALLVALUE 0495 80 DUP1 0496 15 ISZERO 0497 61 PUSH2 0x049f 049A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0494 stack[0] = msg.value } // Block ends with conditional jump to 0x049f, if !msg.value label_049B: // Incoming jump from 0x049A, if not !msg.value // Inputs[1] { @049E memory[0x00:0x00] } 049B 60 PUSH1 0x00 049D 80 DUP1 049E FD *REVERT // Stack delta = +0 // Outputs[1] { @049E revert(memory[0x00:0x00]); } // Block terminates label_049F: // Incoming jump from 0x049A, if !msg.value // Inputs[1] { @04AE msg.data[0x04:0x24] } 049F 5B JUMPDEST 04A0 50 POP 04A1 61 PUSH2 0x02a6 04A4 60 PUSH1 0x01 04A6 60 PUSH1 0xa0 04A8 60 PUSH1 0x02 04AA 0A EXP 04AB 03 SUB 04AC 60 PUSH1 0x04 04AE 35 CALLDATALOAD 04AF 16 AND 04B0 61 PUSH2 0x0b38 04B3 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04A1 stack[-1] = 0x02a6 // @04AF stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with unconditional jump to 0x0b38 label_04B4: // Incoming jump from 0x0105, if 0x706e7373 == stack[-1] // Inputs[1] { @04B5 msg.value } 04B4 5B JUMPDEST 04B5 34 CALLVALUE 04B6 80 DUP1 04B7 15 ISZERO 04B8 61 PUSH2 0x04c0 04BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B5 stack[0] = msg.value } // Block ends with conditional jump to 0x04c0, if !msg.value label_04BC: // Incoming jump from 0x04BB, if not !msg.value // Inputs[1] { @04BF memory[0x00:0x00] } 04BC 60 PUSH1 0x00 04BE 80 DUP1 04BF FD *REVERT // Stack delta = +0 // Outputs[1] { @04BF revert(memory[0x00:0x00]); } // Block terminates label_04C0: // Incoming jump from 0x04BB, if !msg.value 04C0 5B JUMPDEST 04C1 50 POP 04C2 61 PUSH2 0x01b0 04C5 61 PUSH2 0x0b55 04C8 56 *JUMP // Stack delta = +0 // Outputs[1] { @04C2 stack[-1] = 0x01b0 } // Block ends with call to 0x0b55, returns to 0x01B0 label_04C9: // Incoming jump from 0x0110, if 0x70a08231 == stack[-1] // Inputs[1] { @04CA msg.value } 04C9 5B JUMPDEST 04CA 34 CALLVALUE 04CB 80 DUP1 04CC 15 ISZERO 04CD 61 PUSH2 0x04d5 04D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CA stack[0] = msg.value } // Block ends with conditional jump to 0x04d5, if !msg.value label_04D1: // Incoming jump from 0x04D0, if not !msg.value // Inputs[1] { @04D4 memory[0x00:0x00] } 04D1 60 PUSH1 0x00 04D3 80 DUP1 04D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D4 revert(memory[0x00:0x00]); } // Block terminates label_04D5: // Incoming jump from 0x04D0, if !msg.value // Inputs[1] { @04E4 msg.data[0x04:0x24] } 04D5 5B JUMPDEST 04D6 50 POP 04D7 61 PUSH2 0x02de 04DA 60 PUSH1 0x01 04DC 60 PUSH1 0xa0 04DE 60 PUSH1 0x02 04E0 0A EXP 04E1 03 SUB 04E2 60 PUSH1 0x04 04E4 35 CALLDATALOAD 04E5 16 AND 04E6 61 PUSH2 0x0b63 04E9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04D7 stack[-1] = 0x02de // @04E5 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x0b63, returns to 0x02DE label_04EA: // Incoming jump from 0x011B, if 0x95d89b41 == stack[-1] // Inputs[1] { @04EB msg.value } 04EA 5B JUMPDEST 04EB 34 CALLVALUE 04EC 80 DUP1 04ED 15 ISZERO 04EE 61 PUSH2 0x04f6 04F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04EB stack[0] = msg.value } // Block ends with conditional jump to 0x04f6, if !msg.value label_04F2: // Incoming jump from 0x04F1, if not !msg.value // Inputs[1] { @04F5 memory[0x00:0x00] } 04F2 60 PUSH1 0x00 04F4 80 DUP1 04F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F5 revert(memory[0x00:0x00]); } // Block terminates label_04F6: // Incoming jump from 0x04F1, if !msg.value 04F6 5B JUMPDEST 04F7 50 POP 04F8 61 PUSH2 0x01d9 04FB 61 PUSH2 0x0c0f 04FE 56 *JUMP // Stack delta = +0 // Outputs[1] { @04F8 stack[-1] = 0x01d9 } // Block ends with call to 0x0c0f, returns to 0x01D9 label_04FF: // Incoming jump from 0x0126, if 0xa07c7ce4 == stack[-1] // Inputs[1] { @0500 msg.value } 04FF 5B JUMPDEST 0500 34 CALLVALUE 0501 80 DUP1 0502 15 ISZERO 0503 61 PUSH2 0x050b 0506 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0500 stack[0] = msg.value } // Block ends with conditional jump to 0x050b, if !msg.value label_0507: // Incoming jump from 0x0506, if not !msg.value // Inputs[1] { @050A memory[0x00:0x00] } 0507 60 PUSH1 0x00 0509 80 DUP1 050A FD *REVERT // Stack delta = +0 // Outputs[1] { @050A revert(memory[0x00:0x00]); } // Block terminates label_050B: // Incoming jump from 0x0506, if !msg.value 050B 5B JUMPDEST 050C 50 POP 050D 61 PUSH2 0x01b0 0510 61 PUSH2 0x0c70 0513 56 *JUMP // Stack delta = +0 // Outputs[1] { @050D stack[-1] = 0x01b0 } // Block ends with call to 0x0c70, returns to 0x01B0 label_0514: // Incoming jump from 0x0131, if 0xa22cb465 == stack[-1] // Inputs[1] { @0515 msg.value } 0514 5B JUMPDEST 0515 34 CALLVALUE 0516 80 DUP1 0517 15 ISZERO 0518 61 PUSH2 0x0520 051B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0515 stack[0] = msg.value } // Block ends with conditional jump to 0x0520, if !msg.value label_051C: // Incoming jump from 0x051B, if not !msg.value // Inputs[1] { @051F memory[0x00:0x00] } 051C 60 PUSH1 0x00 051E 80 DUP1 051F FD *REVERT // Stack delta = +0 // Outputs[1] { @051F revert(memory[0x00:0x00]); } // Block terminates label_0520: // Incoming jump from 0x051B, if !msg.value // Inputs[2] // { // @052F msg.data[0x04:0x24] // @0533 msg.data[0x24:0x44] // } 0520 5B JUMPDEST 0521 50 POP 0522 61 PUSH2 0x02a6 0525 60 PUSH1 0x01 0527 60 PUSH1 0xa0 0529 60 PUSH1 0x02 052B 0A EXP 052C 03 SUB 052D 60 PUSH1 0x04 052F 35 CALLDATALOAD 0530 16 AND 0531 60 PUSH1 0x24 0533 35 CALLDATALOAD 0534 15 ISZERO 0535 15 ISZERO 0536 61 PUSH2 0x0c79 0539 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0522 stack[-1] = 0x02a6 // @0530 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // @0535 stack[1] = !!msg.data[0x24:0x44] // } // Block ends with call to 0x0c79, returns to 0x02A6 label_053A: // Incoming jump from 0x013C, if 0xa75d5254 == stack[-1] // Inputs[1] { @053B msg.value } 053A 5B JUMPDEST 053B 34 CALLVALUE 053C 80 DUP1 053D 15 ISZERO 053E 61 PUSH2 0x0546 0541 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053B stack[0] = msg.value } // Block ends with conditional jump to 0x0546, if !msg.value label_0542: // Incoming jump from 0x0541, if not !msg.value // Inputs[1] { @0545 memory[0x00:0x00] } 0542 60 PUSH1 0x00 0544 80 DUP1 0545 FD *REVERT // Stack delta = +0 // Outputs[1] { @0545 revert(memory[0x00:0x00]); } // Block terminates label_0546: // Incoming jump from 0x0541, if !msg.value // Inputs[1] { @0555 msg.data[0x04:0x24] } 0546 5B JUMPDEST 0547 50 POP 0548 61 PUSH2 0x02a6 054B 60 PUSH1 0x01 054D 60 PUSH1 0xa0 054F 60 PUSH1 0x02 0551 0A EXP 0552 03 SUB 0553 60 PUSH1 0x04 0555 35 CALLDATALOAD 0556 16 AND 0557 61 PUSH2 0x0cfd 055A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0548 stack[-1] = 0x02a6 // @0556 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with unconditional jump to 0x0cfd label_055B: // Incoming jump from 0x0147, if 0xb88d4fde == stack[-1] // Inputs[5] // { // @056A msg.data[0x04:0x24] // @0571 msg.data[0x24:0x44] // @0578 msg.data[0x44:0x64] // @057C msg.data[0x64:0x84] // @0582 msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] // } 055B 5B JUMPDEST 055C 61 PUSH2 0x02a6 055F 60 PUSH1 0x01 0561 60 PUSH1 0xa0 0563 60 PUSH1 0x02 0565 0A EXP 0566 03 SUB 0567 60 PUSH1 0x04 0569 80 DUP1 056A 35 CALLDATALOAD 056B 82 DUP3 056C 16 AND 056D 91 SWAP2 056E 60 PUSH1 0x24 0570 80 DUP1 0571 35 CALLDATALOAD 0572 90 SWAP1 0573 91 SWAP2 0574 16 AND 0575 91 SWAP2 0576 60 PUSH1 0x44 0578 35 CALLDATALOAD 0579 91 SWAP2 057A 60 PUSH1 0x64 057C 35 CALLDATALOAD 057D 90 SWAP1 057E 81 DUP2 057F 01 ADD 0580 91 SWAP2 0581 01 ADD 0582 35 CALLDATALOAD 0583 61 PUSH2 0x0d51 0586 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @055C stack[0] = 0x02a6 // @056D stack[1] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @0575 stack[2] = 0x02 ** 0xa0 - 0x01 & msg.data[0x24:0x44] // @0579 stack[3] = msg.data[0x44:0x64] // @0580 stack[4] = msg.data[0x64:0x84] + 0x24 // @0582 stack[5] = msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] // } // Block ends with call to 0x0d51, returns to 0x02A6 label_0587: // Incoming jump from 0x0152, if 0xbc9ac68c == stack[-1] // Inputs[1] { @0588 msg.value } 0587 5B JUMPDEST 0588 34 CALLVALUE 0589 80 DUP1 058A 15 ISZERO 058B 61 PUSH2 0x0593 058E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0588 stack[0] = msg.value } // Block ends with conditional jump to 0x0593, if !msg.value label_058F: // Incoming jump from 0x058E, if not !msg.value // Inputs[1] { @0592 memory[0x00:0x00] } 058F 60 PUSH1 0x00 0591 80 DUP1 0592 FD *REVERT // Stack delta = +0 // Outputs[1] { @0592 revert(memory[0x00:0x00]); } // Block terminates label_0593: // Incoming jump from 0x058E, if !msg.value // Inputs[1] { @05A2 msg.data[0x04:0x24] } 0593 5B JUMPDEST 0594 50 POP 0595 61 PUSH2 0x01b0 0598 60 PUSH1 0x01 059A 60 PUSH1 0xa0 059C 60 PUSH1 0x02 059E 0A EXP 059F 03 SUB 05A0 60 PUSH1 0x04 05A2 35 CALLDATALOAD 05A3 16 AND 05A4 61 PUSH2 0x0daa 05A7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0595 stack[-1] = 0x01b0 // @05A3 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with unconditional jump to 0x0daa label_05A8: // Incoming jump from 0x015D, if 0xc87b56dd == stack[-1] // Inputs[1] { @05A9 msg.value } 05A8 5B JUMPDEST 05A9 34 CALLVALUE 05AA 80 DUP1 05AB 15 ISZERO 05AC 61 PUSH2 0x05b4 05AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A9 stack[0] = msg.value } // Block ends with conditional jump to 0x05b4, if !msg.value label_05B0: // Incoming jump from 0x05AF, if not !msg.value // Inputs[1] { @05B3 memory[0x00:0x00] } 05B0 60 PUSH1 0x00 05B2 80 DUP1 05B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B3 revert(memory[0x00:0x00]); } // Block terminates label_05B4: // Incoming jump from 0x05AF, if !msg.value // Inputs[1] { @05BB msg.data[0x04:0x24] } 05B4 5B JUMPDEST 05B5 50 POP 05B6 61 PUSH2 0x01d9 05B9 60 PUSH1 0x04 05BB 35 CALLDATALOAD 05BC 61 PUSH2 0x0dbd 05BF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05B6 stack[-1] = 0x01d9 // @05BB stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0dbd, returns to 0x01D9 label_05C0: // Incoming jump from 0x0168, if 0xe19e4349 == stack[-1] // Inputs[1] { @05C1 msg.value } 05C0 5B JUMPDEST 05C1 34 CALLVALUE 05C2 80 DUP1 05C3 15 ISZERO 05C4 61 PUSH2 0x05cc 05C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C1 stack[0] = msg.value } // Block ends with conditional jump to 0x05cc, if !msg.value label_05C8: // Incoming jump from 0x05C7, if not !msg.value // Inputs[1] { @05CB memory[0x00:0x00] } 05C8 60 PUSH1 0x00 05CA 80 DUP1 05CB FD *REVERT // Stack delta = +0 // Outputs[1] { @05CB revert(memory[0x00:0x00]); } // Block terminates label_05CC: // Incoming jump from 0x05C7, if !msg.value 05CC 5B JUMPDEST 05CD 50 POP 05CE 61 PUSH2 0x02a6 05D1 61 PUSH2 0x0e72 05D4 56 *JUMP // Stack delta = +0 // Outputs[1] { @05CE stack[-1] = 0x02a6 } // Block ends with call to 0x0e72, returns to 0x02A6 label_05D5: // Incoming jump from 0x0173, if 0xe985e9c5 == stack[-1] // Inputs[1] { @05D6 msg.value } 05D5 5B JUMPDEST 05D6 34 CALLVALUE 05D7 80 DUP1 05D8 15 ISZERO 05D9 61 PUSH2 0x05e1 05DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D6 stack[0] = msg.value } // Block ends with conditional jump to 0x05e1, if !msg.value label_05DD: // Incoming jump from 0x05DC, if not !msg.value // Inputs[1] { @05E0 memory[0x00:0x00] } 05DD 60 PUSH1 0x00 05DF 80 DUP1 05E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E0 revert(memory[0x00:0x00]); } // Block terminates label_05E1: // Incoming jump from 0x05DC, if !msg.value // Inputs[2] // { // @05F0 msg.data[0x04:0x24] // @05F6 msg.data[0x24:0x44] // } 05E1 5B JUMPDEST 05E2 50 POP 05E3 61 PUSH2 0x01b0 05E6 60 PUSH1 0x01 05E8 60 PUSH1 0xa0 05EA 60 PUSH1 0x02 05EC 0A EXP 05ED 03 SUB 05EE 60 PUSH1 0x04 05F0 35 CALLDATALOAD 05F1 81 DUP2 05F2 16 AND 05F3 90 SWAP1 05F4 60 PUSH1 0x24 05F6 35 CALLDATALOAD 05F7 16 AND 05F8 61 PUSH2 0x0e7d 05FB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05E3 stack[-1] = 0x01b0 // @05F3 stack[0] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @05F7 stack[1] = msg.data[0x24:0x44] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x0e7d, returns to 0x01B0 label_05FC: // Incoming call from 0x01AF, returns to 0x01B0 // Inputs[4] // { // @061B stack[-1] // @0629 memory[0x00:0x40] // @062A storage[keccak256(memory[0x00:0x40])] // @062E stack[-2] // } 05FC 5B JUMPDEST 05FD 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 061A 19 NOT 061B 16 AND 061C 60 PUSH1 0x00 061E 90 SWAP1 061F 81 DUP2 0620 52 MSTORE 0621 60 PUSH1 0x20 0623 81 DUP2 0624 90 SWAP1 0625 52 MSTORE 0626 60 PUSH1 0x40 0628 90 SWAP1 0629 20 SHA3 062A 54 SLOAD 062B 60 PUSH1 0xff 062D 16 AND 062E 90 SWAP1 062F 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0620 memory[0x00:0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0625 memory[0x20:0x40] = 0x00 // @062E stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0630: // Incoming call from 0x01D8, returns to 0x01D9 // Inputs[2] // { // @0634 storage[0x03] // @0638 memory[0x40:0x60] // } 0630 5B JUMPDEST 0631 60 PUSH1 0x03 0633 80 DUP1 0634 54 SLOAD 0635 60 PUSH1 0x40 0637 80 DUP1 0638 51 MLOAD 0639 60 PUSH1 0x20 063B 60 PUSH1 0x1f 063D 60 PUSH1 0x02 063F 60 PUSH1 0x00 0641 19 NOT 0642 61 PUSH2 0x0100 0645 60 PUSH1 0x01 0647 88 DUP9 0648 16 AND 0649 15 ISZERO 064A 02 MUL 064B 01 ADD 064C 90 SWAP1 064D 95 SWAP6 064E 16 AND 064F 94 SWAP5 0650 90 SWAP1 0651 94 SWAP5 0652 04 DIV 0653 93 SWAP4 0654 84 DUP5 0655 01 ADD 0656 81 DUP2 0657 90 SWAP1 0658 04 DIV 0659 81 DUP2 065A 02 MUL 065B 82 DUP3 065C 01 ADD 065D 81 DUP2 065E 01 ADD 065F 90 SWAP1 0660 92 SWAP3 0661 52 MSTORE 0662 82 DUP3 0663 81 DUP2 0664 52 MSTORE 0665 60 PUSH1 0x60 0667 93 SWAP4 0668 90 SWAP1 0669 92 SWAP3 066A 90 SWAP1 066B 91 SWAP2 066C 83 DUP4 066D 01 ADD 066E 82 DUP3 066F 82 DUP3 0670 80 DUP1 0671 15 ISZERO 0672 61 PUSH2 0x06bc 0675 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0661 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0664 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0667 stack[0] = 0x60 // @0669 stack[1] = memory[0x40:0x60] // @066A stack[3] = (storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02 // @066B stack[2] = 0x03 // @066D stack[4] = memory[0x40:0x60] + 0x20 // @066E stack[5] = 0x03 // @066F stack[6] = (storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x06bc, if !((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0676: // Incoming jump from 0x0675, if not !((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0676 stack[-1] } 0676 80 DUP1 0677 60 PUSH1 0x1f 0679 10 LT 067A 61 PUSH2 0x0691 067D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0691, if 0x1f < stack[-1] label_067E: // Incoming jump from 0x067D, if not 0x1f < stack[-1] // Inputs[4] // { // @0682 stack[-2] // @0683 storage[stack[-2]] // @0686 stack[-3] // @0688 stack[-1] // } 067E 61 PUSH2 0x0100 0681 80 DUP1 0682 83 DUP4 0683 54 SLOAD 0684 04 DIV 0685 02 MUL 0686 83 DUP4 0687 52 MSTORE 0688 91 SWAP2 0689 60 PUSH1 0x20 068B 01 ADD 068C 91 SWAP2 068D 61 PUSH2 0x06bc 0690 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0687 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @068C stack[-1] = stack[-1] // @068C stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06bc label_0691: // Incoming jump from 0x0C5C, if 0x1f < stack[-1] // Incoming jump from 0x067D, if 0x1f < stack[-1] // Inputs[5] // { // @0692 stack[-3] // @0693 stack[-1] // @0695 stack[-2] // @069D memory[0x00:0x20] // @06A1 storage[keccak256(memory[0x00:0x20])] // } 0691 5B JUMPDEST 0692 82 DUP3 0693 01 ADD 0694 91 SWAP2 0695 90 SWAP1 0696 60 PUSH1 0x00 0698 52 MSTORE 0699 60 PUSH1 0x20 069B 60 PUSH1 0x00 069D 20 SHA3 069E 90 SWAP1 069F 5B JUMPDEST 06A0 81 DUP2 06A1 54 SLOAD 06A2 81 DUP2 06A3 52 MSTORE 06A4 90 SWAP1 06A5 60 PUSH1 0x01 06A7 01 ADD 06A8 90 SWAP1 06A9 60 PUSH1 0x20 06AB 01 ADD 06AC 80 DUP1 06AD 83 DUP4 06AE 11 GT 06AF 61 PUSH2 0x069f 06B2 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0694 stack[-3] = stack[-3] + stack[-1] // @0698 memory[0x00:0x20] = stack[-2] // @06A3 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06A8 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06AB stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x069f, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06B3: // Incoming jump from 0x06B2, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x06B2, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @06B3 stack[-3] // @06B4 stack[-1] // } 06B3 82 DUP3 06B4 90 SWAP1 06B5 03 SUB 06B6 60 PUSH1 0x1f 06B8 16 AND 06B9 82 DUP3 06BA 01 ADD 06BB 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06BB stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06BB stack[-1] = stack[-3] // } // Block continues label_06BC: // Incoming jump from 0x0690 // Incoming jump from 0x06BB // Incoming jump from 0x0C6F // Incoming jump from 0x0C54, if !((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0675, if !((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[3] // { // @06C2 stack[-7] // @06C2 stack[-6] // @06C5 stack[-8] // } 06BC 5B JUMPDEST 06BD 50 POP 06BE 50 POP 06BF 50 POP 06C0 50 POP 06C1 50 POP 06C2 90 SWAP1 06C3 50 POP 06C4 5B JUMPDEST 06C5 90 SWAP1 06C6 56 *JUMP // Stack delta = -7 // Outputs[1] { @06C5 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_06C7: // Incoming call from 0x0265, returns to 0x0266 // Incoming call from 0x0F4B, returns to 0x0F4C // Inputs[1] { @06CD stack[-1] } 06C7 5B JUMPDEST 06C8 60 PUSH1 0x00 06CA 61 PUSH2 0x06d2 06CD 82 DUP3 06CE 61 PUSH2 0x0eab 06D1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06C8 stack[0] = 0x00 // @06CA stack[1] = 0x06d2 // @06CD stack[2] = stack[-1] // } // Block ends with call to 0x0eab, returns to 0x06D2 label_06D2: // Incoming return from call to 0x0EAB at 0x06D1 // Inputs[1] { @06D3 stack[-1] } 06D2 5B JUMPDEST 06D3 15 ISZERO 06D4 15 ISZERO 06D5 61 PUSH2 0x06dd 06D8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06dd, if !!stack[-1] label_06D9: // Incoming jump from 0x06D8, if not !!stack[-1] // Inputs[1] { @06DC memory[0x00:0x00] } 06D9 60 PUSH1 0x00 06DB 80 DUP1 06DC FD *REVERT // Stack delta = +0 // Outputs[1] { @06DC revert(memory[0x00:0x00]); } // Block terminates label_06DD: // Incoming jump from 0x06D8, if !!stack[-1] // Inputs[4] // { // @06E1 stack[-2] // @06EC memory[0x00:0x40] // @06ED storage[keccak256(memory[0x00:0x40])] // @06F7 stack[-3] // } 06DD 5B JUMPDEST 06DE 50 POP 06DF 60 PUSH1 0x00 06E1 90 SWAP1 06E2 81 DUP2 06E3 52 MSTORE 06E4 60 PUSH1 0x0b 06E6 60 PUSH1 0x20 06E8 52 MSTORE 06E9 60 PUSH1 0x40 06EB 90 SWAP1 06EC 20 SHA3 06ED 54 SLOAD 06EE 60 PUSH1 0x01 06F0 60 PUSH1 0xa0 06F2 60 PUSH1 0x02 06F4 0A EXP 06F5 03 SUB 06F6 16 AND 06F7 90 SWAP1 06F8 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @06E3 memory[0x00:0x20] = stack[-2] // @06E8 memory[0x20:0x40] = 0x0b // @06F7 stack[-3] = 0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_06F9: // Incoming call from 0x02A5, returns to 0x02A6 // Inputs[1] { @06FF stack[-1] } 06F9 5B JUMPDEST 06FA 60 PUSH1 0x00 06FC 61 PUSH2 0x0704 06FF 82 DUP3 0700 61 PUSH2 0x0b14 0703 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06FA stack[0] = 0x00 // @06FC stack[1] = 0x0704 // @06FF stack[2] = stack[-1] // } // Block ends with call to 0x0b14, returns to 0x0704 label_0704: // Incoming return from call to 0x0B14 at 0x0703 // Inputs[3] // { // @0705 stack[-2] // @0705 stack[-1] // @0707 msg.sender // } 0704 5B JUMPDEST 0705 90 SWAP1 0706 50 POP 0707 33 CALLER 0708 60 PUSH1 0x01 070A 60 PUSH1 0xa0 070C 60 PUSH1 0x02 070E 0A EXP 070F 03 SUB 0710 82 DUP3 0711 16 AND 0712 14 EQ 0713 80 DUP1 0714 61 PUSH2 0x0722 0717 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0705 stack[-2] = stack[-1] // @0712 stack[-1] = stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender // } // Block ends with conditional jump to 0x0722, if stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender label_0718: // Incoming jump from 0x0717, if not stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender // Inputs[2] // { // @071C stack[-2] // @071D msg.sender // } 0718 50 POP 0719 61 PUSH2 0x0722 071C 81 DUP2 071D 33 CALLER 071E 61 PUSH2 0x0e7d 0721 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0719 stack[-1] = 0x0722 // @071C stack[0] = stack[-2] // @071D stack[1] = msg.sender // } // Block ends with call to 0x0e7d, returns to 0x0722 label_0722: // Incoming jump from 0x0717, if stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender // Incoming return from call to 0x0E7D at 0x0721 // Inputs[1] { @0723 stack[-1] } 0722 5B JUMPDEST 0723 15 ISZERO 0724 15 ISZERO 0725 61 PUSH2 0x072d 0728 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x072d, if !!stack[-1] label_0729: // Incoming jump from 0x0728, if not !!stack[-1] // Inputs[1] { @072C memory[0x00:0x00] } 0729 60 PUSH1 0x00 072B 80 DUP1 072C FD *REVERT // Stack delta = +0 // Outputs[1] { @072C revert(memory[0x00:0x00]); } // Block terminates label_072D: // Incoming jump from 0x0728, if !!stack[-1] // Inputs[8] // { // @0730 stack[-2] // @073C memory[0x00:0x40] // @073E storage[keccak256(memory[0x00:0x40])] // @075E stack[-3] // @0768 memory[0x40:0x60] // @076C stack[-1] // @0791 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0795 stack[-4] // } 072D 5B JUMPDEST 072E 60 PUSH1 0x00 0730 82 DUP3 0731 81 DUP2 0732 52 MSTORE 0733 60 PUSH1 0x0b 0735 60 PUSH1 0x20 0737 52 MSTORE 0738 60 PUSH1 0x40 073A 80 DUP1 073B 82 DUP3 073C 20 SHA3 073D 80 DUP1 073E 54 SLOAD 073F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0754 19 NOT 0755 16 AND 0756 60 PUSH1 0x01 0758 60 PUSH1 0xa0 075A 60 PUSH1 0x02 075C 0A EXP 075D 03 SUB 075E 87 DUP8 075F 81 DUP2 0760 16 AND 0761 91 SWAP2 0762 82 DUP3 0763 17 OR 0764 90 SWAP1 0765 92 SWAP3 0766 55 SSTORE 0767 91 SWAP2 0768 51 MLOAD 0769 85 DUP6 076A 93 SWAP4 076B 91 SWAP2 076C 85 DUP6 076D 16 AND 076E 91 SWAP2 076F 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0790 91 SWAP2 0791 A4 LOG4 0792 50 POP 0793 50 POP 0794 50 POP 0795 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0732 memory[0x00:0x20] = stack[-2] // @0737 memory[0x20:0x40] = 0x0b // @0766 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & 0x02 ** 0xa0 - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @0791 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0x02 ** 0xa0 - 0x01, stack[-3] & 0x02 ** 0xa0 - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0796: // Incoming jump from 0x02C8 // Inputs[1] { @079A msg.sender } 0796 5B JUMPDEST 0797 61 PUSH2 0x079f 079A 33 CALLER 079B 61 PUSH2 0x084a 079E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0797 stack[0] = 0x079f // @079A stack[1] = msg.sender // } // Block ends with unconditional jump to 0x084a 079F 5B JUMPDEST 07A0 15 ISZERO 07A1 15 ISZERO 07A2 61 PUSH2 0x07aa 07A5 57 *JUMPI 07A6 60 PUSH1 0x00 07A8 80 DUP1 07A9 FD *REVERT 07AA 5B JUMPDEST 07AB 61 PUSH2 0x07b3 07AE 81 DUP2 07AF 61 PUSH2 0x0ec8 07B2 56 *JUMP label_07B3: // Incoming return from call to 0x18E0 at 0x1861 // Incoming jump from 0x1843 // Incoming return from call to 0x155C at 0x0A31 // Inputs[1] { @07B5 stack[-2] } 07B3 5B JUMPDEST 07B4 50 POP 07B5 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_07B6: // Incoming call from 0x02DD, returns to 0x02DE // Incoming call from 0x0AB4, returns to 0x0AB5 // Inputs[2] // { // @07B9 storage[0x06] // @07BA stack[-1] // } 07B6 5B JUMPDEST 07B7 60 PUSH1 0x06 07B9 54 SLOAD 07BA 90 SWAP1 07BB 56 *JUMP // Stack delta = +0 // Outputs[1] { @07BA stack[-1] = storage[0x06] } // Block ends with unconditional jump to stack[-1] label_07BC: // Incoming call from 0x09CD, returns to 0x09CE // Incoming call from 0x0D5B, returns to 0x0D5C // Incoming call from 0x0319, returns to 0x02A6 // Inputs[2] // { // @07C0 msg.sender // @07C1 stack[-1] // } 07BC 5B JUMPDEST 07BD 61 PUSH2 0x07c6 07C0 33 CALLER 07C1 82 DUP3 07C2 61 PUSH2 0x0f10 07C5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07BD stack[0] = 0x07c6 // @07C0 stack[1] = msg.sender // @07C1 stack[2] = stack[-1] // } // Block ends with call to 0x0f10, returns to 0x07C6 label_07C6: // Incoming return from call to 0x0F10 at 0x07C5 // Inputs[1] { @07C7 stack[-1] } 07C6 5B JUMPDEST 07C7 15 ISZERO 07C8 15 ISZERO 07C9 61 PUSH2 0x07d1 07CC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07d1, if !!stack[-1] label_07CD: // Incoming jump from 0x07CC, if not !!stack[-1] // Inputs[1] { @07D0 memory[0x00:0x00] } 07CD 60 PUSH1 0x00 07CF 80 DUP1 07D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @07D0 revert(memory[0x00:0x00]); } // Block terminates label_07D1: // Incoming jump from 0x07CC, if !!stack[-1] // Inputs[1] { @07DA stack[-2] } 07D1 5B JUMPDEST 07D2 60 PUSH1 0x01 07D4 60 PUSH1 0xa0 07D6 60 PUSH1 0x02 07D8 0A EXP 07D9 03 SUB 07DA 82 DUP3 07DB 16 AND 07DC 15 ISZERO 07DD 15 ISZERO 07DE 61 PUSH2 0x07e6 07E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e6, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) label_07E2: // Incoming jump from 0x07E1, if not !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @07E5 memory[0x00:0x00] } 07E2 60 PUSH1 0x00 07E4 80 DUP1 07E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @07E5 revert(memory[0x00:0x00]); } // Block terminates label_07E6: // Incoming jump from 0x07E1, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[2] // { // @07EA stack[-3] // @07EB stack[-1] // } 07E6 5B JUMPDEST 07E7 61 PUSH2 0x07f0 07EA 83 DUP4 07EB 82 DUP3 07EC 61 PUSH2 0x0f6f 07EF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07E7 stack[0] = 0x07f0 // @07EA stack[1] = stack[-3] // @07EB stack[2] = stack[-1] // } // Block ends with call to 0x0f6f, returns to 0x07F0 label_07F0: // Incoming return from call to 0x0F6F at 0x07EF // Inputs[2] // { // @07F4 stack[-3] // @07F5 stack[-1] // } 07F0 5B JUMPDEST 07F1 61 PUSH2 0x07fa 07F4 83 DUP4 07F5 82 DUP3 07F6 61 PUSH2 0x0fe0 07F9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07F1 stack[0] = 0x07fa // @07F4 stack[1] = stack[-3] // @07F5 stack[2] = stack[-1] // } // Block ends with call to 0x0fe0, returns to 0x07FA label_07FA: // Incoming return from call to 0x0FE0 at 0x07F9 // Incoming return from call to 0x0FE0 at 0x07F9 // Inputs[2] // { // @07FE stack[-2] // @07FF stack[-1] // } 07FA 5B JUMPDEST 07FB 61 PUSH2 0x0804 07FE 82 DUP3 07FF 82 DUP3 0800 61 PUSH2 0x117f 0803 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07FB stack[0] = 0x0804 // @07FE stack[1] = stack[-2] // @07FF stack[2] = stack[-1] // } // Block ends with call to 0x117f, returns to 0x0804 label_0804: // Incoming return from call to 0x117F at 0x0803 // Inputs[7] // { // @0805 stack[-1] // @0806 stack[-2] // @0810 stack[-3] // @083D memory[0x40:0x60] // @0840 memory[0x40:0x60] // @0845 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0849 stack[-4] // } 0804 5B JUMPDEST 0805 80 DUP1 0806 82 DUP3 0807 60 PUSH1 0x01 0809 60 PUSH1 0xa0 080B 60 PUSH1 0x02 080D 0A EXP 080E 03 SUB 080F 16 AND 0810 84 DUP5 0811 60 PUSH1 0x01 0813 60 PUSH1 0xa0 0815 60 PUSH1 0x02 0817 0A EXP 0818 03 SUB 0819 16 AND 081A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 083B 60 PUSH1 0x40 083D 51 MLOAD 083E 60 PUSH1 0x40 0840 51 MLOAD 0841 80 DUP1 0842 91 SWAP2 0843 03 SUB 0844 90 SWAP1 0845 A4 LOG4 0846 50 POP 0847 50 POP 0848 50 POP 0849 56 *JUMP // Stack delta = -4 // Outputs[1] { @0845 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0x02 ** 0xa0 - 0x01, stack[-2] & 0x02 ** 0xa0 - 0x01, stack[-1]]); } // Block ends with unconditional jump to stack[-4] label_084A: // Incoming jump from 0x033A // Incoming jump from 0x09A4 // Incoming jump from 0x0AEA // Incoming jump from 0x0B40 // Incoming jump from 0x079E // Inputs[1] { @0852 stack[-1] } 084A 5B JUMPDEST 084B 60 PUSH1 0x00 084D 61 PUSH2 0x085d 0850 60 PUSH1 0x01 0852 83 DUP4 0853 63 PUSH4 0xffffffff 0858 61 PUSH2 0x125d 085B 16 AND 085C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @084B stack[0] = 0x00 // @084D stack[1] = 0x085d // @0850 stack[2] = 0x01 // @0852 stack[3] = stack[-1] // } // Block ends with call to 0x125d & 0xffffffff, returns to 0x085D label_085D: // Incoming return from call to 0x125D at 0x0DBC // Incoming jump from 0x0B33, if !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Incoming return from call to 0x125D at 0x085C // Inputs[3] // { // @085E stack[-1] // @085E stack[-4] // @085F stack[-3] // } 085D 5B JUMPDEST 085E 92 SWAP3 085F 91 SWAP2 0860 50 POP 0861 50 POP 0862 56 *JUMP // Stack delta = -3 // Outputs[1] { @085E stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0863: // Incoming jump from 0x035B // Inputs[1] { @0867 msg.sender } 0863 5B JUMPDEST 0864 61 PUSH2 0x086c 0867 33 CALLER 0868 61 PUSH2 0x0daa 086B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0864 stack[0] = 0x086c // @0867 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x0daa 086C 5B JUMPDEST 086D 15 ISZERO 086E 15 ISZERO 086F 61 PUSH2 0x0877 0872 57 *JUMPI 0873 60 PUSH1 0x00 0875 80 DUP1 0876 FD *REVERT 0877 5B JUMPDEST 0878 61 PUSH2 0x0880 087B 81 DUP2 087C 61 PUSH2 0x1294 087F 56 *JUMP 0880 5B JUMPDEST 0881 60 PUSH1 0x40 0883 51 MLOAD 0884 60 PUSH1 0x01 0886 60 PUSH1 0xa0 0888 60 PUSH1 0x02 088A 0A EXP 088B 03 SUB 088C 82 DUP3 088D 16 AND 088E 90 SWAP1 088F 7F PUSH32 0xe2681e4603f5d1d79eab2ed79cae6225a72693d467c169be22c766a3d502ab27 08B0 90 SWAP1 08B1 60 PUSH1 0x00 08B3 90 SWAP1 08B4 A2 LOG2 08B5 50 POP 08B6 56 *JUMP label_08B7: // Incoming call from 0x037F, returns to 0x02DE // Inputs[1] { @08BA storage[0x05] } 08B7 5B JUMPDEST 08B8 60 PUSH1 0x05 08BA 54 SLOAD 08BB 60 PUSH1 0x00 08BD 90 SWAP1 08BE 61 PUSH2 0x0100 08C1 90 SWAP1 08C2 04 DIV 08C3 60 PUSH1 0xff 08C5 16 AND 08C6 15 ISZERO 08C7 15 ISZERO 08C8 61 PUSH2 0x0932 08CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08BD stack[0] = 0x00 } // Block ends with conditional jump to 0x0932, if !!(0xff & storage[0x05] / 0x0100) label_08CC: // Incoming jump from 0x08CB, if not !!(0xff & storage[0x05] / 0x0100) // Inputs[3] // { // @08CF memory[0x40:0x60] // @0928 memory[0x40:0x60] // @0931 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 08CC 60 PUSH1 0x40 08CE 80 DUP1 08CF 51 MLOAD 08D0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 08F1 81 DUP2 08F2 52 MSTORE 08F3 60 PUSH1 0x20 08F5 60 PUSH1 0x04 08F7 82 DUP3 08F8 01 ADD 08F9 52 MSTORE 08FA 60 PUSH1 0x17 08FC 60 PUSH1 0x24 08FE 82 DUP3 08FF 01 ADD 0900 52 MSTORE 0901 7F PUSH32 0x546f6b656e206973206e6f7420656e756d657261626c65000000000000000000 0922 60 PUSH1 0x44 0924 82 DUP3 0925 01 ADD 0926 52 MSTORE 0927 90 SWAP1 0928 51 MLOAD 0929 90 SWAP1 092A 81 DUP2 092B 90 SWAP1 092C 03 SUB 092D 60 PUSH1 0x64 092F 01 ADD 0930 90 SWAP1 0931 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @08F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @08F9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0900 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0926 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546f6b656e206973206e6f7420656e756d657261626c65000000000000000000 // @0931 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0932: // Incoming jump from 0x08CB, if !!(0xff & storage[0x05] / 0x0100) // Inputs[1] { @0936 stack[-3] } 0932 5B JUMPDEST 0933 61 PUSH2 0x093b 0936 83 DUP4 0937 61 PUSH2 0x0b63 093A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0933 stack[0] = 0x093b // @0936 stack[1] = stack[-3] // } // Block ends with call to 0x0b63, returns to 0x093B label_093B: // Incoming return from call to 0x0B63 at 0x093A // Inputs[2] // { // @093C stack[-3] // @093D stack[-1] // } 093B 5B JUMPDEST 093C 82 DUP3 093D 10 LT 093E 61 PUSH2 0x0946 0941 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0946, if stack[-3] < stack[-1] label_0942: // Incoming jump from 0x0941, if not stack[-3] < stack[-1] // Inputs[1] { @0945 memory[0x00:0x00] } 0942 60 PUSH1 0x00 0944 80 DUP1 0945 FD *REVERT // Stack delta = +0 // Outputs[1] { @0945 revert(memory[0x00:0x00]); } // Block terminates label_0946: // Incoming jump from 0x0941, if stack[-3] < stack[-1] // Inputs[4] // { // @094F stack[-3] // @095E memory[0x00:0x40] // @0960 storage[keccak256(memory[0x00:0x40])] // @0961 stack[-2] // } 0946 5B JUMPDEST 0947 60 PUSH1 0x01 0949 60 PUSH1 0xa0 094B 60 PUSH1 0x02 094D 0A EXP 094E 03 SUB 094F 83 DUP4 0950 16 AND 0951 60 PUSH1 0x00 0953 90 SWAP1 0954 81 DUP2 0955 52 MSTORE 0956 60 PUSH1 0x09 0958 60 PUSH1 0x20 095A 52 MSTORE 095B 60 PUSH1 0x40 095D 90 SWAP1 095E 20 SHA3 095F 80 DUP1 0960 54 SLOAD 0961 83 DUP4 0962 90 SWAP1 0963 81 DUP2 0964 10 LT 0965 61 PUSH2 0x096a 0968 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0955 memory[0x00:0x20] = stack[-3] & 0x02 ** 0xa0 - 0x01 // @095A memory[0x20:0x40] = 0x09 // @095E stack[0] = keccak256(memory[0x00:0x40]) // @0962 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x096a, if stack[-2] < storage[keccak256(memory[0x00:0x40])] label_0969: // Incoming jump from 0x0968, if not stack[-2] < storage[keccak256(memory[0x00:0x40])] 0969 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0969 assert(); } // Block terminates label_096A: // Incoming jump from 0x0968, if stack[-2] < storage[keccak256(memory[0x00:0x40])] // Inputs[7] // { // @096B stack[-1] // @096B stack[-2] // @0973 memory[0x00:0x20] // @0975 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0976 stack[-3] // @0978 stack[-6] // @0979 stack[-5] // } 096A 5B JUMPDEST 096B 90 SWAP1 096C 60 PUSH1 0x00 096E 52 MSTORE 096F 60 PUSH1 0x20 0971 60 PUSH1 0x00 0973 20 SHA3 0974 01 ADD 0975 54 SLOAD 0976 90 SWAP1 0977 50 POP 0978 92 SWAP3 0979 91 SWAP2 097A 50 POP 097B 50 POP 097C 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @096E memory[0x00:0x20] = stack[-2] // @0978 stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] label_097D: // Incoming jump from 0x03A0 // Inputs[1] { @0981 msg.sender } 097D 5B JUMPDEST 097E 61 PUSH2 0x0986 0981 33 CALLER 0982 61 PUSH2 0x0daa 0985 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @097E stack[0] = 0x0986 // @0981 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x0daa 0986 5B JUMPDEST 0987 15 ISZERO 0988 15 ISZERO 0989 61 PUSH2 0x0991 098C 57 *JUMPI 098D 60 PUSH1 0x00 098F 80 DUP1 0990 FD *REVERT 0991 5B JUMPDEST 0992 61 PUSH2 0x07b3 0995 81 DUP2 0996 61 PUSH2 0x12dc 0999 56 *JUMP label_099A: // Incoming jump from 0x03C4 // Inputs[1] { @09A0 msg.sender } 099A 5B JUMPDEST 099B 60 PUSH1 0x00 099D 61 PUSH2 0x09a5 09A0 33 CALLER 09A1 61 PUSH2 0x084a 09A4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @099B stack[0] = 0x00 // @099D stack[1] = 0x09a5 // @09A0 stack[2] = msg.sender // } // Block ends with unconditional jump to 0x084a 09A5 5B JUMPDEST 09A6 15 ISZERO 09A7 15 ISZERO 09A8 61 PUSH2 0x09b0 09AB 57 *JUMPI 09AC 60 PUSH1 0x00 09AE 80 DUP1 09AF FD *REVERT 09B0 5B JUMPDEST 09B1 61 PUSH2 0x09ba 09B4 83 DUP4 09B5 83 DUP4 09B6 61 PUSH2 0x1324 09B9 56 *JUMP 09BA 5B JUMPDEST 09BB 50 POP 09BC 60 PUSH1 0x01 09BE 92 SWAP3 09BF 91 SWAP2 09C0 50 POP 09C1 50 POP 09C2 56 *JUMP label_09C3: // Incoming call from 0x03E1, returns to 0x02A6 // Inputs[3] // { // @09C7 stack[-3] // @09C8 stack[-2] // @09C9 stack[-1] // } 09C3 5B JUMPDEST 09C4 61 PUSH2 0x09ce 09C7 83 DUP4 09C8 83 DUP4 09C9 83 DUP4 09CA 61 PUSH2 0x07bc 09CD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09C4 stack[0] = 0x09ce // @09C7 stack[1] = stack[-3] // @09C8 stack[2] = stack[-2] // @09C9 stack[3] = stack[-1] // } // Block ends with call to 0x07bc, returns to 0x09CE label_09CE: // Incoming return from call to 0x07BC at 0x09CD // Inputs[4] // { // @09D2 stack[-3] // @09D3 stack[-2] // @09D4 stack[-1] // @09D9 memory[0x40:0x60] // } 09CE 5B JUMPDEST 09CF 61 PUSH2 0x09ea 09D2 83 DUP4 09D3 83 DUP4 09D4 83 DUP4 09D5 60 PUSH1 0x20 09D7 60 PUSH1 0x40 09D9 51 MLOAD 09DA 90 SWAP1 09DB 81 DUP2 09DC 01 ADD 09DD 60 PUSH1 0x40 09DF 52 MSTORE 09E0 80 DUP1 09E1 60 PUSH1 0x00 09E3 81 DUP2 09E4 52 MSTORE 09E5 50 POP 09E6 61 PUSH2 0x13d4 09E9 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @09CF stack[0] = 0x09ea // @09D2 stack[1] = stack[-3] // @09D3 stack[2] = stack[-2] // @09D4 stack[3] = stack[-1] // @09DA stack[4] = memory[0x40:0x60] // @09DF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @09E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x13d4, returns to 0x09EA label_09EA: // Incoming return from call to 0x13D4 at 0x09E9 // Inputs[1] { @09EB stack[-1] } 09EA 5B JUMPDEST 09EB 15 ISZERO 09EC 15 ISZERO 09ED 61 PUSH2 0x09f5 09F0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09f5, if !!stack[-1] label_09F1: // Incoming jump from 0x09F0, if not !!stack[-1] // Inputs[1] { @09F4 memory[0x00:0x00] } 09F1 60 PUSH1 0x00 09F3 80 DUP1 09F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @09F4 revert(memory[0x00:0x00]); } // Block terminates label_09F5: // Incoming jump from 0x1807, if !(storage[stack[-2]] > stack[-1]) // Incoming return from call to 0x18E0 at 0x181D // Incoming jump from 0x09F0, if !!stack[-1] // Inputs[1] { @09F9 stack[-4] } 09F5 5B JUMPDEST 09F6 50 POP 09F7 50 POP 09F8 50 POP 09F9 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_09FA: // Incoming jump from 0x03F9 // Inputs[1] { @09FD storage[0x05] } 09FA 5B JUMPDEST 09FB 60 PUSH1 0x05 09FD 54 SLOAD 09FE 60 PUSH1 0xff 0A00 16 AND 0A01 15 ISZERO 0A02 15 ISZERO 0A03 61 PUSH2 0x0a0b 0A06 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a0b, if !!(0xff & storage[0x05]) label_0A07: // Incoming jump from 0x0A06, if not !!(0xff & storage[0x05]) // Inputs[1] { @0A0A memory[0x00:0x00] } 0A07 60 PUSH1 0x00 0A09 80 DUP1 0A0A FD *REVERT // Stack delta = +0 // Outputs[1] { @0A0A revert(memory[0x00:0x00]); } // Block terminates label_0A0B: // Incoming jump from 0x0A06, if !!(0xff & storage[0x05]) // Inputs[1] { @0A0F stack[-1] } 0A0B 5B JUMPDEST 0A0C 61 PUSH2 0x0a14 0A0F 81 DUP2 0A10 61 PUSH2 0x0b14 0A13 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A0C stack[0] = 0x0a14 // @0A0F stack[1] = stack[-1] // } // Block ends with call to 0x0b14, returns to 0x0A14 label_0A14: // Incoming return from call to 0x0B14 at 0x0A13 // Inputs[2] // { // @0A1D stack[-1] // @0A1E msg.sender // } 0A14 5B JUMPDEST 0A15 60 PUSH1 0x01 0A17 60 PUSH1 0xa0 0A19 60 PUSH1 0x02 0A1B 0A EXP 0A1C 03 SUB 0A1D 16 AND 0A1E 33 CALLER 0A1F 14 EQ 0A20 61 PUSH2 0x0a28 0A23 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a28, if msg.sender == 0x02 ** 0xa0 - 0x01 & stack[-1] label_0A24: // Incoming jump from 0x0A23, if not msg.sender == 0x02 ** 0xa0 - 0x01 & stack[-1] // Inputs[1] { @0A27 memory[0x00:0x00] } 0A24 60 PUSH1 0x00 0A26 80 DUP1 0A27 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A27 revert(memory[0x00:0x00]); } // Block terminates label_0A28: // Incoming jump from 0x0A23, if msg.sender == 0x02 ** 0xa0 - 0x01 & stack[-1] // Inputs[2] // { // @0A2C msg.sender // @0A2D stack[-1] // } 0A28 5B JUMPDEST 0A29 61 PUSH2 0x07b3 0A2C 33 CALLER 0A2D 82 DUP3 0A2E 61 PUSH2 0x155c 0A31 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A29 stack[0] = 0x07b3 // @0A2C stack[1] = msg.sender // @0A2D stack[2] = stack[-1] // } // Block ends with call to 0x155c, returns to 0x07B3 label_0A32: // Incoming call from 0x0411, returns to 0x02DE // Inputs[1] { @0A35 storage[0x05] } 0A32 5B JUMPDEST 0A33 60 PUSH1 0x05 0A35 54 SLOAD 0A36 60 PUSH1 0x00 0A38 90 SWAP1 0A39 61 PUSH2 0x0100 0A3C 90 SWAP1 0A3D 04 DIV 0A3E 60 PUSH1 0xff 0A40 16 AND 0A41 15 ISZERO 0A42 15 ISZERO 0A43 61 PUSH2 0x0aad 0A46 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A38 stack[0] = 0x00 } // Block ends with conditional jump to 0x0aad, if !!(0xff & storage[0x05] / 0x0100) label_0A47: // Incoming jump from 0x0A46, if not !!(0xff & storage[0x05] / 0x0100) // Inputs[3] // { // @0A4A memory[0x40:0x60] // @0AA3 memory[0x40:0x60] // @0AAC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A47 60 PUSH1 0x40 0A49 80 DUP1 0A4A 51 MLOAD 0A4B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A6C 81 DUP2 0A6D 52 MSTORE 0A6E 60 PUSH1 0x20 0A70 60 PUSH1 0x04 0A72 82 DUP3 0A73 01 ADD 0A74 52 MSTORE 0A75 60 PUSH1 0x17 0A77 60 PUSH1 0x24 0A79 82 DUP3 0A7A 01 ADD 0A7B 52 MSTORE 0A7C 7F PUSH32 0x546f6b656e206973206e6f7420656e756d657261626c65000000000000000000 0A9D 60 PUSH1 0x44 0A9F 82 DUP3 0AA0 01 ADD 0AA1 52 MSTORE 0AA2 90 SWAP1 0AA3 51 MLOAD 0AA4 90 SWAP1 0AA5 81 DUP2 0AA6 90 SWAP1 0AA7 03 SUB 0AA8 60 PUSH1 0x64 0AAA 01 ADD 0AAB 90 SWAP1 0AAC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A6D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A74 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A7B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0AA1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546f6b656e206973206e6f7420656e756d657261626c65000000000000000000 // @0AAC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0AAD: // Incoming jump from 0x0A46, if !!(0xff & storage[0x05] / 0x0100) 0AAD 5B JUMPDEST 0AAE 61 PUSH2 0x0ab5 0AB1 61 PUSH2 0x07b6 0AB4 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AAE stack[0] = 0x0ab5 } // Block ends with call to 0x07b6, returns to 0x0AB5 label_0AB5: // Incoming return from call to 0x07B6 at 0x0AB4 // Inputs[2] // { // @0AB6 stack[-3] // @0AB7 stack[-1] // } 0AB5 5B JUMPDEST 0AB6 82 DUP3 0AB7 10 LT 0AB8 61 PUSH2 0x0ac0 0ABB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ac0, if stack[-3] < stack[-1] label_0ABC: // Incoming jump from 0x0ABB, if not stack[-3] < stack[-1] // Inputs[1] { @0ABF memory[0x00:0x00] } 0ABC 60 PUSH1 0x00 0ABE 80 DUP1 0ABF FD *REVERT // Stack delta = +0 // Outputs[1] { @0ABF revert(memory[0x00:0x00]); } // Block terminates label_0AC0: // Incoming jump from 0x0ABB, if stack[-3] < stack[-1] // Inputs[2] // { // @0AC4 storage[0x06] // @0AC5 stack[-2] // } 0AC0 5B JUMPDEST 0AC1 60 PUSH1 0x06 0AC3 80 DUP1 0AC4 54 SLOAD 0AC5 83 DUP4 0AC6 90 SWAP1 0AC7 81 DUP2 0AC8 10 LT 0AC9 61 PUSH2 0x0ace 0ACC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0AC1 stack[0] = 0x06 // @0AC6 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0ace, if stack[-2] < storage[0x06] label_0ACD: // Incoming jump from 0x0ACC, if not stack[-2] < storage[0x06] 0ACD FE *ASSERT // Stack delta = +0 // Outputs[1] { @0ACD assert(); } // Block terminates label_0ACE: // Incoming jump from 0x0ACC, if stack[-2] < storage[0x06] // Inputs[7] // { // @0ACF stack[-2] // @0ACF stack[-1] // @0AD7 memory[0x00:0x20] // @0AD9 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0ADA stack[-3] // @0ADC stack[-5] // @0ADD stack[-4] // } 0ACE 5B JUMPDEST 0ACF 90 SWAP1 0AD0 60 PUSH1 0x00 0AD2 52 MSTORE 0AD3 60 PUSH1 0x20 0AD5 60 PUSH1 0x00 0AD7 20 SHA3 0AD8 01 ADD 0AD9 54 SLOAD 0ADA 90 SWAP1 0ADB 50 POP 0ADC 91 SWAP2 0ADD 90 SWAP1 0ADE 50 POP 0ADF 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0AD2 memory[0x00:0x20] = stack[-2] // @0ADC stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_0AE0: // Incoming jump from 0x047A // Inputs[1] { @0AE6 msg.sender } 0AE0 5B JUMPDEST 0AE1 60 PUSH1 0x00 0AE3 61 PUSH2 0x0aeb 0AE6 33 CALLER 0AE7 61 PUSH2 0x084a 0AEA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AE1 stack[0] = 0x00 // @0AE3 stack[1] = 0x0aeb // @0AE6 stack[2] = msg.sender // } // Block ends with unconditional jump to 0x084a 0AEB 5B JUMPDEST 0AEC 15 ISZERO 0AED 15 ISZERO 0AEE 61 PUSH2 0x0af6 0AF1 57 *JUMPI 0AF2 60 PUSH1 0x00 0AF4 80 DUP1 0AF5 FD *REVERT 0AF6 5B JUMPDEST 0AF7 61 PUSH2 0x0b00 0AFA 84 DUP5 0AFB 84 DUP5 0AFC 61 PUSH2 0x1324 0AFF 56 *JUMP 0B00 5B JUMPDEST 0B01 61 PUSH2 0x0b0a 0B04 83 DUP4 0B05 83 DUP4 0B06 61 PUSH2 0x16ad 0B09 56 *JUMP 0B0A 5B JUMPDEST 0B0B 50 POP 0B0C 60 PUSH1 0x01 0B0E 93 SWAP4 0B0F 92 SWAP3 0B10 50 POP 0B11 50 POP 0B12 50 POP 0B13 56 *JUMP label_0B14: // Incoming call from 0x0F1B, returns to 0x0F1C // Incoming call from 0x0492, returns to 0x0266 // Incoming call from 0x0A13, returns to 0x0A14 // Incoming call from 0x0703, returns to 0x0704 // Incoming call from 0x0F81, returns to 0x0F82 // Incoming call from 0x0FF7, returns to 0x0FF8 // Inputs[3] // { // @0B17 stack[-1] // @0B22 memory[0x00:0x40] // @0B23 storage[keccak256(memory[0x00:0x40])] // } 0B14 5B JUMPDEST 0B15 60 PUSH1 0x00 0B17 81 DUP2 0B18 81 DUP2 0B19 52 MSTORE 0B1A 60 PUSH1 0x08 0B1C 60 PUSH1 0x20 0B1E 52 MSTORE 0B1F 60 PUSH1 0x40 0B21 81 DUP2 0B22 20 SHA3 0B23 54 SLOAD 0B24 60 PUSH1 0x01 0B26 60 PUSH1 0xa0 0B28 60 PUSH1 0x02 0B2A 0A EXP 0B2B 03 SUB 0B2C 16 AND 0B2D 80 DUP1 0B2E 15 ISZERO 0B2F 15 ISZERO 0B30 61 PUSH2 0x085d 0B33 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0B15 stack[0] = 0x00 // @0B19 memory[0x00:0x20] = stack[-1] // @0B1E memory[0x20:0x40] = 0x08 // @0B2C stack[1] = 0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x085d, if !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_0B34: // Incoming jump from 0x0B33, if not !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0B37 memory[0x00:0x00] } 0B34 60 PUSH1 0x00 0B36 80 DUP1 0B37 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B37 revert(memory[0x00:0x00]); } // Block terminates label_0B38: // Incoming jump from 0x04B3 // Inputs[1] { @0B3C msg.sender } 0B38 5B JUMPDEST 0B39 61 PUSH2 0x0b41 0B3C 33 CALLER 0B3D 61 PUSH2 0x084a 0B40 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B39 stack[0] = 0x0b41 // @0B3C stack[1] = msg.sender // } // Block ends with unconditional jump to 0x084a 0B41 5B JUMPDEST 0B42 15 ISZERO 0B43 15 ISZERO 0B44 61 PUSH2 0x0b4c 0B47 57 *JUMPI 0B48 60 PUSH1 0x00 0B4A 80 DUP1 0B4B FD *REVERT 0B4C 5B JUMPDEST 0B4D 61 PUSH2 0x07b3 0B50 81 DUP2 0B51 61 PUSH2 0x1294 0B54 56 *JUMP label_0B55: // Incoming call from 0x04C8, returns to 0x01B0 // Inputs[2] // { // @0B58 storage[0x05] // @0B61 stack[-1] // } 0B55 5B JUMPDEST 0B56 60 PUSH1 0x05 0B58 54 SLOAD 0B59 61 PUSH2 0x0100 0B5C 90 SWAP1 0B5D 04 DIV 0B5E 60 PUSH1 0xff 0B60 16 AND 0B61 81 DUP2 0B62 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B60 stack[0] = 0xff & storage[0x05] / 0x0100 } // Block ends with unconditional jump to stack[-1] label_0B63: // Incoming call from 0x04E9, returns to 0x02DE // Incoming call from 0x093A, returns to 0x093B // Inputs[1] { @0B66 storage[0x05] } 0B63 5B JUMPDEST 0B64 60 PUSH1 0x05 0B66 54 SLOAD 0B67 60 PUSH1 0x00 0B69 90 SWAP1 0B6A 61 PUSH2 0x0100 0B6D 90 SWAP1 0B6E 04 DIV 0B6F 60 PUSH1 0xff 0B71 16 AND 0B72 15 ISZERO 0B73 15 ISZERO 0B74 61 PUSH2 0x0bde 0B77 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B69 stack[0] = 0x00 } // Block ends with conditional jump to 0x0bde, if !!(0xff & storage[0x05] / 0x0100) label_0B78: // Incoming jump from 0x0B77, if not !!(0xff & storage[0x05] / 0x0100) // Inputs[3] // { // @0B7B memory[0x40:0x60] // @0BD4 memory[0x40:0x60] // @0BDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B78 60 PUSH1 0x40 0B7A 80 DUP1 0B7B 51 MLOAD 0B7C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B9D 81 DUP2 0B9E 52 MSTORE 0B9F 60 PUSH1 0x20 0BA1 60 PUSH1 0x04 0BA3 82 DUP3 0BA4 01 ADD 0BA5 52 MSTORE 0BA6 60 PUSH1 0x17 0BA8 60 PUSH1 0x24 0BAA 82 DUP3 0BAB 01 ADD 0BAC 52 MSTORE 0BAD 7F PUSH32 0x546f6b656e206973206e6f7420656e756d657261626c65000000000000000000 0BCE 60 PUSH1 0x44 0BD0 82 DUP3 0BD1 01 ADD 0BD2 52 MSTORE 0BD3 90 SWAP1 0BD4 51 MLOAD 0BD5 90 SWAP1 0BD6 81 DUP2 0BD7 90 SWAP1 0BD8 03 SUB 0BD9 60 PUSH1 0x64 0BDB 01 ADD 0BDC 90 SWAP1 0BDD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B9E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0BA5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BAC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0BD2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546f6b656e206973206e6f7420656e756d657261626c65000000000000000000 // @0BDD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0BDE: // Incoming jump from 0x0B77, if !!(0xff & storage[0x05] / 0x0100) // Inputs[1] { @0BE7 stack[-2] } 0BDE 5B JUMPDEST 0BDF 60 PUSH1 0x01 0BE1 60 PUSH1 0xa0 0BE3 60 PUSH1 0x02 0BE5 0A EXP 0BE6 03 SUB 0BE7 82 DUP3 0BE8 16 AND 0BE9 15 ISZERO 0BEA 15 ISZERO 0BEB 61 PUSH2 0x0bf3 0BEE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf3, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) label_0BEF: // Incoming jump from 0x0BEE, if not !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @0BF2 memory[0x00:0x00] } 0BEF 60 PUSH1 0x00 0BF1 80 DUP1 0BF2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BF2 revert(memory[0x00:0x00]); } // Block terminates label_0BF3: // Incoming jump from 0x0BEE, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[4] // { // @0BFD stack[-2] // @0C0B memory[0x00:0x40] // @0C0C storage[keccak256(memory[0x00:0x40])] // @0C0D stack[-3] // } 0BF3 5B JUMPDEST 0BF4 50 POP 0BF5 60 PUSH1 0x01 0BF7 60 PUSH1 0xa0 0BF9 60 PUSH1 0x02 0BFB 0A EXP 0BFC 03 SUB 0BFD 16 AND 0BFE 60 PUSH1 0x00 0C00 90 SWAP1 0C01 81 DUP2 0C02 52 MSTORE 0C03 60 PUSH1 0x0c 0C05 60 PUSH1 0x20 0C07 52 MSTORE 0C08 60 PUSH1 0x40 0C0A 90 SWAP1 0C0B 20 SHA3 0C0C 54 SLOAD 0C0D 90 SWAP1 0C0E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0C02 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @0C07 memory[0x20:0x40] = 0x0c // @0C0D stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C0F: // Incoming call from 0x04FE, returns to 0x01D9 // Inputs[2] // { // @0C13 storage[0x04] // @0C17 memory[0x40:0x60] // } 0C0F 5B JUMPDEST 0C10 60 PUSH1 0x04 0C12 80 DUP1 0C13 54 SLOAD 0C14 60 PUSH1 0x40 0C16 80 DUP1 0C17 51 MLOAD 0C18 60 PUSH1 0x20 0C1A 60 PUSH1 0x1f 0C1C 60 PUSH1 0x02 0C1E 60 PUSH1 0x00 0C20 19 NOT 0C21 61 PUSH2 0x0100 0C24 60 PUSH1 0x01 0C26 88 DUP9 0C27 16 AND 0C28 15 ISZERO 0C29 02 MUL 0C2A 01 ADD 0C2B 90 SWAP1 0C2C 95 SWAP6 0C2D 16 AND 0C2E 94 SWAP5 0C2F 90 SWAP1 0C30 94 SWAP5 0C31 04 DIV 0C32 93 SWAP4 0C33 84 DUP5 0C34 01 ADD 0C35 81 DUP2 0C36 90 SWAP1 0C37 04 DIV 0C38 81 DUP2 0C39 02 MUL 0C3A 82 DUP3 0C3B 01 ADD 0C3C 81 DUP2 0C3D 01 ADD 0C3E 90 SWAP1 0C3F 92 SWAP3 0C40 52 MSTORE 0C41 82 DUP3 0C42 81 DUP2 0C43 52 MSTORE 0C44 60 PUSH1 0x60 0C46 93 SWAP4 0C47 90 SWAP1 0C48 92 SWAP3 0C49 90 SWAP1 0C4A 91 SWAP2 0C4B 83 DUP4 0C4C 01 ADD 0C4D 82 DUP3 0C4E 82 DUP3 0C4F 80 DUP1 0C50 15 ISZERO 0C51 61 PUSH2 0x06bc 0C54 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0C40 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0C43 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0C46 stack[0] = 0x60 // @0C48 stack[1] = memory[0x40:0x60] // @0C49 stack[3] = (storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0C4A stack[2] = 0x04 // @0C4C stack[4] = memory[0x40:0x60] + 0x20 // @0C4D stack[5] = 0x04 // @0C4E stack[6] = (storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x06bc, if !((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0C55: // Incoming jump from 0x0C54, if not !((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0C55 stack[-1] } 0C55 80 DUP1 0C56 60 PUSH1 0x1f 0C58 10 LT 0C59 61 PUSH2 0x0691 0C5C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0691, if 0x1f < stack[-1] label_0C5D: // Incoming jump from 0x0C5C, if not 0x1f < stack[-1] // Inputs[4] // { // @0C61 stack[-2] // @0C62 storage[stack[-2]] // @0C65 stack[-3] // @0C67 stack[-1] // } 0C5D 61 PUSH2 0x0100 0C60 80 DUP1 0C61 83 DUP4 0C62 54 SLOAD 0C63 04 DIV 0C64 02 MUL 0C65 83 DUP4 0C66 52 MSTORE 0C67 91 SWAP2 0C68 60 PUSH1 0x20 0C6A 01 ADD 0C6B 91 SWAP2 0C6C 61 PUSH2 0x06bc 0C6F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0C66 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0C6B stack[-1] = stack[-1] // @0C6B stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06bc label_0C70: // Incoming call from 0x0513, returns to 0x01B0 // Inputs[2] // { // @0C73 storage[0x05] // @0C77 stack[-1] // } 0C70 5B JUMPDEST 0C71 60 PUSH1 0x05 0C73 54 SLOAD 0C74 60 PUSH1 0xff 0C76 16 AND 0C77 81 DUP2 0C78 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C76 stack[0] = 0xff & storage[0x05] } // Block ends with unconditional jump to stack[-1] label_0C79: // Incoming call from 0x0539, returns to 0x02A6 // Inputs[2] // { // @0C82 stack[-2] // @0C84 msg.sender // } 0C79 5B JUMPDEST 0C7A 60 PUSH1 0x01 0C7C 60 PUSH1 0xa0 0C7E 60 PUSH1 0x02 0C80 0A EXP 0C81 03 SUB 0C82 82 DUP3 0C83 16 AND 0C84 33 CALLER 0C85 14 EQ 0C86 15 ISZERO 0C87 61 PUSH2 0x0c8f 0C8A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c8f, if !(msg.sender == stack[-2] & 0x02 ** 0xa0 - 0x01) label_0C8B: // Incoming jump from 0x0C8A, if not !(msg.sender == stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @0C8E memory[0x00:0x00] } 0C8B 60 PUSH1 0x00 0C8D 80 DUP1 0C8E FD *REVERT // Stack delta = +0 // Outputs[1] { @0C8E revert(memory[0x00:0x00]); } // Block terminates label_0C8F: // Incoming jump from 0x0C8A, if !(msg.sender == stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[10] // { // @0C90 msg.sender // @0CA1 memory[0x00:0x40] // @0CAA stack[-2] // @0CB5 memory[0x00:0x40] // @0CB7 storage[keccak256(memory[0x00:0x40])] // @0CBC stack[-1] // @0CC6 memory[0x40:0x60] // @0CCB memory[0x40:0x60] // @0CF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @0CFC stack[-3] // } 0C8F 5B JUMPDEST 0C90 33 CALLER 0C91 60 PUSH1 0x00 0C93 81 DUP2 0C94 81 DUP2 0C95 52 MSTORE 0C96 60 PUSH1 0x0d 0C98 60 PUSH1 0x20 0C9A 90 SWAP1 0C9B 81 DUP2 0C9C 52 MSTORE 0C9D 60 PUSH1 0x40 0C9F 80 DUP1 0CA0 83 DUP4 0CA1 20 SHA3 0CA2 60 PUSH1 0x01 0CA4 60 PUSH1 0xa0 0CA6 60 PUSH1 0x02 0CA8 0A EXP 0CA9 03 SUB 0CAA 87 DUP8 0CAB 16 AND 0CAC 80 DUP1 0CAD 85 DUP6 0CAE 52 MSTORE 0CAF 90 SWAP1 0CB0 83 DUP4 0CB1 52 MSTORE 0CB2 92 SWAP3 0CB3 81 DUP2 0CB4 90 SWAP1 0CB5 20 SHA3 0CB6 80 DUP1 0CB7 54 SLOAD 0CB8 60 PUSH1 0xff 0CBA 19 NOT 0CBB 16 AND 0CBC 86 DUP7 0CBD 15 ISZERO 0CBE 15 ISZERO 0CBF 90 SWAP1 0CC0 81 DUP2 0CC1 17 OR 0CC2 90 SWAP1 0CC3 91 SWAP2 0CC4 55 SSTORE 0CC5 81 DUP2 0CC6 51 MLOAD 0CC7 90 SWAP1 0CC8 81 DUP2 0CC9 52 MSTORE 0CCA 90 SWAP1 0CCB 51 MLOAD 0CCC 92 SWAP3 0CCD 93 SWAP4 0CCE 92 SWAP3 0CCF 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0CF0 92 SWAP3 0CF1 91 SWAP2 0CF2 81 DUP2 0CF3 90 SWAP1 0CF4 03 SUB 0CF5 90 SWAP1 0CF6 91 SWAP2 0CF7 01 ADD 0CF8 90 SWAP1 0CF9 A3 LOG3 0CFA 50 POP 0CFB 50 POP 0CFC 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0C95 memory[0x00:0x20] = msg.sender // @0C9C memory[0x20:0x40] = 0x0d // @0CAE memory[0x00:0x20] = stack[-2] & 0x02 ** 0xa0 - 0x01 // @0CB1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0CC4 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0CC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0CF9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & 0x02 ** 0xa0 - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_0CFD: // Incoming jump from 0x055A // Inputs[1] { @0D01 msg.sender } 0CFD 5B JUMPDEST 0CFE 61 PUSH2 0x0d06 0D01 33 CALLER 0D02 61 PUSH2 0x0daa 0D05 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CFE stack[0] = 0x0d06 // @0D01 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x0daa 0D06 5B JUMPDEST 0D07 15 ISZERO 0D08 15 ISZERO 0D09 61 PUSH2 0x0d11 0D0C 57 *JUMPI 0D0D 60 PUSH1 0x00 0D0F 80 DUP1 0D10 FD *REVERT 0D11 5B JUMPDEST 0D12 61 PUSH2 0x0d1a 0D15 81 DUP2 0D16 61 PUSH2 0x0ec8 0D19 56 *JUMP 0D1A 5B JUMPDEST 0D1B 60 PUSH1 0x40 0D1D 51 MLOAD 0D1E 60 PUSH1 0x01 0D20 60 PUSH1 0xa0 0D22 60 PUSH1 0x02 0D24 0A EXP 0D25 03 SUB 0D26 82 DUP3 0D27 16 AND 0D28 90 SWAP1 0D29 7F PUSH32 0xdd03a410a9b379c5c31df9bbec14f14840e84bec6958bba98d9c5df9fe4d713d 0D4A 90 SWAP1 0D4B 60 PUSH1 0x00 0D4D 90 SWAP1 0D4E A2 LOG2 0D4F 50 POP 0D50 56 *JUMP label_0D51: // Incoming call from 0x0586, returns to 0x02A6 // Inputs[3] // { // @0D55 stack[-5] // @0D56 stack[-4] // @0D57 stack[-3] // } 0D51 5B JUMPDEST 0D52 61 PUSH2 0x0d5c 0D55 85 DUP6 0D56 85 DUP6 0D57 85 DUP6 0D58 61 PUSH2 0x07bc 0D5B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D52 stack[0] = 0x0d5c // @0D55 stack[1] = stack[-5] // @0D56 stack[2] = stack[-4] // @0D57 stack[3] = stack[-3] // } // Block ends with call to 0x07bc, returns to 0x0D5C label_0D5C: // Incoming return from call to 0x07BC at 0x0D5B // Inputs[7] // { // @0D60 stack[-5] // @0D61 stack[-4] // @0D62 stack[-3] // @0D63 stack[-2] // @0D64 stack[-1] // @0D75 memory[0x40:0x60] // @0D8C msg.data[stack[-2]:stack[-2] + stack[-1]] // } 0D5C 5B JUMPDEST 0D5D 61 PUSH2 0x0d98 0D60 85 DUP6 0D61 85 DUP6 0D62 85 DUP6 0D63 85 DUP6 0D64 85 DUP6 0D65 80 DUP1 0D66 80 DUP1 0D67 60 PUSH1 0x1f 0D69 01 ADD 0D6A 60 PUSH1 0x20 0D6C 80 DUP1 0D6D 91 SWAP2 0D6E 04 DIV 0D6F 02 MUL 0D70 60 PUSH1 0x20 0D72 01 ADD 0D73 60 PUSH1 0x40 0D75 51 MLOAD 0D76 90 SWAP1 0D77 81 DUP2 0D78 01 ADD 0D79 60 PUSH1 0x40 0D7B 52 MSTORE 0D7C 80 DUP1 0D7D 93 SWAP4 0D7E 92 SWAP3 0D7F 91 SWAP2 0D80 90 SWAP1 0D81 81 DUP2 0D82 81 DUP2 0D83 52 MSTORE 0D84 60 PUSH1 0x20 0D86 01 ADD 0D87 83 DUP4 0D88 83 DUP4 0D89 80 DUP1 0D8A 82 DUP3 0D8B 84 DUP5 0D8C 37 CALLDATACOPY 0D8D 50 POP 0D8E 61 PUSH2 0x13d4 0D91 94 SWAP5 0D92 50 POP 0D93 50 POP 0D94 50 POP 0D95 50 POP 0D96 50 POP 0D97 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @0D5D stack[0] = 0x0d98 // @0D60 stack[1] = stack[-5] // @0D61 stack[2] = stack[-4] // @0D62 stack[3] = stack[-3] // @0D7B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0D7D stack[4] = memory[0x40:0x60] // @0D83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D8C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // } // Block ends with call to 0x13d4, returns to 0x0D98 label_0D98: // Incoming return from call to 0x13D4 at 0x0D97 // Inputs[1] { @0D99 stack[-1] } 0D98 5B JUMPDEST 0D99 15 ISZERO 0D9A 15 ISZERO 0D9B 61 PUSH2 0x0da3 0D9E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0da3, if !!stack[-1] label_0D9F: // Incoming jump from 0x0D9E, if not !!stack[-1] // Inputs[1] { @0DA2 memory[0x00:0x00] } 0D9F 60 PUSH1 0x00 0DA1 80 DUP1 0DA2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DA2 revert(memory[0x00:0x00]); } // Block terminates label_0DA3: // Incoming jump from 0x1087, if !(0xff & storage[0x05] / 0x0100) // Incoming jump from 0x0D9E, if !!stack[-1] // Inputs[1] { @0DA9 stack[-6] } 0DA3 5B JUMPDEST 0DA4 50 POP 0DA5 50 POP 0DA6 50 POP 0DA7 50 POP 0DA8 50 POP 0DA9 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0DAA: // Incoming jump from 0x0D05 // Incoming jump from 0x0985 // Incoming jump from 0x086B // Incoming jump from 0x05A7 // Inputs[1] { @0DB2 stack[-1] } 0DAA 5B JUMPDEST 0DAB 60 PUSH1 0x00 0DAD 61 PUSH2 0x085d 0DB0 60 PUSH1 0x02 0DB2 83 DUP4 0DB3 63 PUSH4 0xffffffff 0DB8 61 PUSH2 0x125d 0DBB 16 AND 0DBC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DAB stack[0] = 0x00 // @0DAD stack[1] = 0x085d // @0DB0 stack[2] = 0x02 // @0DB2 stack[3] = stack[-1] // } // Block ends with call to 0x125d & 0xffffffff, returns to 0x085D label_0DBD: // Incoming call from 0x05BF, returns to 0x01D9 // Inputs[1] { @0DC3 stack[-1] } 0DBD 5B JUMPDEST 0DBE 60 PUSH1 0x60 0DC0 61 PUSH2 0x0dc8 0DC3 82 DUP3 0DC4 61 PUSH2 0x0eab 0DC7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DBE stack[0] = 0x60 // @0DC0 stack[1] = 0x0dc8 // @0DC3 stack[2] = stack[-1] // } // Block ends with call to 0x0eab, returns to 0x0DC8 label_0DC8: // Incoming return from call to 0x0EAB at 0x0DC7 // Inputs[1] { @0DC9 stack[-1] } 0DC8 5B JUMPDEST 0DC9 15 ISZERO 0DCA 15 ISZERO 0DCB 61 PUSH2 0x0dd3 0DCE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dd3, if !!stack[-1] label_0DCF: // Incoming jump from 0x0DCE, if not !!stack[-1] // Inputs[1] { @0DD2 memory[0x00:0x00] } 0DCF 60 PUSH1 0x00 0DD1 80 DUP1 0DD2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DD2 revert(memory[0x00:0x00]); } // Block terminates label_0DD3: // Incoming jump from 0x0DCE, if !!stack[-1] // Inputs[4] // { // @0DD6 stack[-2] // @0DE5 memory[0x00:0x40] // @0DE7 storage[keccak256(memory[0x00:0x40])] // @0DE9 memory[0x40:0x60] // } 0DD3 5B JUMPDEST 0DD4 60 PUSH1 0x00 0DD6 82 DUP3 0DD7 81 DUP2 0DD8 52 MSTORE 0DD9 60 PUSH1 0x0e 0DDB 60 PUSH1 0x20 0DDD 90 SWAP1 0DDE 81 DUP2 0DDF 52 MSTORE 0DE0 60 PUSH1 0x40 0DE2 91 SWAP2 0DE3 82 DUP3 0DE4 90 SWAP1 0DE5 20 SHA3 0DE6 80 DUP1 0DE7 54 SLOAD 0DE8 83 DUP4 0DE9 51 MLOAD 0DEA 60 PUSH1 0x1f 0DEC 60 PUSH1 0x02 0DEE 60 PUSH1 0x00 0DF0 19 NOT 0DF1 61 PUSH2 0x0100 0DF4 60 PUSH1 0x01 0DF6 86 DUP7 0DF7 16 AND 0DF8 15 ISZERO 0DF9 02 MUL 0DFA 01 ADD 0DFB 90 SWAP1 0DFC 93 SWAP4 0DFD 16 AND 0DFE 92 SWAP3 0DFF 90 SWAP1 0E00 92 SWAP3 0E01 04 DIV 0E02 91 SWAP2 0E03 82 DUP3 0E04 01 ADD 0E05 84 DUP5 0E06 90 SWAP1 0E07 04 DIV 0E08 84 DUP5 0E09 02 MUL 0E0A 81 DUP2 0E0B 01 ADD 0E0C 84 DUP5 0E0D 01 ADD 0E0E 90 SWAP1 0E0F 94 SWAP5 0E10 52 MSTORE 0E11 80 DUP1 0E12 84 DUP5 0E13 52 MSTORE 0E14 90 SWAP1 0E15 91 SWAP2 0E16 83 DUP4 0E17 01 ADD 0E18 82 DUP3 0E19 82 DUP3 0E1A 80 DUP1 0E1B 15 ISZERO 0E1C 61 PUSH2 0x0e66 0E1F 57 *JUMPI // Stack delta = +6 // Outputs[10] // { // @0DD8 memory[0x00:0x20] = stack[-2] // @0DDF memory[0x20:0x40] = 0x0e // @0E0F stack[0] = memory[0x40:0x60] // @0E10 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0E13 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0E14 stack[2] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0E15 stack[1] = keccak256(memory[0x00:0x40]) // @0E17 stack[3] = memory[0x40:0x60] + 0x20 // @0E18 stack[4] = keccak256(memory[0x00:0x40]) // @0E19 stack[5] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0e66, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0E20: // Incoming jump from 0x0E1F, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0E20 stack[-1] } 0E20 80 DUP1 0E21 60 PUSH1 0x1f 0E23 10 LT 0E24 61 PUSH2 0x0e3b 0E27 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e3b, if 0x1f < stack[-1] label_0E28: // Incoming jump from 0x0E27, if not 0x1f < stack[-1] // Inputs[4] // { // @0E2C stack[-2] // @0E2D storage[stack[-2]] // @0E30 stack[-3] // @0E32 stack[-1] // } 0E28 61 PUSH2 0x0100 0E2B 80 DUP1 0E2C 83 DUP4 0E2D 54 SLOAD 0E2E 04 DIV 0E2F 02 MUL 0E30 83 DUP4 0E31 52 MSTORE 0E32 91 SWAP2 0E33 60 PUSH1 0x20 0E35 01 ADD 0E36 91 SWAP2 0E37 61 PUSH2 0x0e66 0E3A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E31 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0E36 stack[-1] = stack[-1] // @0E36 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0e66 label_0E3B: // Incoming jump from 0x0E27, if 0x1f < stack[-1] // Inputs[5] // { // @0E3C stack[-3] // @0E3D stack[-1] // @0E3F stack[-2] // @0E47 memory[0x00:0x20] // @0E4B storage[keccak256(memory[0x00:0x20])] // } 0E3B 5B JUMPDEST 0E3C 82 DUP3 0E3D 01 ADD 0E3E 91 SWAP2 0E3F 90 SWAP1 0E40 60 PUSH1 0x00 0E42 52 MSTORE 0E43 60 PUSH1 0x20 0E45 60 PUSH1 0x00 0E47 20 SHA3 0E48 90 SWAP1 0E49 5B JUMPDEST 0E4A 81 DUP2 0E4B 54 SLOAD 0E4C 81 DUP2 0E4D 52 MSTORE 0E4E 90 SWAP1 0E4F 60 PUSH1 0x01 0E51 01 ADD 0E52 90 SWAP1 0E53 60 PUSH1 0x20 0E55 01 ADD 0E56 80 DUP1 0E57 83 DUP4 0E58 11 GT 0E59 61 PUSH2 0x0e49 0E5C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0E3E stack[-3] = stack[-3] + stack[-1] // @0E42 memory[0x00:0x20] = stack[-2] // @0E4D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0E52 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0E55 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0e49, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0E5D: // Incoming jump from 0x0E5C, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0E5C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0E5D stack[-3] // @0E5E stack[-1] // } 0E5D 82 DUP3 0E5E 90 SWAP1 0E5F 03 SUB 0E60 60 PUSH1 0x1f 0E62 16 AND 0E63 82 DUP3 0E64 01 ADD 0E65 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0E65 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0E65 stack[-1] = stack[-3] // } // Block continues label_0E66: // Incoming jump from 0x0E3A // Incoming jump from 0x0E1F, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0E65 // Inputs[4] // { // @0E6C stack[-7] // @0E6C stack[-6] // @0E6E stack[-9] // @0E6F stack[-8] // } 0E66 5B JUMPDEST 0E67 50 POP 0E68 50 POP 0E69 50 POP 0E6A 50 POP 0E6B 50 POP 0E6C 90 SWAP1 0E6D 50 POP 0E6E 91 SWAP2 0E6F 90 SWAP1 0E70 50 POP 0E71 56 *JUMP // Stack delta = -8 // Outputs[1] { @0E6E stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_0E72: // Incoming call from 0x05D4, returns to 0x02A6 // Inputs[1] { @0E76 msg.sender } 0E72 5B JUMPDEST 0E73 61 PUSH2 0x0e7b 0E76 33 CALLER 0E77 61 PUSH2 0x16e0 0E7A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E73 stack[0] = 0x0e7b // @0E76 stack[1] = msg.sender // } // Block ends with call to 0x16e0, returns to 0x0E7B label_0E7B: // Incoming return from call to 0x16E0 at 0x0E7A // Inputs[1] { @0E7C stack[-1] } 0E7B 5B JUMPDEST 0E7C 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0E7D: // Incoming call from 0x0F66, returns to 0x0F67 // Incoming call from 0x05FB, returns to 0x01B0 // Incoming call from 0x0721, returns to 0x0722 // Inputs[6] // { // @0E86 stack[-2] // @0E99 memory[0x00:0x40] // @0E9A stack[-1] // @0EA4 memory[0x00:0x40] // @0EA5 storage[keccak256(memory[0x00:0x40])] // @0EA9 stack[-3] // } 0E7D 5B JUMPDEST 0E7E 60 PUSH1 0x01 0E80 60 PUSH1 0xa0 0E82 60 PUSH1 0x02 0E84 0A EXP 0E85 03 SUB 0E86 91 SWAP2 0E87 82 DUP3 0E88 16 AND 0E89 60 PUSH1 0x00 0E8B 90 SWAP1 0E8C 81 DUP2 0E8D 52 MSTORE 0E8E 60 PUSH1 0x0d 0E90 60 PUSH1 0x20 0E92 90 SWAP1 0E93 81 DUP2 0E94 52 MSTORE 0E95 60 PUSH1 0x40 0E97 80 DUP1 0E98 83 DUP4 0E99 20 SHA3 0E9A 93 SWAP4 0E9B 90 SWAP1 0E9C 94 SWAP5 0E9D 16 AND 0E9E 82 DUP3 0E9F 52 MSTORE 0EA0 91 SWAP2 0EA1 90 SWAP1 0EA2 91 SWAP2 0EA3 52 MSTORE 0EA4 20 SHA3 0EA5 54 SLOAD 0EA6 60 PUSH1 0xff 0EA8 16 AND 0EA9 90 SWAP1 0EAA 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0E8D memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @0E94 memory[0x20:0x40] = 0x0d // @0E9F memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @0EA3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0EA9 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0EAB: // Incoming call from 0x0DC7, returns to 0x0DC8 // Incoming call from 0x06D1, returns to 0x06D2 // Inputs[4] // { // @0EAE stack[-1] // @0EB9 memory[0x00:0x40] // @0EBA storage[keccak256(memory[0x00:0x40])] // @0EC6 stack[-2] // } 0EAB 5B JUMPDEST 0EAC 60 PUSH1 0x00 0EAE 90 SWAP1 0EAF 81 DUP2 0EB0 52 MSTORE 0EB1 60 PUSH1 0x08 0EB3 60 PUSH1 0x20 0EB5 52 MSTORE 0EB6 60 PUSH1 0x40 0EB8 90 SWAP1 0EB9 20 SHA3 0EBA 54 SLOAD 0EBB 60 PUSH1 0x01 0EBD 60 PUSH1 0xa0 0EBF 60 PUSH1 0x02 0EC1 0A EXP 0EC2 03 SUB 0EC3 16 AND 0EC4 15 ISZERO 0EC5 15 ISZERO 0EC6 90 SWAP1 0EC7 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0EB0 memory[0x00:0x20] = stack[-1] // @0EB5 memory[0x20:0x40] = 0x08 // @0EC6 stack[-2] = !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] 0EC8 5B JUMPDEST 0EC9 61 PUSH2 0x0ed9 0ECC 60 PUSH1 0x01 0ECE 82 DUP3 0ECF 63 PUSH4 0xffffffff 0ED4 61 PUSH2 0x1728 0ED7 16 AND 0ED8 56 *JUMP 0ED9 5B JUMPDEST 0EDA 60 PUSH1 0x40 0EDC 51 MLOAD 0EDD 60 PUSH1 0x01 0EDF 60 PUSH1 0xa0 0EE1 60 PUSH1 0x02 0EE3 0A EXP 0EE4 03 SUB 0EE5 82 DUP3 0EE6 16 AND 0EE7 90 SWAP1 0EE8 7F PUSH32 0xa3b62bc36326052d97ea62d63c3d60308ed4c3ea8ac079dd8499f1e9c4f80c0f 0F09 90 SWAP1 0F0A 60 PUSH1 0x00 0F0C 90 SWAP1 0F0D A2 LOG2 0F0E 50 POP 0F0F 56 *JUMP label_0F10: // Incoming call from 0x07C5, returns to 0x07C6 // Inputs[1] { @0F17 stack[-1] } 0F10 5B JUMPDEST 0F11 60 PUSH1 0x00 0F13 80 DUP1 0F14 61 PUSH2 0x0f1c 0F17 83 DUP4 0F18 61 PUSH2 0x0b14 0F1B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F11 stack[0] = 0x00 // @0F13 stack[1] = 0x00 // @0F14 stack[2] = 0x0f1c // @0F17 stack[3] = stack[-1] // } // Block ends with call to 0x0b14, returns to 0x0F1C label_0F1C: // Incoming return from call to 0x0B14 at 0x0F1B // Inputs[3] // { // @0F1D stack[-1] // @0F1D stack[-2] // @0F29 stack[-5] // } 0F1C 5B JUMPDEST 0F1D 90 SWAP1 0F1E 50 POP 0F1F 80 DUP1 0F20 60 PUSH1 0x01 0F22 60 PUSH1 0xa0 0F24 60 PUSH1 0x02 0F26 0A EXP 0F27 03 SUB 0F28 16 AND 0F29 84 DUP5 0F2A 60 PUSH1 0x01 0F2C 60 PUSH1 0xa0 0F2E 60 PUSH1 0x02 0F30 0A EXP 0F31 03 SUB 0F32 16 AND 0F33 14 EQ 0F34 80 DUP1 0F35 61 PUSH2 0x0f57 0F38 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0F1D stack[-2] = stack[-1] // @0F33 stack[-1] = 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x0f57, if 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] label_0F39: // Incoming jump from 0x0F38, if not 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] // Inputs[2] // { // @0F3A stack[-5] // @0F47 stack[-4] // } 0F39 50 POP 0F3A 83 DUP4 0F3B 60 PUSH1 0x01 0F3D 60 PUSH1 0xa0 0F3F 60 PUSH1 0x02 0F41 0A EXP 0F42 03 SUB 0F43 16 AND 0F44 61 PUSH2 0x0f4c 0F47 84 DUP5 0F48 61 PUSH2 0x06c7 0F4B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F43 stack[-1] = 0x02 ** 0xa0 - 0x01 & stack[-5] // @0F44 stack[0] = 0x0f4c // @0F47 stack[1] = stack[-4] // } // Block ends with call to 0x06c7, returns to 0x0F4C label_0F4C: // Incoming return from call to 0x06C7 at 0x0F4B // Inputs[2] // { // @0F55 stack[-1] // @0F56 stack[-2] // } 0F4C 5B JUMPDEST 0F4D 60 PUSH1 0x01 0F4F 60 PUSH1 0xa0 0F51 60 PUSH1 0x02 0F53 0A EXP 0F54 03 SUB 0F55 16 AND 0F56 14 EQ // Stack delta = -1 // Outputs[1] { @0F56 stack[-2] = 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] } // Block continues label_0F57: // Incoming jump from 0x0F38, if 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] // Incoming jump from 0x0F56 // Inputs[1] { @0F58 stack[-1] } 0F57 5B JUMPDEST 0F58 80 DUP1 0F59 61 PUSH2 0x0f67 0F5C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f67, if stack[-1] label_0F5D: // Incoming jump from 0x0F5C, if not stack[-1] // Inputs[2] // { // @0F61 stack[-2] // @0F62 stack[-5] // } 0F5D 50 POP 0F5E 61 PUSH2 0x0f67 0F61 81 DUP2 0F62 85 DUP6 0F63 61 PUSH2 0x0e7d 0F66 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F5E stack[-1] = 0x0f67 // @0F61 stack[0] = stack[-2] // @0F62 stack[1] = stack[-5] // } // Block ends with call to 0x0e7d, returns to 0x0F67 label_0F67: // Incoming jump from 0x0F5C, if stack[-1] // Incoming return from call to 0x0E7D at 0x0F66 // Inputs[3] // { // @0F68 stack[-6] // @0F68 stack[-1] // @0F69 stack[-5] // } 0F67 5B JUMPDEST 0F68 94 SWAP5 0F69 93 SWAP4 0F6A 50 POP 0F6B 50 POP 0F6C 50 POP 0F6D 50 POP 0F6E 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F68 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0F6F: // Incoming call from 0x156A, returns to 0x156B // Incoming call from 0x07EF, returns to 0x07F0 // Inputs[2] // { // @0F70 stack[-2] // @0F7D stack[-1] // } 0F6F 5B JUMPDEST 0F70 81 DUP2 0F71 60 PUSH1 0x01 0F73 60 PUSH1 0xa0 0F75 60 PUSH1 0x02 0F77 0A EXP 0F78 03 SUB 0F79 16 AND 0F7A 61 PUSH2 0x0f82 0F7D 82 DUP3 0F7E 61 PUSH2 0x0b14 0F81 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F79 stack[0] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @0F7A stack[1] = 0x0f82 // @0F7D stack[2] = stack[-1] // } // Block ends with call to 0x0b14, returns to 0x0F82 label_0F82: // Incoming return from call to 0x0B14 at 0x0F81 // Inputs[2] // { // @0F8B stack[-1] // @0F8C stack[-2] // } 0F82 5B JUMPDEST 0F83 60 PUSH1 0x01 0F85 60 PUSH1 0xa0 0F87 60 PUSH1 0x02 0F89 0A EXP 0F8A 03 SUB 0F8B 16 AND 0F8C 14 EQ 0F8D 61 PUSH2 0x0f95 0F90 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0f95, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] label_0F91: // Incoming jump from 0x0F90, if not 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0F94 memory[0x00:0x00] } 0F91 60 PUSH1 0x00 0F93 80 DUP1 0F94 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F94 revert(memory[0x00:0x00]); } // Block terminates label_0F95: // Incoming jump from 0x0F90, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @0F98 stack[-1] // @0FA3 memory[0x00:0x40] // @0FA4 storage[keccak256(memory[0x00:0x40])] // } 0F95 5B JUMPDEST 0F96 60 PUSH1 0x00 0F98 81 DUP2 0F99 81 DUP2 0F9A 52 MSTORE 0F9B 60 PUSH1 0x0b 0F9D 60 PUSH1 0x20 0F9F 52 MSTORE 0FA0 60 PUSH1 0x40 0FA2 90 SWAP1 0FA3 20 SHA3 0FA4 54 SLOAD 0FA5 60 PUSH1 0x01 0FA7 60 PUSH1 0xa0 0FA9 60 PUSH1 0x02 0FAB 0A EXP 0FAC 03 SUB 0FAD 16 AND 0FAE 15 ISZERO 0FAF 61 PUSH2 0x0fdc 0FB2 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0F9A memory[0x00:0x20] = stack[-1] // @0F9F memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x0fdc, if !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_0FB3: // Incoming jump from 0x0FB2, if not !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @0FB5 stack[-1] // @0FC0 memory[0x00:0x40] // @0FC2 storage[keccak256(memory[0x00:0x40])] // @0FDF stack[-3] // } 0FB3 60 PUSH1 0x00 0FB5 81 DUP2 0FB6 81 DUP2 0FB7 52 MSTORE 0FB8 60 PUSH1 0x0b 0FBA 60 PUSH1 0x20 0FBC 52 MSTORE 0FBD 60 PUSH1 0x40 0FBF 90 SWAP1 0FC0 20 SHA3 0FC1 80 DUP1 0FC2 54 SLOAD 0FC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FD8 19 NOT 0FD9 16 AND 0FDA 90 SWAP1 0FDB 55 SSTORE 0FDC 5B JUMPDEST 0FDD 50 POP 0FDE 50 POP 0FDF 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0FB7 memory[0x00:0x20] = stack[-1] // @0FBC memory[0x20:0x40] = 0x0b // @0FDB storage[keccak256(memory[0x00:0x40])] = ~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0FE0: // Incoming call from 0x1574, returns to 0x1575 // Incoming call from 0x07F9, returns to 0x07FA // Inputs[2] // { // @0FE6 stack[-2] // @0FF3 stack[-1] // } 0FE0 5B JUMPDEST 0FE1 60 PUSH1 0x00 0FE3 80 DUP1 0FE4 60 PUSH1 0x00 0FE6 84 DUP5 0FE7 60 PUSH1 0x01 0FE9 60 PUSH1 0xa0 0FEB 60 PUSH1 0x02 0FED 0A EXP 0FEE 03 SUB 0FEF 16 AND 0FF0 61 PUSH2 0x0ff8 0FF3 85 DUP6 0FF4 61 PUSH2 0x0b14 0FF7 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0FE1 stack[0] = 0x00 // @0FE3 stack[1] = 0x00 // @0FE4 stack[2] = 0x00 // @0FEF stack[3] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @0FF0 stack[4] = 0x0ff8 // @0FF3 stack[5] = stack[-1] // } // Block ends with call to 0x0b14, returns to 0x0FF8 label_0FF8: // Incoming return from call to 0x0B14 at 0x0FF7 // Inputs[2] // { // @1001 stack[-1] // @1002 stack[-2] // } 0FF8 5B JUMPDEST 0FF9 60 PUSH1 0x01 0FFB 60 PUSH1 0xa0 0FFD 60 PUSH1 0x02 0FFF 0A EXP 1000 03 SUB 1001 16 AND 1002 14 EQ 1003 61 PUSH2 0x100b 1006 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x100b, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] label_1007: // Incoming jump from 0x1006, if not 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @100A memory[0x00:0x00] } 1007 60 PUSH1 0x00 1009 80 DUP1 100A FD *REVERT // Stack delta = +0 // Outputs[1] { @100A revert(memory[0x00:0x00]); } // Block terminates label_100B: // Incoming jump from 0x1006, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @1014 stack[-5] // @1023 memory[0x00:0x40] // @1024 storage[keccak256(memory[0x00:0x40])] // } 100B 5B JUMPDEST 100C 60 PUSH1 0x01 100E 60 PUSH1 0xa0 1010 60 PUSH1 0x02 1012 0A EXP 1013 03 SUB 1014 85 DUP6 1015 16 AND 1016 60 PUSH1 0x00 1018 90 SWAP1 1019 81 DUP2 101A 52 MSTORE 101B 60 PUSH1 0x0c 101D 60 PUSH1 0x20 101F 52 MSTORE 1020 60 PUSH1 0x40 1022 90 SWAP1 1023 20 SHA3 1024 54 SLOAD 1025 61 PUSH2 0x1035 1028 90 SWAP1 1029 60 PUSH1 0x01 102B 63 PUSH4 0xffffffff 1030 61 PUSH2 0x1774 1033 16 AND 1034 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @101A memory[0x00:0x20] = stack[-5] & 0x02 ** 0xa0 - 0x01 // @101F memory[0x20:0x40] = 0x0c // @1028 stack[0] = 0x1035 // @1028 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1029 stack[2] = 0x01 // } // Block ends with call to 0x1774 & 0xffffffff, returns to 0x1035 label_1035: // Incoming return from call to 0x1774 at 0x1034 // Inputs[7] // { // @103E stack[-6] // @1050 memory[0x00:0x40] // @1051 stack[-1] // @1055 stack[-5] // @105C memory[0x00:0x40] // @105E storage[keccak256(memory[0x00:0x40])] // @107A storage[0x05] // } 1035 5B JUMPDEST 1036 60 PUSH1 0x01 1038 60 PUSH1 0xa0 103A 60 PUSH1 0x02 103C 0A EXP 103D 03 SUB 103E 86 DUP7 103F 16 AND 1040 60 PUSH1 0x00 1042 90 SWAP1 1043 81 DUP2 1044 52 MSTORE 1045 60 PUSH1 0x0c 1047 60 PUSH1 0x20 1049 90 SWAP1 104A 81 DUP2 104B 52 MSTORE 104C 60 PUSH1 0x40 104E 80 DUP1 104F 83 DUP4 1050 20 SHA3 1051 93 SWAP4 1052 90 SWAP1 1053 93 SWAP4 1054 55 SSTORE 1055 86 DUP7 1056 82 DUP3 1057 52 MSTORE 1058 60 PUSH1 0x08 105A 90 SWAP1 105B 52 MSTORE 105C 20 SHA3 105D 80 DUP1 105E 54 SLOAD 105F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1074 19 NOT 1075 16 AND 1076 90 SWAP1 1077 55 SSTORE 1078 60 PUSH1 0x05 107A 54 SLOAD 107B 61 PUSH2 0x0100 107E 90 SWAP1 107F 04 DIV 1080 60 PUSH1 0xff 1082 16 AND 1083 15 ISZERO 1084 61 PUSH2 0x0da3 1087 57 *JUMPI // Stack delta = -1 // Outputs[6] // { // @1044 memory[0x00:0x20] = stack[-6] & 0x02 ** 0xa0 - 0x01 // @104B memory[0x20:0x40] = 0x0c // @1054 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1057 memory[0x00:0x20] = stack[-5] // @105B memory[0x20:0x40] = 0x08 // @1077 storage[keccak256(memory[0x00:0x40])] = ~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0da3, if !(0xff & storage[0x05] / 0x0100) label_1088: // Incoming jump from 0x1087, if not !(0xff & storage[0x05] / 0x0100) // Inputs[7] // { // @108A stack[-4] // @1098 memory[0x00:0x40] // @1099 storage[keccak256(memory[0x00:0x40])] // @10A2 stack[-5] // @10AD memory[0x00:0x40] // @10AE storage[keccak256(memory[0x00:0x40])] // @10B0 stack[-3] // } 1088 60 PUSH1 0x00 108A 84 DUP5 108B 81 DUP2 108C 52 MSTORE 108D 60 PUSH1 0x0a 108F 60 PUSH1 0x20 1091 90 SWAP1 1092 81 DUP2 1093 52 MSTORE 1094 60 PUSH1 0x40 1096 80 DUP1 1097 83 DUP4 1098 20 SHA3 1099 54 SLOAD 109A 60 PUSH1 0x01 109C 60 PUSH1 0xa0 109E 60 PUSH1 0x02 10A0 0A EXP 10A1 03 SUB 10A2 89 DUP10 10A3 16 AND 10A4 84 DUP5 10A5 52 MSTORE 10A6 60 PUSH1 0x09 10A8 90 SWAP1 10A9 92 SWAP3 10AA 52 MSTORE 10AB 90 SWAP1 10AC 91 SWAP2 10AD 20 SHA3 10AE 54 SLOAD 10AF 90 SWAP1 10B0 93 SWAP4 10B1 50 POP 10B2 61 PUSH2 0x10c2 10B5 90 SWAP1 10B6 60 PUSH1 0x01 10B8 63 PUSH4 0xffffffff 10BD 61 PUSH2 0x1774 10C0 16 AND 10C1 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @108C memory[0x00:0x20] = stack[-4] // @1093 memory[0x20:0x40] = 0x0a // @10A5 memory[0x00:0x20] = stack[-5] & 0x02 ** 0xa0 - 0x01 // @10AA memory[0x20:0x40] = 0x09 // @10B0 stack[-3] = storage[keccak256(memory[0x00:0x40])] // @10B5 stack[1] = storage[keccak256(memory[0x00:0x40])] // @10B5 stack[0] = 0x10c2 // @10B6 stack[2] = 0x01 // } // Block ends with call to 0x1774 & 0xffffffff, returns to 0x10C2 label_10C2: // Incoming return from call to 0x1774 at 0x10C1 // Inputs[5] // { // @10CB stack[-6] // @10DA memory[0x00:0x40] // @10DC storage[keccak256(memory[0x00:0x40])] // @10DD stack[-1] // @10DE stack[-3] // } 10C2 5B JUMPDEST 10C3 60 PUSH1 0x01 10C5 60 PUSH1 0xa0 10C7 60 PUSH1 0x02 10C9 0A EXP 10CA 03 SUB 10CB 86 DUP7 10CC 16 AND 10CD 60 PUSH1 0x00 10CF 90 SWAP1 10D0 81 DUP2 10D1 52 MSTORE 10D2 60 PUSH1 0x09 10D4 60 PUSH1 0x20 10D6 52 MSTORE 10D7 60 PUSH1 0x40 10D9 90 SWAP1 10DA 20 SHA3 10DB 80 DUP1 10DC 54 SLOAD 10DD 91 SWAP2 10DE 93 SWAP4 10DF 50 POP 10E0 90 SWAP1 10E1 83 DUP4 10E2 90 SWAP1 10E3 81 DUP2 10E4 10 LT 10E5 61 PUSH2 0x10ea 10E8 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @10D1 memory[0x00:0x20] = stack[-6] & 0x02 ** 0xa0 - 0x01 // @10D6 memory[0x20:0x40] = 0x09 // @10DE stack[-3] = stack[-1] // @10E0 stack[-1] = keccak256(memory[0x00:0x40]) // @10E2 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x10ea, if stack[-1] < storage[keccak256(memory[0x00:0x40])] label_10E9: // Incoming jump from 0x10E8, if not stack[-1] < storage[keccak256(memory[0x00:0x40])] 10E9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @10E9 assert(); } // Block terminates label_10EA: // Incoming jump from 0x10E8, if stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[9] // { // @10EB stack[-1] // @10EB stack[-2] // @10F3 memory[0x00:0x20] // @10F5 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @10F6 stack[-3] // @10FD stack[-7] // @111D memory[0x00:0x40] // @111E stack[-5] // @1120 storage[keccak256(memory[0x00:0x40])] // } 10EA 5B JUMPDEST 10EB 90 SWAP1 10EC 60 PUSH1 0x00 10EE 52 MSTORE 10EF 60 PUSH1 0x20 10F1 60 PUSH1 0x00 10F3 20 SHA3 10F4 01 ADD 10F5 54 SLOAD 10F6 90 SWAP1 10F7 50 POP 10F8 80 DUP1 10F9 60 PUSH1 0x09 10FB 60 PUSH1 0x00 10FD 87 DUP8 10FE 60 PUSH1 0x01 1100 60 PUSH1 0xa0 1102 60 PUSH1 0x02 1104 0A EXP 1105 03 SUB 1106 16 AND 1107 60 PUSH1 0x01 1109 60 PUSH1 0xa0 110B 60 PUSH1 0x02 110D 0A EXP 110E 03 SUB 110F 16 AND 1110 81 DUP2 1111 52 MSTORE 1112 60 PUSH1 0x20 1114 01 ADD 1115 90 SWAP1 1116 81 DUP2 1117 52 MSTORE 1118 60 PUSH1 0x20 111A 01 ADD 111B 60 PUSH1 0x00 111D 20 SHA3 111E 84 DUP5 111F 81 DUP2 1120 54 SLOAD 1121 81 DUP2 1122 10 LT 1123 15 ISZERO 1124 15 ISZERO 1125 61 PUSH2 0x112a 1128 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @10EE memory[0x00:0x20] = stack[-2] // @10F6 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @10F8 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1111 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & 0x02 ** 0xa0 - 0x01 & stack[-7] // @1117 memory[0x20:0x40] = 0x09 // @111D stack[-1] = keccak256(memory[0x00:0x40]) // @111E stack[0] = stack[-5] // } // Block ends with conditional jump to 0x112a, if !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) label_1129: // Incoming jump from 0x1128, if not !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) 1129 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1129 assert(); } // Block terminates label_112A: // Incoming jump from 0x1128, if !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) // Inputs[7] // { // @112D stack[-2] // @1134 memory[0x00:0x20] // @1136 stack[-1] // @1138 stack[-3] // @1144 stack[-8] // @1150 memory[0x00:0x40] // @1152 storage[keccak256(memory[0x00:0x40])] // } 112A 5B JUMPDEST 112B 60 PUSH1 0x00 112D 91 SWAP2 112E 82 DUP3 112F 52 MSTORE 1130 60 PUSH1 0x20 1132 80 DUP1 1133 83 DUP4 1134 20 SHA3 1135 90 SWAP1 1136 91 SWAP2 1137 01 ADD 1138 92 SWAP3 1139 90 SWAP1 113A 92 SWAP3 113B 55 SSTORE 113C 60 PUSH1 0x01 113E 60 PUSH1 0xa0 1140 60 PUSH1 0x02 1142 0A EXP 1143 03 SUB 1144 87 DUP8 1145 16 AND 1146 81 DUP2 1147 52 MSTORE 1148 60 PUSH1 0x09 114A 90 SWAP1 114B 91 SWAP2 114C 52 MSTORE 114D 60 PUSH1 0x40 114F 90 SWAP1 1150 20 SHA3 1151 80 DUP1 1152 54 SLOAD 1153 90 SWAP1 1154 61 PUSH2 0x1161 1157 90 SWAP1 1158 60 PUSH1 0x00 115A 19 NOT 115B 83 DUP4 115C 01 ADD 115D 61 PUSH2 0x17fa 1160 56 *JUMP // Stack delta = +1 // Outputs[8] // { // @112F memory[0x00:0x20] = stack[-2] // @113B storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @1147 memory[0x00:0x20] = stack[-8] & 0x02 ** 0xa0 - 0x01 // @114C memory[0x20:0x40] = 0x09 // @1153 stack[-3] = storage[keccak256(memory[0x00:0x40])] // @1157 stack[-2] = 0x1161 // @1157 stack[-1] = keccak256(memory[0x00:0x40]) // @115C stack[0] = storage[keccak256(memory[0x00:0x40])] + ~0x00 // } // Block ends with call to 0x17fa, returns to 0x1161 label_1161: // Incoming return from call to 0x17FA at 0x1160 // Inputs[7] // { // @1165 stack[-5] // @1171 memory[0x00:0x40] // @1175 stack[-2] // @1178 stack[-3] // @117A memory[0x00:0x40] // @117B stack[-4] // @117E stack[-7] // } 1161 5B JUMPDEST 1162 50 POP 1163 60 PUSH1 0x00 1165 93 SWAP4 1166 84 DUP5 1167 52 MSTORE 1168 60 PUSH1 0x0a 116A 60 PUSH1 0x20 116C 52 MSTORE 116D 60 PUSH1 0x40 116F 80 DUP1 1170 85 DUP6 1171 20 SHA3 1172 85 DUP6 1173 90 SWAP1 1174 55 SSTORE 1175 90 SWAP1 1176 84 DUP5 1177 52 MSTORE 1178 90 SWAP1 1179 92 SWAP3 117A 20 SHA3 117B 55 SSTORE 117C 50 POP 117D 50 POP 117E 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @1167 memory[0x00:0x20] = stack[-5] // @116C memory[0x20:0x40] = 0x0a // @1174 storage[keccak256(memory[0x00:0x40])] = 0x00 // @1177 memory[0x00:0x20] = stack[-2] // @117B storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_117F: // Incoming call from 0x0803, returns to 0x0804 // Inputs[3] // { // @1182 stack[-1] // @118D memory[0x00:0x40] // @118E storage[keccak256(memory[0x00:0x40])] // } 117F 5B JUMPDEST 1180 60 PUSH1 0x00 1182 81 DUP2 1183 81 DUP2 1184 52 MSTORE 1185 60 PUSH1 0x08 1187 60 PUSH1 0x20 1189 52 MSTORE 118A 60 PUSH1 0x40 118C 90 SWAP1 118D 20 SHA3 118E 54 SLOAD 118F 60 PUSH1 0x01 1191 60 PUSH1 0xa0 1193 60 PUSH1 0x02 1195 0A EXP 1196 03 SUB 1197 16 AND 1198 15 ISZERO 1199 61 PUSH2 0x11a1 119C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1184 memory[0x00:0x20] = stack[-1] // @1189 memory[0x20:0x40] = 0x08 // } // Block ends with conditional jump to 0x11a1, if !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_119D: // Incoming jump from 0x119C, if not !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @11A0 memory[0x00:0x00] } 119D 60 PUSH1 0x00 119F 80 DUP1 11A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @11A0 revert(memory[0x00:0x00]); } // Block terminates label_11A1: // Incoming jump from 0x119C, if !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[6] // { // @11A4 stack[-1] // @11B2 memory[0x00:0x40] // @11B4 storage[keccak256(memory[0x00:0x40])] // @11D4 stack[-2] // @11E4 memory[0x00:0x40] // @11E5 storage[keccak256(memory[0x00:0x40])] // } 11A1 5B JUMPDEST 11A2 60 PUSH1 0x00 11A4 81 DUP2 11A5 81 DUP2 11A6 52 MSTORE 11A7 60 PUSH1 0x08 11A9 60 PUSH1 0x20 11AB 90 SWAP1 11AC 81 DUP2 11AD 52 MSTORE 11AE 60 PUSH1 0x40 11B0 80 DUP1 11B1 83 DUP4 11B2 20 SHA3 11B3 80 DUP1 11B4 54 SLOAD 11B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11CA 19 NOT 11CB 16 AND 11CC 60 PUSH1 0x01 11CE 60 PUSH1 0xa0 11D0 60 PUSH1 0x02 11D2 0A EXP 11D3 03 SUB 11D4 87 DUP8 11D5 16 AND 11D6 90 SWAP1 11D7 81 DUP2 11D8 17 OR 11D9 90 SWAP1 11DA 91 SWAP2 11DB 55 SSTORE 11DC 83 DUP4 11DD 52 MSTORE 11DE 60 PUSH1 0x0c 11E0 90 SWAP1 11E1 91 SWAP2 11E2 52 MSTORE 11E3 90 SWAP1 11E4 20 SHA3 11E5 54 SLOAD 11E6 61 PUSH2 0x11f0 11E9 90 SWAP1 11EA 60 PUSH1 0x01 11EC 61 PUSH2 0x178b 11EF 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @11A6 memory[0x00:0x20] = stack[-1] // @11AD memory[0x20:0x40] = 0x08 // @11DB storage[keccak256(memory[0x00:0x40])] = (stack[-2] & 0x02 ** 0xa0 - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @11DD memory[0x00:0x20] = stack[-2] & 0x02 ** 0xa0 - 0x01 // @11E2 memory[0x20:0x40] = 0x0c // @11E9 stack[0] = 0x11f0 // @11E9 stack[1] = storage[keccak256(memory[0x00:0x40])] // @11EA stack[2] = 0x01 // } // Block ends with call to 0x178b, returns to 0x11F0 label_11F0: // Incoming return from call to 0x178B at 0x11EF // Inputs[4] // { // @11F9 stack[-3] // @1208 memory[0x00:0x40] // @1209 stack[-1] // @120C storage[0x05] // } 11F0 5B JUMPDEST 11F1 60 PUSH1 0x01 11F3 60 PUSH1 0xa0 11F5 60 PUSH1 0x02 11F7 0A EXP 11F8 03 SUB 11F9 83 DUP4 11FA 16 AND 11FB 60 PUSH1 0x00 11FD 90 SWAP1 11FE 81 DUP2 11FF 52 MSTORE 1200 60 PUSH1 0x0c 1202 60 PUSH1 0x20 1204 52 MSTORE 1205 60 PUSH1 0x40 1207 90 SWAP1 1208 20 SHA3 1209 55 SSTORE 120A 60 PUSH1 0x05 120C 54 SLOAD 120D 61 PUSH2 0x0100 1210 90 SWAP1 1211 04 DIV 1212 60 PUSH1 0xff 1214 16 AND 1215 15 ISZERO 1216 61 PUSH2 0x0fdc 1219 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @11FF memory[0x00:0x20] = stack[-3] & 0x02 ** 0xa0 - 0x01 // @1204 memory[0x20:0x40] = 0x0c // @1209 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with conditional jump to 0x0fdc, if !(0xff & storage[0x05] / 0x0100) label_121A: // Incoming jump from 0x1219, if not !(0xff & storage[0x05] / 0x0100) // Inputs[8] // { // @1222 stack[-2] // @1223 stack[-1] // @1236 memory[0x00:0x40] // @1238 storage[keccak256(memory[0x00:0x40])] // @1244 memory[0x00:0x20] // @1249 storage[keccak256(memory[0x00:0x40])] // @1253 memory[0x00:0x40] // @125C stack[-3] // } 121A 60 PUSH1 0x01 121C 60 PUSH1 0xa0 121E 60 PUSH1 0x02 1220 0A EXP 1221 03 SUB 1222 91 SWAP2 1223 90 SWAP1 1224 91 SWAP2 1225 16 AND 1226 60 PUSH1 0x00 1228 90 SWAP1 1229 81 DUP2 122A 52 MSTORE 122B 60 PUSH1 0x09 122D 60 PUSH1 0x20 122F 90 SWAP1 1230 81 DUP2 1231 52 MSTORE 1232 60 PUSH1 0x40 1234 80 DUP1 1235 83 DUP4 1236 20 SHA3 1237 80 DUP1 1238 54 SLOAD 1239 60 PUSH1 0x01 123B 81 DUP2 123C 01 ADD 123D 82 DUP3 123E 55 SSTORE 123F 81 DUP2 1240 85 DUP6 1241 52 MSTORE 1242 83 DUP4 1243 85 DUP6 1244 20 SHA3 1245 01 ADD 1246 85 DUP6 1247 90 SWAP1 1248 55 SSTORE 1249 54 SLOAD 124A 93 SWAP4 124B 83 DUP4 124C 52 MSTORE 124D 60 PUSH1 0x0a 124F 90 SWAP1 1250 91 SWAP2 1251 52 MSTORE 1252 90 SWAP1 1253 20 SHA3 1254 60 PUSH1 0x00 1256 19 NOT 1257 90 SWAP1 1258 91 SWAP2 1259 01 ADD 125A 90 SWAP1 125B 55 SSTORE 125C 56 *JUMP // Stack delta = -3 // Outputs[8] // { // @122A memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @1231 memory[0x20:0x40] = 0x09 // @123E storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @1241 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @1248 storage[keccak256(memory[0x00:0x20]) + storage[keccak256(memory[0x00:0x40])]] = stack[-1] // @124C memory[0x00:0x20] = stack[-1] // @1251 memory[0x20:0x40] = 0x0a // @125B storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + ~0x00 // } // Block ends with unconditional jump to stack[-3] label_125D: // Incoming call from 0x0DBC, returns to 0x085D // Incoming call from 0x1746, returns to 0x1747 // Incoming call from 0x085C, returns to 0x085D // Inputs[1] { @1268 stack[-1] } 125D 5B JUMPDEST 125E 60 PUSH1 0x00 1260 60 PUSH1 0x01 1262 60 PUSH1 0xa0 1264 60 PUSH1 0x02 1266 0A EXP 1267 03 SUB 1268 82 DUP3 1269 16 AND 126A 15 ISZERO 126B 15 ISZERO 126C 61 PUSH2 0x1274 126F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @125E stack[0] = 0x00 } // Block ends with conditional jump to 0x1274, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) label_1270: // Incoming jump from 0x126F, if not !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @1273 memory[0x00:0x00] } 1270 60 PUSH1 0x00 1272 80 DUP1 1273 FD *REVERT // Stack delta = +0 // Outputs[1] { @1273 revert(memory[0x00:0x00]); } // Block terminates label_1274: // Incoming jump from 0x126F, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[5] // { // @127E stack[-2] // @1286 stack[-3] // @128D memory[0x00:0x40] // @128E storage[keccak256(memory[0x00:0x40])] // @1292 stack[-4] // } 1274 5B JUMPDEST 1275 50 POP 1276 60 PUSH1 0x01 1278 60 PUSH1 0xa0 127A 60 PUSH1 0x02 127C 0A EXP 127D 03 SUB 127E 16 AND 127F 60 PUSH1 0x00 1281 90 SWAP1 1282 81 DUP2 1283 52 MSTORE 1284 60 PUSH1 0x20 1286 91 SWAP2 1287 90 SWAP1 1288 91 SWAP2 1289 52 MSTORE 128A 60 PUSH1 0x40 128C 90 SWAP1 128D 20 SHA3 128E 54 SLOAD 128F 60 PUSH1 0xff 1291 16 AND 1292 90 SWAP1 1293 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1283 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @1289 memory[0x20:0x40] = stack[-3] // @1292 stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] 1294 5B JUMPDEST 1295 61 PUSH2 0x12a5 1298 60 PUSH1 0x01 129A 82 DUP3 129B 63 PUSH4 0xffffffff 12A0 61 PUSH2 0x17a4 12A3 16 AND 12A4 56 *JUMP 12A5 5B JUMPDEST 12A6 60 PUSH1 0x40 12A8 51 MLOAD 12A9 60 PUSH1 0x01 12AB 60 PUSH1 0xa0 12AD 60 PUSH1 0x02 12AF 0A EXP 12B0 03 SUB 12B1 82 DUP3 12B2 16 AND 12B3 90 SWAP1 12B4 7F PUSH32 0x44d6d25963f097ad14f29f06854a01f575648a1ef82f30e562ccd3889717e339 12D5 90 SWAP1 12D6 60 PUSH1 0x00 12D8 90 SWAP1 12D9 A2 LOG2 12DA 50 POP 12DB 56 *JUMP 12DC 5B JUMPDEST 12DD 61 PUSH2 0x12ed 12E0 60 PUSH1 0x02 12E2 82 DUP3 12E3 63 PUSH4 0xffffffff 12E8 61 PUSH2 0x17a4 12EB 16 AND 12EC 56 *JUMP 12ED 5B JUMPDEST 12EE 60 PUSH1 0x40 12F0 51 MLOAD 12F1 60 PUSH1 0x01 12F3 60 PUSH1 0xa0 12F5 60 PUSH1 0x02 12F7 0A EXP 12F8 03 SUB 12F9 82 DUP3 12FA 16 AND 12FB 90 SWAP1 12FC 7F PUSH32 0xe5471443dacef43f16d651e9c89638c8b115a4f9c6cbe09df93e544cb8f8fe3d 131D 90 SWAP1 131E 60 PUSH1 0x00 1320 90 SWAP1 1321 A2 LOG2 1322 50 POP 1323 56 *JUMP 1324 5B JUMPDEST 1325 60 PUSH1 0x01 1327 60 PUSH1 0xa0 1329 60 PUSH1 0x02 132B 0A EXP 132C 03 SUB 132D 82 DUP3 132E 16 AND 132F 15 ISZERO 1330 15 ISZERO 1331 61 PUSH2 0x1339 1334 57 *JUMPI 1335 60 PUSH1 0x00 1337 80 DUP1 1338 FD *REVERT 1339 5B JUMPDEST 133A 61 PUSH2 0x1343 133D 82 DUP3 133E 82 DUP3 133F 61 PUSH2 0x117f 1342 56 *JUMP 1343 5B JUMPDEST 1344 60 PUSH1 0x05 1346 54 SLOAD 1347 61 PUSH2 0x0100 134A 90 SWAP1 134B 04 DIV 134C 60 PUSH1 0xff 134E 16 AND 134F 15 ISZERO 1350 61 PUSH2 0x1398 1353 57 *JUMPI 1354 60 PUSH1 0x06 1356 80 DUP1 1357 54 SLOAD 1358 60 PUSH1 0x00 135A 83 DUP4 135B 81 DUP2 135C 52 MSTORE 135D 60 PUSH1 0x07 135F 60 PUSH1 0x20 1361 52 MSTORE 1362 60 PUSH1 0x40 1364 81 DUP2 1365 20 SHA3 1366 82 DUP3 1367 90 SWAP1 1368 55 SSTORE 1369 60 PUSH1 0x01 136B 82 DUP3 136C 01 ADD 136D 83 DUP4 136E 55 SSTORE 136F 91 SWAP2 1370 90 SWAP1 1371 91 SWAP2 1372 52 MSTORE 1373 7F PUSH32 0xf652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f 1394 01 ADD 1395 81 DUP2 1396 90 SWAP1 1397 55 SSTORE 1398 5B JUMPDEST 1399 60 PUSH1 0x40 139B 51 MLOAD 139C 81 DUP2 139D 90 SWAP1 139E 60 PUSH1 0x01 13A0 60 PUSH1 0xa0 13A2 60 PUSH1 0x02 13A4 0A EXP 13A5 03 SUB 13A6 84 DUP5 13A7 16 AND 13A8 90 SWAP1 13A9 60 PUSH1 0x00 13AB 90 SWAP1 13AC 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 13CD 90 SWAP1 13CE 82 DUP3 13CF 90 SWAP1 13D0 A4 LOG4 13D1 50 POP 13D2 50 POP 13D3 56 *JUMP label_13D4: // Incoming call from 0x0D97, returns to 0x0D98 // Incoming call from 0x09E9, returns to 0x09EA // Inputs[1] { @13DD stack[-3] } 13D4 5B JUMPDEST 13D5 60 PUSH1 0x00 13D7 80 DUP1 13D8 60 PUSH1 0x00 13DA 61 PUSH2 0x13eb 13DD 86 DUP7 13DE 60 PUSH1 0x01 13E0 60 PUSH1 0xa0 13E2 60 PUSH1 0x02 13E4 0A EXP 13E5 03 SUB 13E6 16 AND 13E7 61 PUSH2 0x17f2 13EA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @13D5 stack[0] = 0x00 // @13D7 stack[1] = 0x00 // @13D8 stack[2] = 0x00 // @13DA stack[3] = 0x13eb // @13E6 stack[4] = 0x02 ** 0xa0 - 0x01 & stack[-3] // } // Block ends with call to 0x17f2, returns to 0x13EB label_13EB: // Incoming return from call to 0x17F2 at 0x13EA // Inputs[1] { @13EC stack[-1] } 13EB 5B JUMPDEST 13EC 15 ISZERO 13ED 15 ISZERO 13EE 61 PUSH2 0x13fa 13F1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13fa, if !!stack[-1] label_13F2: // Incoming jump from 0x13F1, if not !!stack[-1] // Inputs[1] { @13F4 stack[-3] } 13F2 60 PUSH1 0x01 13F4 92 SWAP3 13F5 50 POP 13F6 61 PUSH2 0x1552 13F9 56 *JUMP // Stack delta = +0 // Outputs[1] { @13F4 stack[-3] = 0x01 } // Block ends with unconditional jump to 0x1552 label_13FA: // Incoming jump from 0x13F1, if !!stack[-1] // Inputs[9] // { // @13FD memory[0x40:0x60] // @1421 msg.sender // @1431 stack[-7] // @143D stack[-5] // @1449 stack[-4] // @144A memory[stack[-4]:stack[-4] + 0x20] // @1451 memory[stack[-4]:stack[-4] + 0x20] // @1452 stack[-6] // @1453 stack[-2] // } 13FA 5B JUMPDEST 13FB 60 PUSH1 0x40 13FD 51 MLOAD 13FE 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 141F 81 DUP2 1420 52 MSTORE 1421 33 CALLER 1422 60 PUSH1 0x04 1424 82 DUP3 1425 01 ADD 1426 81 DUP2 1427 81 DUP2 1428 52 MSTORE 1429 60 PUSH1 0x01 142B 60 PUSH1 0xa0 142D 60 PUSH1 0x02 142F 0A EXP 1430 03 SUB 1431 8A DUP11 1432 81 DUP2 1433 16 AND 1434 60 PUSH1 0x24 1436 85 DUP6 1437 01 ADD 1438 52 MSTORE 1439 60 PUSH1 0x44 143B 84 DUP5 143C 01 ADD 143D 89 DUP10 143E 90 SWAP1 143F 52 MSTORE 1440 60 PUSH1 0x80 1442 60 PUSH1 0x64 1444 85 DUP6 1445 01 ADD 1446 90 SWAP1 1447 81 DUP2 1448 52 MSTORE 1449 88 DUP9 144A 51 MLOAD 144B 60 PUSH1 0x84 144D 86 DUP7 144E 01 ADD 144F 52 MSTORE 1450 88 DUP9 1451 51 MLOAD 1452 8B DUP12 1453 97 SWAP8 1454 50 POP 1455 91 SWAP2 1456 87 DUP8 1457 16 AND 1458 94 SWAP5 1459 63 PUSH4 0x150b7a02 145E 94 SWAP5 145F 93 SWAP4 1460 8D DUP14 1461 93 SWAP4 1462 8C DUP13 1463 93 SWAP4 1464 8C DUP13 1465 93 SWAP4 1466 90 SWAP1 1467 91 SWAP2 1468 60 PUSH1 0xa4 146A 90 SWAP1 146B 91 SWAP2 146C 01 ADD 146D 90 SWAP1 146E 60 PUSH1 0x20 1470 85 DUP6 1471 01 ADD 1472 90 SWAP1 1473 80 DUP1 1474 83 DUP4 1475 83 DUP4 1476 60 PUSH1 0x00 1478 5B JUMPDEST 1479 83 DUP4 147A 81 DUP2 147B 10 LT 147C 15 ISZERO 147D 61 PUSH2 0x1490 1480 57 *JUMPI // Stack delta = +15 // Outputs[22] // { // @1420 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x150b7a0200000000000000000000000000000000000000000000000000000000 // @1428 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @1438 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 ** 0xa0 - 0x01 & stack[-7] // @143F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-5] // @1448 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x80 // @144F memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @1453 stack[-2] = stack[-6] // @1458 stack[0] = stack[-6] & 0x02 ** 0xa0 - 0x01 // @145E stack[1] = 0x150b7a02 // @145F stack[6] = memory[0x40:0x60] + 0x04 // @145F stack[2] = msg.sender // @1461 stack[3] = stack[-7] // @1463 stack[4] = stack[-5] // @1465 stack[5] = stack[-4] // @1467 stack[7] = memory[0x40:0x60] + 0x64 // @146D stack[8] = memory[0x40:0x60] + 0xa4 // @1472 stack[10] = memory[stack[-4]:stack[-4] + 0x20] // @1472 stack[9] = stack[-4] + 0x20 // @1473 stack[11] = memory[stack[-4]:stack[-4] + 0x20] // @1474 stack[12] = memory[0x40:0x60] + 0xa4 // @1475 stack[13] = stack[-4] + 0x20 // @1476 stack[14] = 0x00 // } // Block ends with conditional jump to 0x1490, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_1481: // Incoming jump from 0x1480, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1480, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @1481 stack[-2] // @1482 stack[-1] // @1484 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1485 stack[-3] // } 1481 81 DUP2 1482 81 DUP2 1483 01 ADD 1484 51 MLOAD 1485 83 DUP4 1486 82 DUP3 1487 01 ADD 1488 52 MSTORE 1489 60 PUSH1 0x20 148B 01 ADD 148C 61 PUSH2 0x1478 148F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1488 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @148B stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1478 label_1490: // Incoming jump from 0x1480, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1480, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @1495 stack[-6] // @1495 stack[-5] // @1497 stack[-7] // } 1490 5B JUMPDEST 1491 50 POP 1492 50 POP 1493 50 POP 1494 50 POP 1495 90 SWAP1 1496 50 POP 1497 90 SWAP1 1498 81 DUP2 1499 01 ADD 149A 90 SWAP1 149B 60 PUSH1 0x1f 149D 16 AND 149E 80 DUP1 149F 15 ISZERO 14A0 61 PUSH2 0x14bd 14A3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @149A stack[-7] = stack[-5] + stack[-7] // @149D stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x14bd, if !(0x1f & stack[-5]) label_14A4: // Incoming jump from 0x14A3, if not !(0x1f & stack[-5]) // Inputs[7] // { // @14A4 stack[-1] // @14A5 stack[-2] // @14A8 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @14BF stack[-8] // @14CA memory[0x40:0x60] // @14D1 stack[-10] // @14D3 address(stack[-10]).code.length // } 14A4 80 DUP1 14A5 82 DUP3 14A6 03 SUB 14A7 80 DUP1 14A8 51 MLOAD 14A9 60 PUSH1 0x01 14AB 83 DUP4 14AC 60 PUSH1 0x20 14AE 03 SUB 14AF 61 PUSH2 0x0100 14B2 0A EXP 14B3 03 SUB 14B4 19 NOT 14B5 16 AND 14B6 81 DUP2 14B7 52 MSTORE 14B8 60 PUSH1 0x20 14BA 01 ADD 14BB 91 SWAP2 14BC 50 POP 14BD 5B JUMPDEST 14BE 50 POP 14BF 95 SWAP6 14C0 50 POP 14C1 50 POP 14C2 50 POP 14C3 50 POP 14C4 50 POP 14C5 50 POP 14C6 60 PUSH1 0x20 14C8 60 PUSH1 0x40 14CA 51 MLOAD 14CB 80 DUP1 14CC 83 DUP4 14CD 03 SUB 14CE 81 DUP2 14CF 60 PUSH1 0x00 14D1 87 DUP8 14D2 80 DUP1 14D3 3B EXTCODESIZE 14D4 15 ISZERO 14D5 80 DUP1 14D6 15 ISZERO 14D7 61 PUSH2 0x14df 14DA 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @14B7 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] // @14BF stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @14C6 stack[-7] = 0x20 // @14CA stack[-6] = memory[0x40:0x60] // @14CD stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @14CE stack[-4] = memory[0x40:0x60] // @14CF stack[-3] = 0x00 // @14D1 stack[-2] = stack[-10] // @14D4 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x14df, if !!address(stack[-10]).code.length label_14DB: // Incoming jump from 0x14DA, if not !!address(stack[-10]).code.length // Incoming jump from 0x14DA, if not !!address(stack[-10]).code.length // Inputs[1] { @14DE memory[0x00:0x00] } 14DB 60 PUSH1 0x00 14DD 80 DUP1 14DE FD *REVERT // Stack delta = +0 // Outputs[1] { @14DE revert(memory[0x00:0x00]); } // Block terminates label_14DF: // Incoming jump from 0x14DA, if !!address(stack[-10]).code.length // Incoming jump from 0x14DA, if !!address(stack[-10]).code.length // Inputs[9] // { // @14E1 msg.gas // @14E2 stack[-7] // @14E2 stack[-2] // @14E2 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @14E2 stack[-4] // @14E2 stack[-6] // @14E2 stack[-5] // @14E2 stack[-3] // @14E2 memory[stack[-4]:stack[-4] + stack[-5]] // } 14DF 5B JUMPDEST 14E0 50 POP 14E1 5A GAS 14E2 F1 CALL 14E3 15 ISZERO 14E4 80 DUP1 14E5 15 ISZERO 14E6 61 PUSH2 0x14f3 14E9 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @14E2 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @14E3 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x14f3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_14EA: // Incoming jump from 0x14E9, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @14EA returndata.length // @14EE returndata[0x00:0x00 + returndata.length] // @14EF returndata.length // @14F2 memory[0x00:0x00 + returndata.length] // } 14EA 3D RETURNDATASIZE 14EB 60 PUSH1 0x00 14ED 80 DUP1 14EE 3E RETURNDATACOPY 14EF 3D RETURNDATASIZE 14F0 60 PUSH1 0x00 14F2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14EE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @14F2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_14F3: // Incoming jump from 0x14E9, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @14FA memory[0x40:0x60] // @14FB returndata.length // } 14F3 5B JUMPDEST 14F4 50 POP 14F5 50 POP 14F6 50 POP 14F7 50 POP 14F8 60 PUSH1 0x40 14FA 51 MLOAD 14FB 3D RETURNDATASIZE 14FC 60 PUSH1 0x20 14FE 81 DUP2 14FF 10 LT 1500 15 ISZERO 1501 61 PUSH2 0x1509 1504 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @14FA stack[-4] = memory[0x40:0x60] // @14FB stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1509, if !(returndata.length < 0x20) label_1505: // Incoming jump from 0x1504, if not !(returndata.length < 0x20) // Inputs[1] { @1508 memory[0x00:0x00] } 1505 60 PUSH1 0x00 1507 80 DUP1 1508 FD *REVERT // Stack delta = +0 // Outputs[1] { @1508 revert(memory[0x00:0x00]); } // Block terminates label_1509: // Incoming jump from 0x1504, if !(returndata.length < 0x20) // Inputs[4] // { // @150B stack[-2] // @150B memory[stack[-2]:stack[-2] + 0x20] // @154E stack[-5] // @1550 stack[-3] // } 1509 5B JUMPDEST 150A 50 POP 150B 51 MLOAD 150C 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1529 19 NOT 152A 81 DUP2 152B 16 AND 152C 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 154D 14 EQ 154E 93 SWAP4 154F 50 POP 1550 90 SWAP1 1551 50 POP // Stack delta = -2 // Outputs[2] // { // @154E stack[-5] = 0x150b7a0200000000000000000000000000000000000000000000000000000000 == memory[stack[-2]:stack[-2] + 0x20] & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @1550 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block continues label_1552: // Incoming jump from 0x13F9 // Incoming jump from 0x1551 // Inputs[3] // { // @1555 stack[-8] // @1555 stack[-3] // @1556 stack[-7] // } 1552 5B JUMPDEST 1553 50 POP 1554 50 POP 1555 94 SWAP5 1556 93 SWAP4 1557 50 POP 1558 50 POP 1559 50 POP 155A 50 POP 155B 56 *JUMP // Stack delta = -7 // Outputs[1] { @1555 stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_155C: // Incoming call from 0x0A31, returns to 0x07B3 // Inputs[2] // { // @1565 stack[-2] // @1566 stack[-1] // } 155C 5B JUMPDEST 155D 60 PUSH1 0x00 155F 80 DUP1 1560 60 PUSH1 0x00 1562 61 PUSH2 0x156b 1565 85 DUP6 1566 85 DUP6 1567 61 PUSH2 0x0f6f 156A 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @155D stack[0] = 0x00 // @155F stack[1] = 0x00 // @1560 stack[2] = 0x00 // @1562 stack[3] = 0x156b // @1565 stack[4] = stack[-2] // @1566 stack[5] = stack[-1] // } // Block ends with call to 0x0f6f, returns to 0x156B label_156B: // Incoming return from call to 0x0F6F at 0x156A // Inputs[2] // { // @156F stack[-5] // @1570 stack[-4] // } 156B 5B JUMPDEST 156C 61 PUSH2 0x1575 156F 85 DUP6 1570 85 DUP6 1571 61 PUSH2 0x0fe0 1574 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @156C stack[0] = 0x1575 // @156F stack[1] = stack[-5] // @1570 stack[2] = stack[-4] // } // Block ends with call to 0x0fe0, returns to 0x1575 label_1575: // Incoming return from call to 0x0FE0 at 0x1574 // Incoming return from call to 0x0FE0 at 0x1574 // Inputs[3] // { // @1578 stack[-4] // @1583 memory[0x00:0x40] // @1584 storage[keccak256(memory[0x00:0x40])] // } 1575 5B JUMPDEST 1576 60 PUSH1 0x00 1578 84 DUP5 1579 81 DUP2 157A 52 MSTORE 157B 60 PUSH1 0x0e 157D 60 PUSH1 0x20 157F 52 MSTORE 1580 60 PUSH1 0x40 1582 90 SWAP1 1583 20 SHA3 1584 54 SLOAD 1585 60 PUSH1 0x02 1587 60 PUSH1 0x00 1589 19 NOT 158A 61 PUSH2 0x0100 158D 60 PUSH1 0x01 158F 84 DUP5 1590 16 AND 1591 15 ISZERO 1592 02 MUL 1593 01 ADD 1594 90 SWAP1 1595 91 SWAP2 1596 16 AND 1597 04 DIV 1598 15 ISZERO 1599 61 PUSH2 0x15b3 159C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @157A memory[0x00:0x20] = stack[-4] // @157F memory[0x20:0x40] = 0x0e // } // Block ends with conditional jump to 0x15b3, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_159D: // Incoming jump from 0x159C, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[2] // { // @159F stack[-4] // @15AA memory[0x00:0x40] // } 159D 60 PUSH1 0x00 159F 84 DUP5 15A0 81 DUP2 15A1 52 MSTORE 15A2 60 PUSH1 0x0e 15A4 60 PUSH1 0x20 15A6 52 MSTORE 15A7 60 PUSH1 0x40 15A9 81 DUP2 15AA 20 SHA3 15AB 61 PUSH2 0x15b3 15AE 91 SWAP2 15AF 61 PUSH2 0x181e 15B2 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @15A1 memory[0x00:0x20] = stack[-4] // @15A6 memory[0x20:0x40] = 0x0e // @15AA stack[1] = keccak256(memory[0x00:0x40]) // @15AE stack[0] = 0x15b3 // @15AE stack[2] = 0x00 // } // Block ends with call to 0x181e, returns to 0x15B3 label_15B3: // Incoming jump from 0x159C, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming return from call to 0x181E at 0x15B2 // Inputs[1] { @15B6 storage[0x05] } 15B3 5B JUMPDEST 15B4 60 PUSH1 0x05 15B6 54 SLOAD 15B7 61 PUSH2 0x0100 15BA 90 SWAP1 15BB 04 DIV 15BC 60 PUSH1 0xff 15BE 16 AND 15BF 15 ISZERO 15C0 61 PUSH2 0x166e 15C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x166e, if !(0xff & storage[0x05] / 0x0100) label_15C4: // Incoming jump from 0x15C3, if not !(0xff & storage[0x05] / 0x0100) // Inputs[5] // { // @15C6 stack[-4] // @15D1 memory[0x00:0x40] // @15D2 storage[keccak256(memory[0x00:0x40])] // @15D5 storage[0x06] // @15D7 stack[-3] // } 15C4 60 PUSH1 0x00 15C6 84 DUP5 15C7 81 DUP2 15C8 52 MSTORE 15C9 60 PUSH1 0x07 15CB 60 PUSH1 0x20 15CD 52 MSTORE 15CE 60 PUSH1 0x40 15D0 90 SWAP1 15D1 20 SHA3 15D2 54 SLOAD 15D3 60 PUSH1 0x06 15D5 54 SLOAD 15D6 90 SWAP1 15D7 93 SWAP4 15D8 50 POP 15D9 61 PUSH2 0x15e9 15DC 90 SWAP1 15DD 60 PUSH1 0x01 15DF 63 PUSH4 0xffffffff 15E4 61 PUSH2 0x1774 15E7 16 AND 15E8 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @15C8 memory[0x00:0x20] = stack[-4] // @15CD memory[0x20:0x40] = 0x07 // @15D7 stack[-3] = storage[keccak256(memory[0x00:0x40])] // @15DC stack[1] = storage[0x06] // @15DC stack[0] = 0x15e9 // @15DD stack[2] = 0x01 // } // Block ends with call to 0x1774 & 0xffffffff, returns to 0x15E9 label_15E9: // Incoming return from call to 0x1774 at 0x15E8 // Inputs[3] // { // @15EA stack[-1] // @15EA stack[-3] // @15F0 storage[0x06] // } 15E9 5B JUMPDEST 15EA 91 SWAP2 15EB 50 POP 15EC 60 PUSH1 0x06 15EE 82 DUP3 15EF 81 DUP2 15F0 54 SLOAD 15F1 81 DUP2 15F2 10 LT 15F3 15 ISZERO 15F4 15 ISZERO 15F5 61 PUSH2 0x15fa 15F8 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @15EA stack[-3] = stack[-1] // @15EC stack[-1] = 0x06 // @15EE stack[0] = stack[-1] // } // Block ends with conditional jump to 0x15fa, if !!(stack[-1] < storage[0x06]) label_15F9: // Incoming jump from 0x15F8, if not !!(stack[-1] < storage[0x06]) 15F9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @15F9 assert(); } // Block terminates label_15FA: // Incoming jump from 0x15F8, if !!(stack[-1] < storage[0x06]) // Inputs[7] // { // @15FB stack[-1] // @15FB stack[-2] // @1603 memory[0x00:0x20] // @1605 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1606 stack[-3] // @160B stack[-5] // @160D storage[0x06] // } 15FA 5B JUMPDEST 15FB 90 SWAP1 15FC 60 PUSH1 0x00 15FE 52 MSTORE 15FF 60 PUSH1 0x20 1601 60 PUSH1 0x00 1603 20 SHA3 1604 01 ADD 1605 54 SLOAD 1606 90 SWAP1 1607 50 POP 1608 80 DUP1 1609 60 PUSH1 0x06 160B 84 DUP5 160C 81 DUP2 160D 54 SLOAD 160E 81 DUP2 160F 10 LT 1610 15 ISZERO 1611 15 ISZERO 1612 61 PUSH2 0x1617 1615 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @15FE memory[0x00:0x20] = stack[-2] // @1606 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1608 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1609 stack[-1] = 0x06 // @160B stack[0] = stack[-5] // } // Block ends with conditional jump to 0x1617, if !!(stack[-5] < storage[0x06]) label_1616: // Incoming jump from 0x1615, if not !!(stack[-5] < storage[0x06]) 1616 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1616 assert(); } // Block terminates label_1617: // Incoming jump from 0x1615, if !!(stack[-5] < storage[0x06]) // Inputs[6] // { // @161A stack[-2] // @1620 memory[0x00:0x20] // @1621 stack[-1] // @1622 stack[-3] // @1629 storage[0x06] // @162A stack[-5] // } 1617 5B JUMPDEST 1618 60 PUSH1 0x00 161A 91 SWAP2 161B 82 DUP3 161C 52 MSTORE 161D 60 PUSH1 0x20 161F 82 DUP3 1620 20 SHA3 1621 01 ADD 1622 91 SWAP2 1623 90 SWAP1 1624 91 SWAP2 1625 55 SSTORE 1626 60 PUSH1 0x06 1628 80 DUP1 1629 54 SLOAD 162A 84 DUP5 162B 90 SWAP1 162C 81 DUP2 162D 10 LT 162E 61 PUSH2 0x1633 1631 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @161C memory[0x00:0x20] = stack[-2] // @1624 stack[-3] = 0x00 // @1625 storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @1626 stack[-2] = 0x06 // @162B stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x1633, if stack[-5] < storage[0x06] label_1632: // Incoming jump from 0x1631, if not stack[-5] < storage[0x06] 1632 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1632 assert(); } // Block terminates label_1633: // Incoming jump from 0x1631, if stack[-5] < storage[0x06] // Inputs[5] // { // @1636 stack[-2] // @163B stack[-1] // @163D memory[0x00:0x20] // @163F stack[-3] // @1643 storage[0x06] // } 1633 5B JUMPDEST 1634 60 PUSH1 0x00 1636 91 SWAP2 1637 82 DUP3 1638 52 MSTORE 1639 60 PUSH1 0x20 163B 90 SWAP1 163C 91 SWAP2 163D 20 SHA3 163E 01 ADD 163F 55 SSTORE 1640 60 PUSH1 0x06 1642 80 DUP1 1643 54 SLOAD 1644 90 SWAP1 1645 61 PUSH2 0x1652 1648 90 SWAP1 1649 60 PUSH1 0x00 164B 19 NOT 164C 83 DUP4 164D 01 ADD 164E 61 PUSH2 0x17fa 1651 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1638 memory[0x00:0x20] = stack[-2] // @163F storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @1644 stack[-3] = storage[0x06] // @1648 stack[-2] = 0x1652 // @1648 stack[-1] = 0x06 // @164D stack[0] = storage[0x06] + ~0x00 // } // Block ends with call to 0x17fa, returns to 0x1652 label_1652: // Incoming return from call to 0x17FA at 0x1651 // Inputs[5] // { // @1656 stack[-5] // @1662 memory[0x00:0x40] // @1666 stack[-2] // @166A memory[0x00:0x40] // @166B stack[-4] // } 1652 5B JUMPDEST 1653 50 POP 1654 60 PUSH1 0x00 1656 84 DUP5 1657 81 DUP2 1658 52 MSTORE 1659 60 PUSH1 0x07 165B 60 PUSH1 0x20 165D 52 MSTORE 165E 60 PUSH1 0x40 1660 80 DUP1 1661 82 DUP3 1662 20 SHA3 1663 82 DUP3 1664 90 SWAP1 1665 55 SSTORE 1666 82 DUP3 1667 82 DUP3 1668 52 MSTORE 1669 90 SWAP1 166A 20 SHA3 166B 83 DUP4 166C 90 SWAP1 166D 55 SSTORE // Stack delta = -1 // Outputs[5] // { // @1658 memory[0x00:0x20] = stack[-5] // @165D memory[0x20:0x40] = 0x07 // @1665 storage[keccak256(memory[0x00:0x40])] = 0x00 // @1668 memory[0x00:0x20] = stack[-2] // @166D storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_166E: // Incoming jump from 0x166D // Incoming jump from 0x15C3, if !(0xff & storage[0x05] / 0x0100) // Inputs[5] // { // @1671 memory[0x40:0x60] // @1672 stack[-4] // @167F stack[-5] // @16A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @16AC stack[-6] // } 166E 5B JUMPDEST 166F 60 PUSH1 0x40 1671 51 MLOAD 1672 84 DUP5 1673 90 SWAP1 1674 60 PUSH1 0x00 1676 90 SWAP1 1677 60 PUSH1 0x01 1679 60 PUSH1 0xa0 167B 60 PUSH1 0x02 167D 0A EXP 167E 03 SUB 167F 88 DUP9 1680 16 AND 1681 90 SWAP1 1682 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 16A3 90 SWAP1 16A4 83 DUP4 16A5 90 SWAP1 16A6 A4 LOG4 16A7 50 POP 16A8 50 POP 16A9 50 POP 16AA 50 POP 16AB 50 POP 16AC 56 *JUMP // Stack delta = -6 // Outputs[1] { @16A6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-5] & 0x02 ** 0xa0 - 0x01, 0x00, stack[-4]]); } // Block ends with unconditional jump to stack[-6] 16AD 5B JUMPDEST 16AE 61 PUSH2 0x16b6 16B1 82 DUP3 16B2 61 PUSH2 0x0eab 16B5 56 *JUMP 16B6 5B JUMPDEST 16B7 15 ISZERO 16B8 15 ISZERO 16B9 61 PUSH2 0x16c1 16BC 57 *JUMPI 16BD 60 PUSH1 0x00 16BF 80 DUP1 16C0 FD *REVERT 16C1 5B JUMPDEST 16C2 60 PUSH1 0x00 16C4 82 DUP3 16C5 81 DUP2 16C6 52 MSTORE 16C7 60 PUSH1 0x0e 16C9 60 PUSH1 0x20 16CB 90 SWAP1 16CC 81 DUP2 16CD 52 MSTORE 16CE 60 PUSH1 0x40 16D0 90 SWAP1 16D1 91 SWAP2 16D2 20 SHA3 16D3 82 DUP3 16D4 51 MLOAD 16D5 61 PUSH2 0x09f5 16D8 92 SWAP3 16D9 84 DUP5 16DA 01 ADD 16DB 90 SWAP1 16DC 61 PUSH2 0x1862 16DF 56 *JUMP label_16E0: // Incoming call from 0x0E7A, returns to 0x0E7B // Inputs[1] { @16E6 stack[-1] } 16E0 5B JUMPDEST 16E1 61 PUSH2 0x16f1 16E4 60 PUSH1 0x02 16E6 82 DUP3 16E7 63 PUSH4 0xffffffff 16EC 61 PUSH2 0x1728 16EF 16 AND 16F0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16E1 stack[0] = 0x16f1 // @16E4 stack[1] = 0x02 // @16E6 stack[2] = stack[-1] // } // Block ends with call to 0x1728 & 0xffffffff, returns to 0x16F1 label_16F1: // Incoming return from call to 0x1728 at 0x16F0 // Inputs[4] // { // @16F4 memory[0x40:0x60] // @16FD stack[-1] // @1725 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1727 stack[-2] // } 16F1 5B JUMPDEST 16F2 60 PUSH1 0x40 16F4 51 MLOAD 16F5 60 PUSH1 0x01 16F7 60 PUSH1 0xa0 16F9 60 PUSH1 0x02 16FB 0A EXP 16FC 03 SUB 16FD 82 DUP3 16FE 16 AND 16FF 90 SWAP1 1700 7F PUSH32 0x4035d91020256e004a98d6a179f13602f5e859c5f0c874dd50eadaf3ea3034d1 1721 90 SWAP1 1722 60 PUSH1 0x00 1724 90 SWAP1 1725 A2 LOG2 1726 50 POP 1727 56 *JUMP // Stack delta = -2 // Outputs[1] { @1725 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x4035d91020256e004a98d6a179f13602f5e859c5f0c874dd50eadaf3ea3034d1, stack[-1] & 0x02 ** 0xa0 - 0x01]); } // Block ends with unconditional jump to stack[-2] label_1728: // Incoming call from 0x16F0, returns to 0x16F1 // Inputs[1] { @1731 stack[-1] } 1728 5B JUMPDEST 1729 60 PUSH1 0x01 172B 60 PUSH1 0xa0 172D 60 PUSH1 0x02 172F 0A EXP 1730 03 SUB 1731 81 DUP2 1732 16 AND 1733 15 ISZERO 1734 15 ISZERO 1735 61 PUSH2 0x173d 1738 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x173d, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) label_1739: // Incoming jump from 0x1738, if not !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @173C memory[0x00:0x00] } 1739 60 PUSH1 0x00 173B 80 DUP1 173C FD *REVERT // Stack delta = +0 // Outputs[1] { @173C revert(memory[0x00:0x00]); } // Block terminates label_173D: // Incoming jump from 0x1738, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[2] // { // @1741 stack[-2] // @1742 stack[-1] // } 173D 5B JUMPDEST 173E 61 PUSH2 0x1747 1741 82 DUP3 1742 82 DUP3 1743 61 PUSH2 0x125d 1746 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @173E stack[0] = 0x1747 // @1741 stack[1] = stack[-2] // @1742 stack[2] = stack[-1] // } // Block ends with call to 0x125d, returns to 0x1747 label_1747: // Incoming return from call to 0x125D at 0x1746 // Inputs[1] { @1748 stack[-1] } 1747 5B JUMPDEST 1748 15 ISZERO 1749 15 ISZERO 174A 61 PUSH2 0x1752 174D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1752, if !!stack[-1] label_174E: // Incoming jump from 0x174D, if not !!stack[-1] // Inputs[1] { @1751 memory[0x00:0x00] } 174E 60 PUSH1 0x00 1750 80 DUP1 1751 FD *REVERT // Stack delta = +0 // Outputs[1] { @1751 revert(memory[0x00:0x00]); } // Block terminates label_1752: // Incoming jump from 0x174D, if !!stack[-1] // Inputs[5] // { // @175B stack[-1] // @1763 stack[-2] // @176A memory[0x00:0x40] // @176C storage[keccak256(memory[0x00:0x40])] // @1773 stack[-3] // } 1752 5B JUMPDEST 1753 60 PUSH1 0x01 1755 60 PUSH1 0xa0 1757 60 PUSH1 0x02 1759 0A EXP 175A 03 SUB 175B 16 AND 175C 60 PUSH1 0x00 175E 90 SWAP1 175F 81 DUP2 1760 52 MSTORE 1761 60 PUSH1 0x20 1763 91 SWAP2 1764 90 SWAP1 1765 91 SWAP2 1766 52 MSTORE 1767 60 PUSH1 0x40 1769 90 SWAP1 176A 20 SHA3 176B 80 DUP1 176C 54 SLOAD 176D 60 PUSH1 0xff 176F 19 NOT 1770 16 AND 1771 90 SWAP1 1772 55 SSTORE 1773 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1760 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @1766 memory[0x20:0x40] = stack[-2] // @1772 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1774: // Incoming call from 0x1034, returns to 0x1035 // Incoming call from 0x10C1, returns to 0x10C2 // Incoming call from 0x15E8, returns to 0x15E9 // Inputs[2] // { // @1778 stack[-2] // @1779 stack[-1] // } 1774 5B JUMPDEST 1775 60 PUSH1 0x00 1777 80 DUP1 1778 83 DUP4 1779 83 DUP4 177A 11 GT 177B 15 ISZERO 177C 61 PUSH2 0x1784 177F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1775 stack[0] = 0x00 // @1777 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1784, if !(stack[-1] > stack[-2]) label_1780: // Incoming jump from 0x177F, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1783 memory[0x00:0x00] } 1780 60 PUSH1 0x00 1782 80 DUP1 1783 FD *REVERT // Stack delta = +0 // Outputs[1] { @1783 revert(memory[0x00:0x00]); } // Block terminates label_1784: // Incoming jump from 0x177F, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @1787 stack[-3] // @1787 stack[-4] // @1789 stack[-5] // } 1784 5B JUMPDEST 1785 50 POP 1786 50 POP 1787 90 SWAP1 1788 03 SUB 1789 90 SWAP1 178A 56 *JUMP // Stack delta = -4 // Outputs[1] { @1789 stack[-5] = stack[-4] - stack[-3] } // Block ends with unconditional jump to stack[-5] label_178B: // Incoming call from 0x11EF, returns to 0x11F0 // Inputs[2] // { // @178E stack[-2] // @178F stack[-1] // } 178B 5B JUMPDEST 178C 60 PUSH1 0x00 178E 82 DUP3 178F 82 DUP3 1790 01 ADD 1791 83 DUP4 1792 81 DUP2 1793 10 LT 1794 15 ISZERO 1795 61 PUSH2 0x179d 1798 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @178C stack[0] = 0x00 // @1790 stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x179d, if !(stack[-1] + stack[-2] < stack[-2]) label_1799: // Incoming jump from 0x1798, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[1] { @179C memory[0x00:0x00] } 1799 60 PUSH1 0x00 179B 80 DUP1 179C FD *REVERT // Stack delta = +0 // Outputs[1] { @179C revert(memory[0x00:0x00]); } // Block terminates label_179D: // Incoming jump from 0x1798, if !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @179E stack[-5] // @179E stack[-1] // @179F stack[-4] // } 179D 5B JUMPDEST 179E 93 SWAP4 179F 92 SWAP3 17A0 50 POP 17A1 50 POP 17A2 50 POP 17A3 56 *JUMP // Stack delta = -4 // Outputs[1] { @179E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 17A4 5B JUMPDEST 17A5 60 PUSH1 0x01 17A7 60 PUSH1 0xa0 17A9 60 PUSH1 0x02 17AB 0A EXP 17AC 03 SUB 17AD 81 DUP2 17AE 16 AND 17AF 15 ISZERO 17B0 15 ISZERO 17B1 61 PUSH2 0x17b9 17B4 57 *JUMPI 17B5 60 PUSH1 0x00 17B7 80 DUP1 17B8 FD *REVERT 17B9 5B JUMPDEST 17BA 61 PUSH2 0x17c3 17BD 82 DUP3 17BE 82 DUP3 17BF 61 PUSH2 0x125d 17C2 56 *JUMP 17C3 5B JUMPDEST 17C4 15 ISZERO 17C5 61 PUSH2 0x17cd 17C8 57 *JUMPI 17C9 60 PUSH1 0x00 17CB 80 DUP1 17CC FD *REVERT 17CD 5B JUMPDEST 17CE 60 PUSH1 0x01 17D0 60 PUSH1 0xa0 17D2 60 PUSH1 0x02 17D4 0A EXP 17D5 03 SUB 17D6 16 AND 17D7 60 PUSH1 0x00 17D9 90 SWAP1 17DA 81 DUP2 17DB 52 MSTORE 17DC 60 PUSH1 0x20 17DE 91 SWAP2 17DF 90 SWAP1 17E0 91 SWAP2 17E1 52 MSTORE 17E2 60 PUSH1 0x40 17E4 90 SWAP1 17E5 20 SHA3 17E6 80 DUP1 17E7 54 SLOAD 17E8 60 PUSH1 0xff 17EA 19 NOT 17EB 16 AND 17EC 60 PUSH1 0x01 17EE 17 OR 17EF 90 SWAP1 17F0 55 SSTORE 17F1 56 *JUMP label_17F2: // Incoming call from 0x13EA, returns to 0x13EB // Inputs[3] // { // @17F5 stack[-1] // @17F6 address(stack[-1]).code.length // @17F8 stack[-2] // } 17F2 5B JUMPDEST 17F3 60 PUSH1 0x00 17F5 90 SWAP1 17F6 3B EXTCODESIZE 17F7 11 GT 17F8 90 SWAP1 17F9 56 *JUMP // Stack delta = -1 // Outputs[1] { @17F8 stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_17FA: // Incoming call from 0x1651, returns to 0x1652 // Incoming call from 0x1160, returns to 0x1161 // Inputs[3] // { // @17FB stack[-2] // @17FC storage[stack[-2]] // @17FD stack[-1] // } 17FA 5B JUMPDEST 17FB 81 DUP2 17FC 54 SLOAD 17FD 81 DUP2 17FE 83 DUP4 17FF 55 SSTORE 1800 81 DUP2 1801 81 DUP2 1802 11 GT 1803 15 ISZERO 1804 61 PUSH2 0x09f5 1807 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @17FC stack[0] = storage[stack[-2]] // @17FF storage[stack[-2]] = stack[-1] // } // Block ends with conditional jump to 0x09f5, if !(storage[stack[-2]] > stack[-1]) label_1808: // Incoming jump from 0x1807, if not !(storage[stack[-2]] > stack[-1]) // Inputs[4] // { // @180A stack[-3] // @1810 memory[0x00:0x20] // @1814 stack[-1] // @1818 stack[-2] // } 1808 60 PUSH1 0x00 180A 83 DUP4 180B 81 DUP2 180C 52 MSTORE 180D 60 PUSH1 0x20 180F 90 SWAP1 1810 20 SHA3 1811 61 PUSH2 0x09f5 1814 91 SWAP2 1815 81 DUP2 1816 01 ADD 1817 90 SWAP1 1818 83 DUP4 1819 01 ADD 181A 61 PUSH2 0x18e0 181D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @180C memory[0x00:0x20] = stack[-3] // @1814 stack[-1] = 0x09f5 // @1817 stack[0] = keccak256(memory[0x00:0x20]) + stack[-1] // @1819 stack[1] = stack[-2] + keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x18e0, returns to 0x09F5 label_181E: // Incoming call from 0x15B2, returns to 0x15B3 // Inputs[2] // { // @1820 stack[-2] // @1821 storage[stack[-2]] // } 181E 5B JUMPDEST 181F 50 POP 1820 80 DUP1 1821 54 SLOAD 1822 60 PUSH1 0x01 1824 81 DUP2 1825 60 PUSH1 0x01 1827 16 AND 1828 15 ISZERO 1829 61 PUSH2 0x0100 182C 02 MUL 182D 03 SUB 182E 16 AND 182F 60 PUSH1 0x02 1831 90 SWAP1 1832 04 DIV 1833 60 PUSH1 0x00 1835 82 DUP3 1836 55 SSTORE 1837 80 DUP1 1838 60 PUSH1 0x1f 183A 10 LT 183B 61 PUSH2 0x1844 183E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1832 stack[-1] = (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 // @1836 storage[stack[-2]] = 0x00 // } // Block ends with conditional jump to 0x1844, if 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 label_183F: // Incoming jump from 0x183E, if not 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 183F 50 POP 1840 61 PUSH2 0x07b3 1843 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x07b3 label_1844: // Incoming jump from 0x183E, if 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 // Inputs[3] // { // @1847 stack[-1] // @184C stack[-2] // @1854 memory[0x00:0x20] // } 1844 5B JUMPDEST 1845 60 PUSH1 0x1f 1847 01 ADD 1848 60 PUSH1 0x20 184A 90 SWAP1 184B 04 DIV 184C 90 SWAP1 184D 60 PUSH1 0x00 184F 52 MSTORE 1850 60 PUSH1 0x20 1852 60 PUSH1 0x00 1854 20 SHA3 1855 90 SWAP1 1856 81 DUP2 1857 01 ADD 1858 90 SWAP1 1859 61 PUSH2 0x07b3 185C 91 SWAP2 185D 90 SWAP1 185E 61 PUSH2 0x18e0 1861 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @184F memory[0x00:0x20] = stack[-2] // @185C stack[-2] = 0x07b3 // @185D stack[-1] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // @185D stack[0] = keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x18e0, returns to 0x07B3 1862 5B JUMPDEST 1863 82 DUP3 1864 80 DUP1 1865 54 SLOAD 1866 60 PUSH1 0x01 1868 81 DUP2 1869 60 PUSH1 0x01 186B 16 AND 186C 15 ISZERO 186D 61 PUSH2 0x0100 1870 02 MUL 1871 03 SUB 1872 16 AND 1873 60 PUSH1 0x02 1875 90 SWAP1 1876 04 DIV 1877 90 SWAP1 1878 60 PUSH1 0x00 187A 52 MSTORE 187B 60 PUSH1 0x20 187D 60 PUSH1 0x00 187F 20 SHA3 1880 90 SWAP1 1881 60 PUSH1 0x1f 1883 01 ADD 1884 60 PUSH1 0x20 1886 90 SWAP1 1887 04 DIV 1888 81 DUP2 1889 01 ADD 188A 92 SWAP3 188B 82 DUP3 188C 60 PUSH1 0x1f 188E 10 LT 188F 61 PUSH2 0x18a3 1892 57 *JUMPI 1893 80 DUP1 1894 51 MLOAD 1895 60 PUSH1 0xff 1897 19 NOT 1898 16 AND 1899 83 DUP4 189A 80 DUP1 189B 01 ADD 189C 17 OR 189D 85 DUP6 189E 55 SSTORE 189F 61 PUSH2 0x18d0 18A2 56 *JUMP 18A3 5B JUMPDEST 18A4 82 DUP3 18A5 80 DUP1 18A6 01 ADD 18A7 60 PUSH1 0x01 18A9 01 ADD 18AA 85 DUP6 18AB 55 SSTORE 18AC 82 DUP3 18AD 15 ISZERO 18AE 61 PUSH2 0x18d0 18B1 57 *JUMPI 18B2 91 SWAP2 18B3 82 DUP3 18B4 01 ADD 18B5 5B JUMPDEST 18B6 82 DUP3 18B7 81 DUP2 18B8 11 GT 18B9 15 ISZERO 18BA 61 PUSH2 0x18d0 18BD 57 *JUMPI 18BE 82 DUP3 18BF 51 MLOAD 18C0 82 DUP3 18C1 55 SSTORE 18C2 91 SWAP2 18C3 60 PUSH1 0x20 18C5 01 ADD 18C6 91 SWAP2 18C7 90 SWAP1 18C8 60 PUSH1 0x01 18CA 01 ADD 18CB 90 SWAP1 18CC 61 PUSH2 0x18b5 18CF 56 *JUMP 18D0 5B JUMPDEST 18D1 50 POP 18D2 61 PUSH2 0x18dc 18D5 92 SWAP3 18D6 91 SWAP2 18D7 50 POP 18D8 61 PUSH2 0x18e0 18DB 56 *JUMP label_18DC: // Incoming jump from 0x18EE, if !(stack[-2] > stack[-1]) // Incoming jump from 0x18EE, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @18DE stack[-3] // @18DE stack[-2] // } 18DC 5B JUMPDEST 18DD 50 POP 18DE 90 SWAP1 18DF 56 *JUMP // Stack delta = -2 // Outputs[1] { @18DE stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_18E0: // Incoming call from 0x1861, returns to 0x07B3 // Incoming call from 0x181D, returns to 0x09F5 // Inputs[2] // { // @18E4 stack[-2] // @18E5 stack[-1] // } 18E0 5B JUMPDEST 18E1 61 PUSH2 0x06c4 18E4 91 SWAP2 18E5 90 SWAP1 18E6 5B JUMPDEST 18E7 80 DUP1 18E8 82 DUP3 18E9 11 GT 18EA 15 ISZERO 18EB 61 PUSH2 0x18dc 18EE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @18E4 stack[-2] = 0x06c4 // @18E5 stack[-1] = stack[-2] // @18E5 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x18dc, if !(stack[-2] > stack[-1]) label_18EF: // Incoming jump from 0x18EE, if not !(stack[-2] > stack[-1]) // Incoming call from 0x18EE, returns to 0x06C4, if not !(stack[-2] > stack[-1]) // Inputs[1] { @18F1 stack[-1] } 18EF 60 PUSH1 0x00 18F1 81 DUP2 18F2 55 SSTORE 18F3 60 PUSH1 0x01 18F5 01 ADD 18F6 61 PUSH2 0x18e6 18F9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18F2 storage[stack[-1]] = 0x00 // @18F5 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x18e6 18FA 00 *STOP 18FB A1 LOG1 18FC 65 PUSH6 0x627a7a723058 1903 20 SHA3 1904 57 *JUMPI 1905 82 DUP3 1906 ED ED 1907 4C 4C 1908 13 SGT 1909 C1 C1 190A 85 DUP6 190B 9D SWAP14 190C B4 B4 190D 2B 2B 190E D4 D4 190F 94 SWAP5 1910 F8 F8 1911 D8 D8 1912 3B EXTCODESIZE 1913 1A BYTE 1914 CD CD 1915 FC FC 1916 3E RETURNDATACOPY 1917 71 PUSH18 0x9f0d7b2654ba8960cb64b2ca0029