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 0x040b6583 0046 14 EQ 0047 61 PUSH2 0x01c4 004A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c4, if 0x040b6583 == stack[-1] label_004B: // Incoming jump from 0x004A, if not 0x040b6583 == stack[-1] // Inputs[1] { @004B stack[-1] } 004B 80 DUP1 004C 63 PUSH4 0x06fdde03 0051 14 EQ 0052 61 PUSH2 0x01e0 0055 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e0, if 0x06fdde03 == stack[-1] label_0056: // Incoming jump from 0x0055, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0056 stack[-1] } 0056 80 DUP1 0057 63 PUSH4 0x081812fc 005C 14 EQ 005D 61 PUSH2 0x026a 0060 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026a, if 0x081812fc == stack[-1] label_0061: // Incoming jump from 0x0060, if not 0x081812fc == stack[-1] // Inputs[1] { @0061 stack[-1] } 0061 80 DUP1 0062 63 PUSH4 0x095ea7b3 0067 14 EQ 0068 61 PUSH2 0x029e 006B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029e, if 0x095ea7b3 == stack[-1] label_006C: // Incoming jump from 0x006B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @006C stack[-1] } 006C 80 DUP1 006D 63 PUSH4 0x18160ddd 0072 14 EQ 0073 61 PUSH2 0x02c2 0076 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c2, 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 0x02e9 0081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e9, 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 0x2cb2f52e 0088 14 EQ 0089 61 PUSH2 0x0313 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0313, if 0x2cb2f52e == stack[-1] label_008D: // Incoming jump from 0x008C, if not 0x2cb2f52e == stack[-1] // Inputs[1] { @008D stack[-1] } 008D 80 DUP1 008E 63 PUSH4 0x2f745c59 0093 14 EQ 0094 61 PUSH2 0x0371 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0371, if 0x2f745c59 == stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x3af32abf 009E 14 EQ 009F 61 PUSH2 0x0395 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0395, if 0x3af32abf == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x3af32abf == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x40c1a064 00A9 14 EQ 00AA 61 PUSH2 0x03b6 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b6, if 0x40c1a064 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x40c1a064 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x42842e0e 00B4 14 EQ 00B5 61 PUSH2 0x03ce 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ce, if 0x42842e0e == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x42842e0e == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x4f6ccce7 00BF 14 EQ 00C0 61 PUSH2 0x03f8 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f8, if 0x4f6ccce7 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x6297c16c 00CA 14 EQ 00CB 61 PUSH2 0x0410 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0410, if 0x6297c16c == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x6297c16c == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x6352211e 00D5 14 EQ 00D6 61 PUSH2 0x0428 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0428, if 0x6352211e == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x6352211e == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x70a08231 00E0 14 EQ 00E1 61 PUSH2 0x0440 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0440, if 0x70a08231 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x70a08231 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x715018a6 00EB 14 EQ 00EC 61 PUSH2 0x0461 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0461, if 0x715018a6 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x715018a6 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x8ab1d681 00F6 14 EQ 00F7 61 PUSH2 0x0476 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0476, if 0x8ab1d681 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x8ab1d681 == stack[-1] // Inputs[1] { @00FB stack[-1] } 00FB 80 DUP1 00FC 63 PUSH4 0x8da5cb5b 0101 14 EQ 0102 61 PUSH2 0x0497 0105 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0x8da5cb5b == stack[-1] label_0106: // Incoming jump from 0x0105, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0106 stack[-1] } 0106 80 DUP1 0107 63 PUSH4 0x8f32d59b 010C 14 EQ 010D 61 PUSH2 0x04ac 0110 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ac, if 0x8f32d59b == stack[-1] label_0111: // Incoming jump from 0x0110, if not 0x8f32d59b == stack[-1] // Inputs[1] { @0111 stack[-1] } 0111 80 DUP1 0112 63 PUSH4 0x95d89b41 0117 14 EQ 0118 61 PUSH2 0x04c1 011B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c1, 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 0xa22cb465 0122 14 EQ 0123 61 PUSH2 0x04d6 0126 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d6, if 0xa22cb465 == stack[-1] label_0127: // Incoming jump from 0x0126, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0127 stack[-1] } 0127 80 DUP1 0128 63 PUSH4 0xb85ecf93 012D 14 EQ 012E 61 PUSH2 0x04fc 0131 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04fc, if 0xb85ecf93 == stack[-1] label_0132: // Incoming jump from 0x0131, if not 0xb85ecf93 == stack[-1] // Inputs[1] { @0132 stack[-1] } 0132 80 DUP1 0133 63 PUSH4 0xb88d4fde 0138 14 EQ 0139 61 PUSH2 0x0551 013C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0551, if 0xb88d4fde == stack[-1] label_013D: // Incoming jump from 0x013C, if not 0xb88d4fde == stack[-1] // Inputs[1] { @013D stack[-1] } 013D 80 DUP1 013E 63 PUSH4 0xc87b56dd 0143 14 EQ 0144 61 PUSH2 0x05c0 0147 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c0, if 0xc87b56dd == stack[-1] label_0148: // Incoming jump from 0x0147, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0148 stack[-1] } 0148 80 DUP1 0149 63 PUSH4 0xd9856c21 014E 14 EQ 014F 61 PUSH2 0x05d8 0152 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d8, if 0xd9856c21 == stack[-1] label_0153: // Incoming jump from 0x0152, if not 0xd9856c21 == stack[-1] // Inputs[1] { @0153 stack[-1] } 0153 80 DUP1 0154 63 PUSH4 0xe43252d7 0159 14 EQ 015A 61 PUSH2 0x0631 015D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0631, if 0xe43252d7 == stack[-1] label_015E: // Incoming jump from 0x015D, if not 0xe43252d7 == stack[-1] // Inputs[1] { @015E stack[-1] } 015E 80 DUP1 015F 63 PUSH4 0xe985e9c5 0164 14 EQ 0165 61 PUSH2 0x0652 0168 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0652, if 0xe985e9c5 == stack[-1] label_0169: // Incoming jump from 0x0168, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0169 stack[-1] } 0169 80 DUP1 016A 63 PUSH4 0xf2fde38b 016F 14 EQ 0170 61 PUSH2 0x0679 0173 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0679, if 0xf2fde38b == stack[-1] label_0174: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0173, if not 0xf2fde38b == 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 0x069a 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 0x069a, returns to 0x01B0 label_01B0: // Incoming return from call to 0x1029 at 0x0678 // Incoming return from call to 0x0D10 at 0x04C0 // Incoming return from call to 0x0AD3 at 0x03B5 // Incoming return from call to 0x069A at 0x01AF // 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 0x040b6583 == 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 // Inputs[1] { @01D7 msg.data[0x04:0x24] } 01D0 5B JUMPDEST 01D1 50 POP 01D2 61 PUSH2 0x01de 01D5 60 PUSH1 0x04 01D7 35 CALLDATALOAD 01D8 15 ISZERO 01D9 15 ISZERO 01DA 61 PUSH2 0x06d2 01DD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @01D2 stack[-1] = 0x01de // @01D9 stack[0] = !!msg.data[0x04:0x24] // } // Block ends with call to 0x06d2, returns to 0x01DE label_01DE: // Incoming return from call to 0x0E06 at 0x0550 // Incoming return from call to 0x0870 at 0x0312 // Incoming return from call to 0x0FD6 at 0x0651 // Incoming return from call to 0x0C51 at 0x0475 // Incoming return from call to 0x0D82 at 0x04FB // Incoming return from call to 0x07C1 at 0x02C1 // Incoming return from call to 0x1057 at 0x0699 // Incoming return from call to 0x0E67 at 0x05BF // Incoming return from call to 0x06D2 at 0x01DD // Incoming return from call to 0x0CAE at 0x0496 01DE 5B JUMPDEST 01DF 00 *STOP // Stack delta = +0 // Outputs[1] { @01DF stop(); } // Block terminates label_01E0: // Incoming jump from 0x0055, if 0x06fdde03 == stack[-1] // Inputs[1] { @01E1 msg.value } 01E0 5B JUMPDEST 01E1 34 CALLVALUE 01E2 80 DUP1 01E3 15 ISZERO 01E4 61 PUSH2 0x01ec 01E7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01E1 stack[0] = msg.value } // Block ends with conditional jump to 0x01ec, if !msg.value label_01E8: // Incoming jump from 0x01E7, if not !msg.value // Inputs[1] { @01EB memory[0x00:0x00] } 01E8 60 PUSH1 0x00 01EA 80 DUP1 01EB FD *REVERT // Stack delta = +0 // Outputs[1] { @01EB revert(memory[0x00:0x00]); } // Block terminates label_01EC: // Incoming jump from 0x01E7, if !msg.value 01EC 5B JUMPDEST 01ED 50 POP 01EE 61 PUSH2 0x01f5 01F1 61 PUSH2 0x06f8 01F4 56 *JUMP // Stack delta = +0 // Outputs[1] { @01EE stack[-1] = 0x01f5 } // Block ends with call to 0x06f8, returns to 0x01F5 label_01F5: // Incoming return from call to 0x06F8 at 0x01F4 // Incoming return from call to 0x0E8F at 0x05D7 // Incoming return from call to 0x0D21 at 0x04D5 // Inputs[4] // { // @01F9 memory[0x40:0x60] // @01FF stack[-1] // @0200 memory[stack[-1]:stack[-1] + 0x20] // @0206 memory[stack[-1]:stack[-1] + 0x20] // } 01F5 5B JUMPDEST 01F6 60 PUSH1 0x40 01F8 80 DUP1 01F9 51 MLOAD 01FA 60 PUSH1 0x20 01FC 80 DUP1 01FD 82 DUP3 01FE 52 MSTORE 01FF 83 DUP4 0200 51 MLOAD 0201 81 DUP2 0202 83 DUP4 0203 01 ADD 0204 52 MSTORE 0205 83 DUP4 0206 51 MLOAD 0207 91 SWAP2 0208 92 SWAP3 0209 83 DUP4 020A 92 SWAP3 020B 90 SWAP1 020C 83 DUP4 020D 01 ADD 020E 91 SWAP2 020F 85 DUP6 0210 01 ADD 0211 90 SWAP1 0212 80 DUP1 0213 83 DUP4 0214 83 DUP4 0215 60 PUSH1 0x00 0217 5B JUMPDEST 0218 83 DUP4 0219 81 DUP2 021A 10 LT 021B 15 ISZERO 021C 61 PUSH2 0x022f 021F 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @0204 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0208 stack[0] = memory[0x40:0x60] // @020A stack[1] = memory[0x40:0x60] // @020E stack[2] = memory[0x40:0x60] + 0x40 // @0211 stack[3] = stack[-1] + 0x20 // @0211 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0212 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0213 stack[6] = memory[0x40:0x60] + 0x40 // @0214 stack[7] = stack[-1] + 0x20 // @0215 stack[8] = 0x00 // } // Block ends with conditional jump to 0x022f, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0220: // Incoming jump from 0x021F, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x021F, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0220 stack[-2] // @0221 stack[-1] // @0223 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0224 stack[-3] // } 0220 81 DUP2 0221 81 DUP2 0222 01 ADD 0223 51 MLOAD 0224 83 DUP4 0225 82 DUP3 0226 01 ADD 0227 52 MSTORE 0228 60 PUSH1 0x20 022A 01 ADD 022B 61 PUSH2 0x0217 022E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0227 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @022A stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0217 label_022F: // Incoming jump from 0x021F, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x021F, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0234 stack[-6] // @0234 stack[-5] // @0236 stack[-7] // } 022F 5B JUMPDEST 0230 50 POP 0231 50 POP 0232 50 POP 0233 50 POP 0234 90 SWAP1 0235 50 POP 0236 90 SWAP1 0237 81 DUP2 0238 01 ADD 0239 90 SWAP1 023A 60 PUSH1 0x1f 023C 16 AND 023D 80 DUP1 023E 15 ISZERO 023F 61 PUSH2 0x025c 0242 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0239 stack[-7] = stack[-5] + stack[-7] // @023C stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x025c, if !(0x1f & stack[-5]) label_0243: // Incoming jump from 0x0242, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0243 stack[-1] // @0244 stack[-2] // @0247 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @025E stack[-5] // @0264 memory[0x40:0x60] // @0269 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0243 80 DUP1 0244 82 DUP3 0245 03 SUB 0246 80 DUP1 0247 51 MLOAD 0248 60 PUSH1 0x01 024A 83 DUP4 024B 60 PUSH1 0x20 024D 03 SUB 024E 61 PUSH2 0x0100 0251 0A EXP 0252 03 SUB 0253 19 NOT 0254 16 AND 0255 81 DUP2 0256 52 MSTORE 0257 60 PUSH1 0x20 0259 01 ADD 025A 91 SWAP2 025B 50 POP 025C 5B JUMPDEST 025D 50 POP 025E 92 SWAP3 025F 50 POP 0260 50 POP 0261 50 POP 0262 60 PUSH1 0x40 0264 51 MLOAD 0265 80 DUP1 0266 91 SWAP2 0267 03 SUB 0268 90 SWAP1 0269 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0256 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] // @0269 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_026A: // Incoming jump from 0x0060, if 0x081812fc == stack[-1] // Inputs[1] { @026B msg.value } 026A 5B JUMPDEST 026B 34 CALLVALUE 026C 80 DUP1 026D 15 ISZERO 026E 61 PUSH2 0x0276 0271 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026B stack[0] = msg.value } // Block ends with conditional jump to 0x0276, if !msg.value label_0272: // Incoming jump from 0x0271, if not !msg.value // Inputs[1] { @0275 memory[0x00:0x00] } 0272 60 PUSH1 0x00 0274 80 DUP1 0275 FD *REVERT // Stack delta = +0 // Outputs[1] { @0275 revert(memory[0x00:0x00]); } // Block terminates label_0276: // Incoming jump from 0x0271, if !msg.value // Inputs[1] { @027D msg.data[0x04:0x24] } 0276 5B JUMPDEST 0277 50 POP 0278 61 PUSH2 0x0282 027B 60 PUSH1 0x04 027D 35 CALLDATALOAD 027E 61 PUSH2 0x078f 0281 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0278 stack[-1] = 0x0282 // @027D stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x078f, returns to 0x0282 label_0282: // Incoming return from call to 0x0BF4 at 0x043F // Incoming return from call to 0x078F at 0x0281 // Incoming return from call to 0x0D01 at 0x04AB // Incoming return from call to 0x0B0B at 0x03CD // Inputs[4] // { // @0286 memory[0x40:0x60] // @0290 stack[-1] // @0294 memory[0x40:0x60] // @029D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0282 5B JUMPDEST 0283 60 PUSH1 0x40 0285 80 DUP1 0286 51 MLOAD 0287 60 PUSH1 0x01 0289 60 PUSH1 0xa0 028B 60 PUSH1 0x02 028D 0A EXP 028E 03 SUB 028F 90 SWAP1 0290 92 SWAP3 0291 16 AND 0292 82 DUP3 0293 52 MSTORE 0294 51 MLOAD 0295 90 SWAP1 0296 81 DUP2 0297 90 SWAP1 0298 03 SUB 0299 60 PUSH1 0x20 029B 01 ADD 029C 90 SWAP1 029D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0293 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0x02 ** 0xa0 - 0x01 // @029D return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_029E: // Incoming jump from 0x006B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @029F msg.value } 029E 5B JUMPDEST 029F 34 CALLVALUE 02A0 80 DUP1 02A1 15 ISZERO 02A2 61 PUSH2 0x02aa 02A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @029F stack[0] = msg.value } // Block ends with conditional jump to 0x02aa, if !msg.value label_02A6: // Incoming jump from 0x02A5, if not !msg.value // Inputs[1] { @02A9 memory[0x00:0x00] } 02A6 60 PUSH1 0x00 02A8 80 DUP1 02A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A9 revert(memory[0x00:0x00]); } // Block terminates label_02AA: // Incoming jump from 0x02A5, if !msg.value // Inputs[2] // { // @02B9 msg.data[0x04:0x24] // @02BD msg.data[0x24:0x44] // } 02AA 5B JUMPDEST 02AB 50 POP 02AC 61 PUSH2 0x01de 02AF 60 PUSH1 0x01 02B1 60 PUSH1 0xa0 02B3 60 PUSH1 0x02 02B5 0A EXP 02B6 03 SUB 02B7 60 PUSH1 0x04 02B9 35 CALLDATALOAD 02BA 16 AND 02BB 60 PUSH1 0x24 02BD 35 CALLDATALOAD 02BE 61 PUSH2 0x07c1 02C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02AC stack[-1] = 0x01de // @02BA stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // @02BD stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x07c1, returns to 0x01DE label_02C2: // Incoming jump from 0x0076, if 0x18160ddd == stack[-1] // Inputs[1] { @02C3 msg.value } 02C2 5B JUMPDEST 02C3 34 CALLVALUE 02C4 80 DUP1 02C5 15 ISZERO 02C6 61 PUSH2 0x02ce 02C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ce, if !msg.value label_02CA: // Incoming jump from 0x02C9, if not !msg.value // Inputs[1] { @02CD memory[0x00:0x00] } 02CA 60 PUSH1 0x00 02CC 80 DUP1 02CD FD *REVERT // Stack delta = +0 // Outputs[1] { @02CD revert(memory[0x00:0x00]); } // Block terminates label_02CE: // Incoming jump from 0x02C9, if !msg.value 02CE 5B JUMPDEST 02CF 50 POP 02D0 61 PUSH2 0x02d7 02D3 61 PUSH2 0x086a 02D6 56 *JUMP // Stack delta = +0 // Outputs[1] { @02D0 stack[-1] = 0x02d7 } // Block ends with call to 0x086a, returns to 0x02D7 label_02D7: // Incoming return from call to 0x0B47 at 0x040F // Incoming return from call to 0x086A at 0x02D6 // Incoming return from call to 0x0C1E at 0x0460 // Incoming return from call to 0x0A86 at 0x0394 // Inputs[4] // { // @02DB memory[0x40:0x60] // @02DC stack[-1] // @02DF memory[0x40:0x60] // @02E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 02D7 5B JUMPDEST 02D8 60 PUSH1 0x40 02DA 80 DUP1 02DB 51 MLOAD 02DC 91 SWAP2 02DD 82 DUP3 02DE 52 MSTORE 02DF 51 MLOAD 02E0 90 SWAP1 02E1 81 DUP2 02E2 90 SWAP1 02E3 03 SUB 02E4 60 PUSH1 0x20 02E6 01 ADD 02E7 90 SWAP1 02E8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02E8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_02E9: // Incoming jump from 0x0081, if 0x23b872dd == stack[-1] // Inputs[1] { @02EA msg.value } 02E9 5B JUMPDEST 02EA 34 CALLVALUE 02EB 80 DUP1 02EC 15 ISZERO 02ED 61 PUSH2 0x02f5 02F0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02EA stack[0] = msg.value } // Block ends with conditional jump to 0x02f5, if !msg.value label_02F1: // Incoming jump from 0x02F0, if not !msg.value // Inputs[1] { @02F4 memory[0x00:0x00] } 02F1 60 PUSH1 0x00 02F3 80 DUP1 02F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F4 revert(memory[0x00:0x00]); } // Block terminates label_02F5: // Incoming jump from 0x02F0, if !msg.value // Inputs[3] // { // @0304 msg.data[0x04:0x24] // @030A msg.data[0x24:0x44] // @030E msg.data[0x44:0x64] // } 02F5 5B JUMPDEST 02F6 50 POP 02F7 61 PUSH2 0x01de 02FA 60 PUSH1 0x01 02FC 60 PUSH1 0xa0 02FE 60 PUSH1 0x02 0300 0A EXP 0301 03 SUB 0302 60 PUSH1 0x04 0304 35 CALLDATALOAD 0305 81 DUP2 0306 16 AND 0307 90 SWAP1 0308 60 PUSH1 0x24 030A 35 CALLDATALOAD 030B 16 AND 030C 60 PUSH1 0x44 030E 35 CALLDATALOAD 030F 61 PUSH2 0x0870 0312 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F7 stack[-1] = 0x01de // @0307 stack[0] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @030B stack[1] = msg.data[0x24:0x44] & 0x02 ** 0xa0 - 0x01 // @030E stack[2] = msg.data[0x44:0x64] // } // Block ends with call to 0x0870, returns to 0x01DE label_0313: // Incoming jump from 0x008C, if 0x2cb2f52e == stack[-1] // Inputs[1] { @0314 msg.value } 0313 5B JUMPDEST 0314 34 CALLVALUE 0315 80 DUP1 0316 15 ISZERO 0317 61 PUSH2 0x031f 031A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0314 stack[0] = msg.value } // Block ends with conditional jump to 0x031f, if !msg.value label_031B: // Incoming jump from 0x031A, if not !msg.value // Inputs[1] { @031E memory[0x00:0x00] } 031B 60 PUSH1 0x00 031D 80 DUP1 031E FD *REVERT // Stack delta = +0 // Outputs[1] { @031E revert(memory[0x00:0x00]); } // Block terminates label_031F: // Incoming jump from 0x031A, if !msg.value // Inputs[6] // { // @0324 memory[0x40:0x60] // @032C msg.data[0x24:0x44] // @0330 msg.data[msg.data[0x24:0x44] + 0x04:msg.data[0x24:0x44] + 0x04 + 0x20] // @0349 msg.data[0x04:0x24] // @034B msg.data.length // @0360 msg.data[0x24 + msg.data[0x24:0x44]:0x24 + msg.data[0x24:0x44] + msg.data[msg.data[0x24:0x44] + 0x04:msg.data[0x24:0x44] + 0x04 + 0x20]] // } 031F 5B JUMPDEST 0320 50 POP 0321 60 PUSH1 0x40 0323 80 DUP1 0324 51 MLOAD 0325 60 PUSH1 0x20 0327 60 PUSH1 0x04 0329 60 PUSH1 0x24 032B 80 DUP1 032C 35 CALLDATALOAD 032D 82 DUP3 032E 81 DUP2 032F 01 ADD 0330 35 CALLDATALOAD 0331 60 PUSH1 0x1f 0333 81 DUP2 0334 01 ADD 0335 85 DUP6 0336 90 SWAP1 0337 04 DIV 0338 85 DUP6 0339 02 MUL 033A 86 DUP7 033B 01 ADD 033C 85 DUP6 033D 01 ADD 033E 90 SWAP1 033F 96 SWAP7 0340 52 MSTORE 0341 85 DUP6 0342 85 DUP6 0343 52 MSTORE 0344 61 PUSH2 0x01de 0347 95 SWAP6 0348 83 DUP4 0349 35 CALLDATALOAD 034A 95 SWAP6 034B 36 CALLDATASIZE 034C 95 SWAP6 034D 60 PUSH1 0x44 034F 94 SWAP5 0350 91 SWAP2 0351 93 SWAP4 0352 90 SWAP1 0353 91 SWAP2 0354 01 ADD 0355 91 SWAP2 0356 90 SWAP1 0357 81 DUP2 0358 90 SWAP1 0359 84 DUP5 035A 01 ADD 035B 83 DUP4 035C 82 DUP3 035D 80 DUP1 035E 82 DUP3 035F 84 DUP5 0360 37 CALLDATACOPY 0361 50 POP 0362 94 SWAP5 0363 97 SWAP8 0364 50 POP 0365 61 PUSH2 0x08fe 0368 96 SWAP7 0369 50 POP 036A 50 POP 036B 50 POP 036C 50 POP 036D 50 POP 036E 50 POP 036F 50 POP 0370 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0340 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * ((msg.data[msg.data[0x24:0x44] + 0x04:msg.data[0x24:0x44] + 0x04 + 0x20] + 0x1f) / 0x20) // @0343 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[msg.data[0x24:0x44] + 0x04:msg.data[0x24:0x44] + 0x04 + 0x20] // @0347 stack[-1] = 0x01de // @034A stack[0] = msg.data[0x04:0x24] // @0360 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + msg.data[msg.data[0x24:0x44] + 0x04:msg.data[0x24:0x44] + 0x04 + 0x20]] = msg.data[0x24 + msg.data[0x24:0x44]:0x24 + msg.data[0x24:0x44] + msg.data[msg.data[0x24:0x44] + 0x04:msg.data[0x24:0x44] + 0x04 + 0x20]] // @0363 stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08fe label_0371: // Incoming jump from 0x0097, if 0x2f745c59 == stack[-1] // Inputs[1] { @0372 msg.value } 0371 5B JUMPDEST 0372 34 CALLVALUE 0373 80 DUP1 0374 15 ISZERO 0375 61 PUSH2 0x037d 0378 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0372 stack[0] = msg.value } // Block ends with conditional jump to 0x037d, if !msg.value label_0379: // Incoming jump from 0x0378, if not !msg.value // Inputs[1] { @037C memory[0x00:0x00] } 0379 60 PUSH1 0x00 037B 80 DUP1 037C FD *REVERT // Stack delta = +0 // Outputs[1] { @037C revert(memory[0x00:0x00]); } // Block terminates label_037D: // Incoming jump from 0x0378, if !msg.value // Inputs[2] // { // @038C msg.data[0x04:0x24] // @0390 msg.data[0x24:0x44] // } 037D 5B JUMPDEST 037E 50 POP 037F 61 PUSH2 0x02d7 0382 60 PUSH1 0x01 0384 60 PUSH1 0xa0 0386 60 PUSH1 0x02 0388 0A EXP 0389 03 SUB 038A 60 PUSH1 0x04 038C 35 CALLDATALOAD 038D 16 AND 038E 60 PUSH1 0x24 0390 35 CALLDATALOAD 0391 61 PUSH2 0x0a86 0394 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @037F stack[-1] = 0x02d7 // @038D stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // @0390 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0a86, returns to 0x02D7 label_0395: // Incoming jump from 0x00A2, if 0x3af32abf == stack[-1] // Inputs[1] { @0396 msg.value } 0395 5B JUMPDEST 0396 34 CALLVALUE 0397 80 DUP1 0398 15 ISZERO 0399 61 PUSH2 0x03a1 039C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0396 stack[0] = msg.value } // Block ends with conditional jump to 0x03a1, if !msg.value label_039D: // Incoming jump from 0x039C, if not !msg.value // Inputs[1] { @03A0 memory[0x00:0x00] } 039D 60 PUSH1 0x00 039F 80 DUP1 03A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A0 revert(memory[0x00:0x00]); } // Block terminates label_03A1: // Incoming jump from 0x039C, if !msg.value // Inputs[1] { @03B0 msg.data[0x04:0x24] } 03A1 5B JUMPDEST 03A2 50 POP 03A3 61 PUSH2 0x01b0 03A6 60 PUSH1 0x01 03A8 60 PUSH1 0xa0 03AA 60 PUSH1 0x02 03AC 0A EXP 03AD 03 SUB 03AE 60 PUSH1 0x04 03B0 35 CALLDATALOAD 03B1 16 AND 03B2 61 PUSH2 0x0ad3 03B5 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03A3 stack[-1] = 0x01b0 // @03B1 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x0ad3, returns to 0x01B0 label_03B6: // Incoming jump from 0x00AD, if 0x40c1a064 == stack[-1] // Inputs[1] { @03B7 msg.value } 03B6 5B JUMPDEST 03B7 34 CALLVALUE 03B8 80 DUP1 03B9 15 ISZERO 03BA 61 PUSH2 0x03c2 03BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B7 stack[0] = msg.value } // Block ends with conditional jump to 0x03c2, if !msg.value label_03BE: // Incoming jump from 0x03BD, if not !msg.value // Inputs[1] { @03C1 memory[0x00:0x00] } 03BE 60 PUSH1 0x00 03C0 80 DUP1 03C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C1 revert(memory[0x00:0x00]); } // Block terminates label_03C2: // Incoming jump from 0x03BD, if !msg.value // Inputs[1] { @03C9 msg.data[0x04:0x24] } 03C2 5B JUMPDEST 03C3 50 POP 03C4 61 PUSH2 0x0282 03C7 60 PUSH1 0x04 03C9 35 CALLDATALOAD 03CA 61 PUSH2 0x0b0b 03CD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03C4 stack[-1] = 0x0282 // @03C9 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0b0b, returns to 0x0282 label_03CE: // Incoming jump from 0x00B8, if 0x42842e0e == stack[-1] // Inputs[1] { @03CF msg.value } 03CE 5B JUMPDEST 03CF 34 CALLVALUE 03D0 80 DUP1 03D1 15 ISZERO 03D2 61 PUSH2 0x03da 03D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CF stack[0] = msg.value } // Block ends with conditional jump to 0x03da, if !msg.value label_03D6: // Incoming jump from 0x03D5, if not !msg.value // Inputs[1] { @03D9 memory[0x00:0x00] } 03D6 60 PUSH1 0x00 03D8 80 DUP1 03D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D9 revert(memory[0x00:0x00]); } // Block terminates label_03DA: // Incoming jump from 0x03D5, if !msg.value // Inputs[3] // { // @03E9 msg.data[0x04:0x24] // @03EF msg.data[0x24:0x44] // @03F3 msg.data[0x44:0x64] // } 03DA 5B JUMPDEST 03DB 50 POP 03DC 61 PUSH2 0x01de 03DF 60 PUSH1 0x01 03E1 60 PUSH1 0xa0 03E3 60 PUSH1 0x02 03E5 0A EXP 03E6 03 SUB 03E7 60 PUSH1 0x04 03E9 35 CALLDATALOAD 03EA 81 DUP2 03EB 16 AND 03EC 90 SWAP1 03ED 60 PUSH1 0x24 03EF 35 CALLDATALOAD 03F0 16 AND 03F1 60 PUSH1 0x44 03F3 35 CALLDATALOAD 03F4 61 PUSH2 0x0b26 03F7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03DC stack[-1] = 0x01de // @03EC stack[0] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @03F0 stack[1] = msg.data[0x24:0x44] & 0x02 ** 0xa0 - 0x01 // @03F3 stack[2] = msg.data[0x44:0x64] // } // Block ends with unconditional jump to 0x0b26 label_03F8: // Incoming jump from 0x00C3, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @03F9 msg.value } 03F8 5B JUMPDEST 03F9 34 CALLVALUE 03FA 80 DUP1 03FB 15 ISZERO 03FC 61 PUSH2 0x0404 03FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0404, if !msg.value label_0400: // Incoming jump from 0x03FF, if not !msg.value // Inputs[1] { @0403 memory[0x00:0x00] } 0400 60 PUSH1 0x00 0402 80 DUP1 0403 FD *REVERT // Stack delta = +0 // Outputs[1] { @0403 revert(memory[0x00:0x00]); } // Block terminates label_0404: // Incoming jump from 0x03FF, if !msg.value // Inputs[1] { @040B msg.data[0x04:0x24] } 0404 5B JUMPDEST 0405 50 POP 0406 61 PUSH2 0x02d7 0409 60 PUSH1 0x04 040B 35 CALLDATALOAD 040C 61 PUSH2 0x0b47 040F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0406 stack[-1] = 0x02d7 // @040B stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0b47, returns to 0x02D7 label_0410: // Incoming jump from 0x00CE, if 0x6297c16c == stack[-1] // Inputs[1] { @0411 msg.value } 0410 5B JUMPDEST 0411 34 CALLVALUE 0412 80 DUP1 0413 15 ISZERO 0414 61 PUSH2 0x041c 0417 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0411 stack[0] = msg.value } // Block ends with conditional jump to 0x041c, if !msg.value label_0418: // Incoming jump from 0x0417, if not !msg.value // Inputs[1] { @041B memory[0x00:0x00] } 0418 60 PUSH1 0x00 041A 80 DUP1 041B FD *REVERT // Stack delta = +0 // Outputs[1] { @041B revert(memory[0x00:0x00]); } // Block terminates label_041C: // Incoming jump from 0x0417, if !msg.value // Inputs[1] { @0423 msg.data[0x04:0x24] } 041C 5B JUMPDEST 041D 50 POP 041E 61 PUSH2 0x01de 0421 60 PUSH1 0x04 0423 35 CALLDATALOAD 0424 61 PUSH2 0x0b7c 0427 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @041E stack[-1] = 0x01de // @0423 stack[0] = msg.data[0x04:0x24] // } // Block ends with unconditional jump to 0x0b7c label_0428: // Incoming jump from 0x00D9, if 0x6352211e == stack[-1] // Inputs[1] { @0429 msg.value } 0428 5B JUMPDEST 0429 34 CALLVALUE 042A 80 DUP1 042B 15 ISZERO 042C 61 PUSH2 0x0434 042F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0429 stack[0] = msg.value } // Block ends with conditional jump to 0x0434, if !msg.value label_0430: // Incoming jump from 0x042F, if not !msg.value // Inputs[1] { @0433 memory[0x00:0x00] } 0430 60 PUSH1 0x00 0432 80 DUP1 0433 FD *REVERT // Stack delta = +0 // Outputs[1] { @0433 revert(memory[0x00:0x00]); } // Block terminates label_0434: // Incoming jump from 0x042F, if !msg.value // Inputs[1] { @043B msg.data[0x04:0x24] } 0434 5B JUMPDEST 0435 50 POP 0436 61 PUSH2 0x0282 0439 60 PUSH1 0x04 043B 35 CALLDATALOAD 043C 61 PUSH2 0x0bf4 043F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0436 stack[-1] = 0x0282 // @043B stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0bf4, returns to 0x0282 label_0440: // Incoming jump from 0x00E4, if 0x70a08231 == stack[-1] // Inputs[1] { @0441 msg.value } 0440 5B JUMPDEST 0441 34 CALLVALUE 0442 80 DUP1 0443 15 ISZERO 0444 61 PUSH2 0x044c 0447 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0441 stack[0] = msg.value } // Block ends with conditional jump to 0x044c, if !msg.value label_0448: // Incoming jump from 0x0447, if not !msg.value // Inputs[1] { @044B memory[0x00:0x00] } 0448 60 PUSH1 0x00 044A 80 DUP1 044B FD *REVERT // Stack delta = +0 // Outputs[1] { @044B revert(memory[0x00:0x00]); } // Block terminates label_044C: // Incoming jump from 0x0447, if !msg.value // Inputs[1] { @045B msg.data[0x04:0x24] } 044C 5B JUMPDEST 044D 50 POP 044E 61 PUSH2 0x02d7 0451 60 PUSH1 0x01 0453 60 PUSH1 0xa0 0455 60 PUSH1 0x02 0457 0A EXP 0458 03 SUB 0459 60 PUSH1 0x04 045B 35 CALLDATALOAD 045C 16 AND 045D 61 PUSH2 0x0c1e 0460 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @044E stack[-1] = 0x02d7 // @045C stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x0c1e, returns to 0x02D7 label_0461: // Incoming jump from 0x00EF, if 0x715018a6 == stack[-1] // Inputs[1] { @0462 msg.value } 0461 5B JUMPDEST 0462 34 CALLVALUE 0463 80 DUP1 0464 15 ISZERO 0465 61 PUSH2 0x046d 0468 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0462 stack[0] = msg.value } // Block ends with conditional jump to 0x046d, if !msg.value label_0469: // Incoming jump from 0x0468, if not !msg.value // Inputs[1] { @046C memory[0x00:0x00] } 0469 60 PUSH1 0x00 046B 80 DUP1 046C FD *REVERT // Stack delta = +0 // Outputs[1] { @046C revert(memory[0x00:0x00]); } // Block terminates label_046D: // Incoming jump from 0x0468, if !msg.value 046D 5B JUMPDEST 046E 50 POP 046F 61 PUSH2 0x01de 0472 61 PUSH2 0x0c51 0475 56 *JUMP // Stack delta = +0 // Outputs[1] { @046F stack[-1] = 0x01de } // Block ends with call to 0x0c51, returns to 0x01DE label_0476: // Incoming jump from 0x00FA, if 0x8ab1d681 == stack[-1] // Inputs[1] { @0477 msg.value } 0476 5B JUMPDEST 0477 34 CALLVALUE 0478 80 DUP1 0479 15 ISZERO 047A 61 PUSH2 0x0482 047D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0477 stack[0] = msg.value } // Block ends with conditional jump to 0x0482, if !msg.value label_047E: // Incoming jump from 0x047D, if not !msg.value // Inputs[1] { @0481 memory[0x00:0x00] } 047E 60 PUSH1 0x00 0480 80 DUP1 0481 FD *REVERT // Stack delta = +0 // Outputs[1] { @0481 revert(memory[0x00:0x00]); } // Block terminates label_0482: // Incoming jump from 0x047D, if !msg.value // Inputs[1] { @0491 msg.data[0x04:0x24] } 0482 5B JUMPDEST 0483 50 POP 0484 61 PUSH2 0x01de 0487 60 PUSH1 0x01 0489 60 PUSH1 0xa0 048B 60 PUSH1 0x02 048D 0A EXP 048E 03 SUB 048F 60 PUSH1 0x04 0491 35 CALLDATALOAD 0492 16 AND 0493 61 PUSH2 0x0cae 0496 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0484 stack[-1] = 0x01de // @0492 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x0cae, returns to 0x01DE label_0497: // Incoming jump from 0x0105, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0498 msg.value } 0497 5B JUMPDEST 0498 34 CALLVALUE 0499 80 DUP1 049A 15 ISZERO 049B 61 PUSH2 0x04a3 049E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0498 stack[0] = msg.value } // Block ends with conditional jump to 0x04a3, if !msg.value label_049F: // Incoming jump from 0x049E, if not !msg.value // Inputs[1] { @04A2 memory[0x00:0x00] } 049F 60 PUSH1 0x00 04A1 80 DUP1 04A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A2 revert(memory[0x00:0x00]); } // Block terminates label_04A3: // Incoming jump from 0x049E, if !msg.value 04A3 5B JUMPDEST 04A4 50 POP 04A5 61 PUSH2 0x0282 04A8 61 PUSH2 0x0d01 04AB 56 *JUMP // Stack delta = +0 // Outputs[1] { @04A5 stack[-1] = 0x0282 } // Block ends with call to 0x0d01, returns to 0x0282 label_04AC: // Incoming jump from 0x0110, if 0x8f32d59b == stack[-1] // Inputs[1] { @04AD msg.value } 04AC 5B JUMPDEST 04AD 34 CALLVALUE 04AE 80 DUP1 04AF 15 ISZERO 04B0 61 PUSH2 0x04b8 04B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AD stack[0] = msg.value } // Block ends with conditional jump to 0x04b8, if !msg.value label_04B4: // Incoming jump from 0x04B3, if not !msg.value // Inputs[1] { @04B7 memory[0x00:0x00] } 04B4 60 PUSH1 0x00 04B6 80 DUP1 04B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B7 revert(memory[0x00:0x00]); } // Block terminates label_04B8: // Incoming jump from 0x04B3, if !msg.value 04B8 5B JUMPDEST 04B9 50 POP 04BA 61 PUSH2 0x01b0 04BD 61 PUSH2 0x0d10 04C0 56 *JUMP // Stack delta = +0 // Outputs[1] { @04BA stack[-1] = 0x01b0 } // Block ends with call to 0x0d10, returns to 0x01B0 label_04C1: // Incoming jump from 0x011B, if 0x95d89b41 == stack[-1] // Inputs[1] { @04C2 msg.value } 04C1 5B JUMPDEST 04C2 34 CALLVALUE 04C3 80 DUP1 04C4 15 ISZERO 04C5 61 PUSH2 0x04cd 04C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C2 stack[0] = msg.value } // Block ends with conditional jump to 0x04cd, if !msg.value label_04C9: // Incoming jump from 0x04C8, if not !msg.value // Inputs[1] { @04CC memory[0x00:0x00] } 04C9 60 PUSH1 0x00 04CB 80 DUP1 04CC FD *REVERT // Stack delta = +0 // Outputs[1] { @04CC revert(memory[0x00:0x00]); } // Block terminates label_04CD: // Incoming jump from 0x04C8, if !msg.value 04CD 5B JUMPDEST 04CE 50 POP 04CF 61 PUSH2 0x01f5 04D2 61 PUSH2 0x0d21 04D5 56 *JUMP // Stack delta = +0 // Outputs[1] { @04CF stack[-1] = 0x01f5 } // Block ends with call to 0x0d21, returns to 0x01F5 label_04D6: // Incoming jump from 0x0126, if 0xa22cb465 == stack[-1] // Inputs[1] { @04D7 msg.value } 04D6 5B JUMPDEST 04D7 34 CALLVALUE 04D8 80 DUP1 04D9 15 ISZERO 04DA 61 PUSH2 0x04e2 04DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D7 stack[0] = msg.value } // Block ends with conditional jump to 0x04e2, if !msg.value label_04DE: // Incoming jump from 0x04DD, if not !msg.value // Inputs[1] { @04E1 memory[0x00:0x00] } 04DE 60 PUSH1 0x00 04E0 80 DUP1 04E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E1 revert(memory[0x00:0x00]); } // Block terminates label_04E2: // Incoming jump from 0x04DD, if !msg.value // Inputs[2] // { // @04F1 msg.data[0x04:0x24] // @04F5 msg.data[0x24:0x44] // } 04E2 5B JUMPDEST 04E3 50 POP 04E4 61 PUSH2 0x01de 04E7 60 PUSH1 0x01 04E9 60 PUSH1 0xa0 04EB 60 PUSH1 0x02 04ED 0A EXP 04EE 03 SUB 04EF 60 PUSH1 0x04 04F1 35 CALLDATALOAD 04F2 16 AND 04F3 60 PUSH1 0x24 04F5 35 CALLDATALOAD 04F6 15 ISZERO 04F7 15 ISZERO 04F8 61 PUSH2 0x0d82 04FB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04E4 stack[-1] = 0x01de // @04F2 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // @04F7 stack[1] = !!msg.data[0x24:0x44] // } // Block ends with call to 0x0d82, returns to 0x01DE label_04FC: // Incoming jump from 0x0131, if 0xb85ecf93 == stack[-1] // Inputs[1] { @04FD msg.value } 04FC 5B JUMPDEST 04FD 34 CALLVALUE 04FE 80 DUP1 04FF 15 ISZERO 0500 61 PUSH2 0x0508 0503 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04FD stack[0] = msg.value } // Block ends with conditional jump to 0x0508, if !msg.value label_0504: // Incoming jump from 0x0503, if not !msg.value // Inputs[1] { @0507 memory[0x00:0x00] } 0504 60 PUSH1 0x00 0506 80 DUP1 0507 FD *REVERT // Stack delta = +0 // Outputs[1] { @0507 revert(memory[0x00:0x00]); } // Block terminates label_0508: // Incoming jump from 0x0503, if !msg.value // Inputs[5] // { // @050D memory[0x40:0x60] // @0513 msg.data[0x04:0x24] // @0517 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @052A msg.data.length // @0540 msg.data[0x24 + msg.data[0x04:0x24]:0x24 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] * 0x20] // } 0508 5B JUMPDEST 0509 50 POP 050A 60 PUSH1 0x40 050C 80 DUP1 050D 51 MLOAD 050E 60 PUSH1 0x20 0510 60 PUSH1 0x04 0512 80 DUP1 0513 35 CALLDATALOAD 0514 80 DUP1 0515 82 DUP3 0516 01 ADD 0517 35 CALLDATALOAD 0518 83 DUP4 0519 81 DUP2 051A 02 MUL 051B 80 DUP1 051C 86 DUP7 051D 01 ADD 051E 85 DUP6 051F 01 ADD 0520 90 SWAP1 0521 96 SWAP7 0522 52 MSTORE 0523 80 DUP1 0524 85 DUP6 0525 52 MSTORE 0526 61 PUSH2 0x01de 0529 95 SWAP6 052A 36 CALLDATASIZE 052B 95 SWAP6 052C 93 SWAP4 052D 94 SWAP5 052E 60 PUSH1 0x24 0530 94 SWAP5 0531 93 SWAP4 0532 85 DUP6 0533 01 ADD 0534 92 SWAP3 0535 91 SWAP2 0536 82 DUP3 0537 91 SWAP2 0538 85 DUP6 0539 01 ADD 053A 90 SWAP1 053B 84 DUP5 053C 90 SWAP1 053D 80 DUP1 053E 82 DUP3 053F 84 DUP5 0540 37 CALLDATACOPY 0541 50 POP 0542 94 SWAP5 0543 97 SWAP8 0544 50 POP 0545 61 PUSH2 0x0e06 0548 96 SWAP7 0549 50 POP 054A 50 POP 054B 50 POP 054C 50 POP 054D 50 POP 054E 50 POP 054F 50 POP 0550 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0522 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] * 0x20 // @0525 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0529 stack[-1] = 0x01de // @0540 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] * 0x20] = msg.data[0x24 + msg.data[0x04:0x24]:0x24 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] * 0x20] // @0543 stack[0] = memory[0x40:0x60] // } // Block ends with call to 0x0e06, returns to 0x01DE label_0551: // Incoming jump from 0x013C, if 0xb88d4fde == stack[-1] // Inputs[1] { @0552 msg.value } 0551 5B JUMPDEST 0552 34 CALLVALUE 0553 80 DUP1 0554 15 ISZERO 0555 61 PUSH2 0x055d 0558 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0552 stack[0] = msg.value } // Block ends with conditional jump to 0x055d, if !msg.value label_0559: // Incoming jump from 0x0558, if not !msg.value // Inputs[1] { @055C memory[0x00:0x00] } 0559 60 PUSH1 0x00 055B 80 DUP1 055C FD *REVERT // Stack delta = +0 // Outputs[1] { @055C revert(memory[0x00:0x00]); } // Block terminates label_055D: // Incoming jump from 0x0558, if !msg.value // Inputs[8] // { // @0562 memory[0x40:0x60] // @0569 msg.data[0x64:0x84] // @056F msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] // @058F msg.data[0x04:0x24] // @0596 msg.data[0x24:0x44] // @059D msg.data[0x44:0x64] // @059F msg.data.length // @05AF msg.data[0x24 + msg.data[0x64:0x84]:0x24 + msg.data[0x64:0x84] + msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20]] // } 055D 5B JUMPDEST 055E 50 POP 055F 60 PUSH1 0x40 0561 80 DUP1 0562 51 MLOAD 0563 60 PUSH1 0x20 0565 60 PUSH1 0x1f 0567 60 PUSH1 0x64 0569 35 CALLDATALOAD 056A 60 PUSH1 0x04 056C 81 DUP2 056D 81 DUP2 056E 01 ADD 056F 35 CALLDATALOAD 0570 92 SWAP3 0571 83 DUP4 0572 01 ADD 0573 84 DUP5 0574 90 SWAP1 0575 04 DIV 0576 84 DUP5 0577 02 MUL 0578 85 DUP6 0579 01 ADD 057A 84 DUP5 057B 01 ADD 057C 90 SWAP1 057D 95 SWAP6 057E 52 MSTORE 057F 81 DUP2 0580 84 DUP5 0581 52 MSTORE 0582 61 PUSH2 0x01de 0585 94 SWAP5 0586 60 PUSH1 0x01 0588 60 PUSH1 0xa0 058A 60 PUSH1 0x02 058C 0A EXP 058D 03 SUB 058E 81 DUP2 058F 35 CALLDATALOAD 0590 81 DUP2 0591 16 AND 0592 95 SWAP6 0593 60 PUSH1 0x24 0595 80 DUP1 0596 35 CALLDATALOAD 0597 90 SWAP1 0598 92 SWAP3 0599 16 AND 059A 95 SWAP6 059B 60 PUSH1 0x44 059D 35 CALLDATALOAD 059E 95 SWAP6 059F 36 CALLDATASIZE 05A0 95 SWAP6 05A1 60 PUSH1 0x84 05A3 94 SWAP5 05A4 01 ADD 05A5 91 SWAP2 05A6 81 DUP2 05A7 90 SWAP1 05A8 84 DUP5 05A9 01 ADD 05AA 83 DUP4 05AB 82 DUP3 05AC 80 DUP1 05AD 82 DUP3 05AE 84 DUP5 05AF 37 CALLDATACOPY 05B0 50 POP 05B1 94 SWAP5 05B2 97 SWAP8 05B3 50 POP 05B4 61 PUSH2 0x0e67 05B7 96 SWAP7 05B8 50 POP 05B9 50 POP 05BA 50 POP 05BB 50 POP 05BC 50 POP 05BD 50 POP 05BE 50 POP 05BF 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @057E memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * ((msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] + 0x1f) / 0x20) // @0581 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20] // @0585 stack[-1] = 0x01de // @0592 stack[0] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @059A stack[1] = 0x02 ** 0xa0 - 0x01 & msg.data[0x24:0x44] // @059E stack[2] = msg.data[0x44:0x64] // @05AF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20]] = msg.data[0x24 + msg.data[0x64:0x84]:0x24 + msg.data[0x64:0x84] + msg.data[0x04 + msg.data[0x64:0x84]:0x04 + msg.data[0x64:0x84] + 0x20]] // @05B2 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x0e67, returns to 0x01DE label_05C0: // Incoming jump from 0x0147, if 0xc87b56dd == 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 // Inputs[1] { @05D3 msg.data[0x04:0x24] } 05CC 5B JUMPDEST 05CD 50 POP 05CE 61 PUSH2 0x01f5 05D1 60 PUSH1 0x04 05D3 35 CALLDATALOAD 05D4 61 PUSH2 0x0e8f 05D7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05CE stack[-1] = 0x01f5 // @05D3 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0e8f, returns to 0x01F5 label_05D8: // Incoming jump from 0x0152, if 0xd9856c21 == stack[-1] // Inputs[1] { @05D9 msg.value } 05D8 5B JUMPDEST 05D9 34 CALLVALUE 05DA 80 DUP1 05DB 15 ISZERO 05DC 61 PUSH2 0x05e4 05DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D9 stack[0] = msg.value } // Block ends with conditional jump to 0x05e4, if !msg.value label_05E0: // Incoming jump from 0x05DF, if not !msg.value // Inputs[1] { @05E3 memory[0x00:0x00] } 05E0 60 PUSH1 0x00 05E2 80 DUP1 05E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E3 revert(memory[0x00:0x00]); } // Block terminates label_05E4: // Incoming jump from 0x05DF, if !msg.value // Inputs[5] // { // @05E9 memory[0x40:0x60] // @05EF msg.data[0x04:0x24] // @05F3 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @060B msg.data.length // @0620 msg.data[0x24 + msg.data[0x04:0x24]:0x24 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 05E4 5B JUMPDEST 05E5 50 POP 05E6 60 PUSH1 0x40 05E8 80 DUP1 05E9 51 MLOAD 05EA 60 PUSH1 0x20 05EC 60 PUSH1 0x04 05EE 80 DUP1 05EF 35 CALLDATALOAD 05F0 80 DUP1 05F1 82 DUP3 05F2 01 ADD 05F3 35 CALLDATALOAD 05F4 60 PUSH1 0x1f 05F6 81 DUP2 05F7 01 ADD 05F8 84 DUP5 05F9 90 SWAP1 05FA 04 DIV 05FB 84 DUP5 05FC 02 MUL 05FD 85 DUP6 05FE 01 ADD 05FF 84 DUP5 0600 01 ADD 0601 90 SWAP1 0602 95 SWAP6 0603 52 MSTORE 0604 84 DUP5 0605 84 DUP5 0606 52 MSTORE 0607 61 PUSH2 0x01de 060A 94 SWAP5 060B 36 CALLDATASIZE 060C 94 SWAP5 060D 92 SWAP3 060E 93 SWAP4 060F 60 PUSH1 0x24 0611 93 SWAP4 0612 92 SWAP3 0613 84 DUP5 0614 01 ADD 0615 91 SWAP2 0616 90 SWAP1 0617 81 DUP2 0618 90 SWAP1 0619 84 DUP5 061A 01 ADD 061B 83 DUP4 061C 82 DUP3 061D 80 DUP1 061E 82 DUP3 061F 84 DUP5 0620 37 CALLDATACOPY 0621 50 POP 0622 94 SWAP5 0623 97 SWAP8 0624 50 POP 0625 61 PUSH2 0x0f44 0628 96 SWAP7 0629 50 POP 062A 50 POP 062B 50 POP 062C 50 POP 062D 50 POP 062E 50 POP 062F 50 POP 0630 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0603 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * ((msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] + 0x1f) / 0x20) // @0606 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @060A stack[-1] = 0x01de // @0620 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x24 + msg.data[0x04:0x24]:0x24 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @0623 stack[0] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0f44 label_0631: // Incoming jump from 0x015D, if 0xe43252d7 == stack[-1] // Inputs[1] { @0632 msg.value } 0631 5B JUMPDEST 0632 34 CALLVALUE 0633 80 DUP1 0634 15 ISZERO 0635 61 PUSH2 0x063d 0638 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0632 stack[0] = msg.value } // Block ends with conditional jump to 0x063d, if !msg.value label_0639: // Incoming jump from 0x0638, if not !msg.value // Inputs[1] { @063C memory[0x00:0x00] } 0639 60 PUSH1 0x00 063B 80 DUP1 063C FD *REVERT // Stack delta = +0 // Outputs[1] { @063C revert(memory[0x00:0x00]); } // Block terminates label_063D: // Incoming jump from 0x0638, if !msg.value // Inputs[1] { @064C msg.data[0x04:0x24] } 063D 5B JUMPDEST 063E 50 POP 063F 61 PUSH2 0x01de 0642 60 PUSH1 0x01 0644 60 PUSH1 0xa0 0646 60 PUSH1 0x02 0648 0A EXP 0649 03 SUB 064A 60 PUSH1 0x04 064C 35 CALLDATALOAD 064D 16 AND 064E 61 PUSH2 0x0fd6 0651 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @063F stack[-1] = 0x01de // @064D stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x0fd6, returns to 0x01DE label_0652: // Incoming jump from 0x0168, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0653 msg.value } 0652 5B JUMPDEST 0653 34 CALLVALUE 0654 80 DUP1 0655 15 ISZERO 0656 61 PUSH2 0x065e 0659 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0653 stack[0] = msg.value } // Block ends with conditional jump to 0x065e, if !msg.value label_065A: // Incoming jump from 0x0659, if not !msg.value // Inputs[1] { @065D memory[0x00:0x00] } 065A 60 PUSH1 0x00 065C 80 DUP1 065D FD *REVERT // Stack delta = +0 // Outputs[1] { @065D revert(memory[0x00:0x00]); } // Block terminates label_065E: // Incoming jump from 0x0659, if !msg.value // Inputs[2] // { // @066D msg.data[0x04:0x24] // @0673 msg.data[0x24:0x44] // } 065E 5B JUMPDEST 065F 50 POP 0660 61 PUSH2 0x01b0 0663 60 PUSH1 0x01 0665 60 PUSH1 0xa0 0667 60 PUSH1 0x02 0669 0A EXP 066A 03 SUB 066B 60 PUSH1 0x04 066D 35 CALLDATALOAD 066E 81 DUP2 066F 16 AND 0670 90 SWAP1 0671 60 PUSH1 0x24 0673 35 CALLDATALOAD 0674 16 AND 0675 61 PUSH2 0x1029 0678 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0660 stack[-1] = 0x01b0 // @0670 stack[0] = 0x02 ** 0xa0 - 0x01 & msg.data[0x04:0x24] // @0674 stack[1] = msg.data[0x24:0x44] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x1029, returns to 0x01B0 label_0679: // Incoming jump from 0x0173, if 0xf2fde38b == stack[-1] // Inputs[1] { @067A msg.value } 0679 5B JUMPDEST 067A 34 CALLVALUE 067B 80 DUP1 067C 15 ISZERO 067D 61 PUSH2 0x0685 0680 57 *JUMPI // Stack delta = +1 // Outputs[1] { @067A stack[0] = msg.value } // Block ends with conditional jump to 0x0685, if !msg.value label_0681: // Incoming jump from 0x0680, if not !msg.value // Inputs[1] { @0684 memory[0x00:0x00] } 0681 60 PUSH1 0x00 0683 80 DUP1 0684 FD *REVERT // Stack delta = +0 // Outputs[1] { @0684 revert(memory[0x00:0x00]); } // Block terminates label_0685: // Incoming jump from 0x0680, if !msg.value // Inputs[1] { @0694 msg.data[0x04:0x24] } 0685 5B JUMPDEST 0686 50 POP 0687 61 PUSH2 0x01de 068A 60 PUSH1 0x01 068C 60 PUSH1 0xa0 068E 60 PUSH1 0x02 0690 0A EXP 0691 03 SUB 0692 60 PUSH1 0x04 0694 35 CALLDATALOAD 0695 16 AND 0696 61 PUSH2 0x1057 0699 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0687 stack[-1] = 0x01de // @0695 stack[0] = msg.data[0x04:0x24] & 0x02 ** 0xa0 - 0x01 // } // Block ends with call to 0x1057, returns to 0x01DE label_069A: // Incoming call from 0x01AF, returns to 0x01B0 // Inputs[4] // { // @06B9 stack[-1] // @06C8 memory[0x00:0x40] // @06C9 storage[keccak256(memory[0x00:0x40])] // @06CE stack[-2] // } 069A 5B JUMPDEST 069B 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 06B8 19 NOT 06B9 81 DUP2 06BA 16 AND 06BB 60 PUSH1 0x00 06BD 90 SWAP1 06BE 81 DUP2 06BF 52 MSTORE 06C0 60 PUSH1 0x20 06C2 81 DUP2 06C3 90 SWAP1 06C4 52 MSTORE 06C5 60 PUSH1 0x40 06C7 90 SWAP1 06C8 20 SHA3 06C9 54 SLOAD 06CA 60 PUSH1 0xff 06CC 16 AND 06CD 5B JUMPDEST 06CE 91 SWAP2 06CF 90 SWAP1 06D0 50 POP 06D1 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @06BF memory[0x00:0x20] = stack[-1] & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @06C4 memory[0x20:0x40] = 0x00 // @06CE stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_06D2: // Incoming call from 0x01DD, returns to 0x01DE 06D2 5B JUMPDEST 06D3 61 PUSH2 0x06da 06D6 61 PUSH2 0x0d10 06D9 56 *JUMP // Stack delta = +1 // Outputs[1] { @06D3 stack[0] = 0x06da } // Block ends with call to 0x0d10, returns to 0x06DA label_06DA: // Incoming return from call to 0x0D10 at 0x06D9 // Inputs[1] { @06DB stack[-1] } 06DA 5B JUMPDEST 06DB 15 ISZERO 06DC 15 ISZERO 06DD 61 PUSH2 0x06e5 06E0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06e5, if !!stack[-1] label_06E1: // Incoming jump from 0x06E0, if not !!stack[-1] // Inputs[1] { @06E4 memory[0x00:0x00] } 06E1 60 PUSH1 0x00 06E3 80 DUP1 06E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E4 revert(memory[0x00:0x00]); } // Block terminates label_06E5: // Incoming jump from 0x06E0, if !!stack[-1] // Inputs[3] // { // @06E9 storage[0x0e] // @06EE stack[-1] // @06F7 stack[-2] // } 06E5 5B JUMPDEST 06E6 60 PUSH1 0x0e 06E8 80 DUP1 06E9 54 SLOAD 06EA 60 PUSH1 0xff 06EC 19 NOT 06ED 16 AND 06EE 91 SWAP2 06EF 15 ISZERO 06F0 15 ISZERO 06F1 91 SWAP2 06F2 90 SWAP1 06F3 91 SWAP2 06F4 17 OR 06F5 90 SWAP1 06F6 55 SSTORE 06F7 56 *JUMP // Stack delta = -2 // Outputs[1] { @06F6 storage[0x0e] = !!stack[-1] | (~0xff & storage[0x0e]) } // Block ends with unconditional jump to stack[-2] label_06F8: // Incoming call from 0x01F4, returns to 0x01F5 // Inputs[2] // { // @06FC storage[0x09] // @0700 memory[0x40:0x60] // } 06F8 5B JUMPDEST 06F9 60 PUSH1 0x09 06FB 80 DUP1 06FC 54 SLOAD 06FD 60 PUSH1 0x40 06FF 80 DUP1 0700 51 MLOAD 0701 60 PUSH1 0x20 0703 60 PUSH1 0x1f 0705 60 PUSH1 0x02 0707 60 PUSH1 0x00 0709 19 NOT 070A 61 PUSH2 0x0100 070D 60 PUSH1 0x01 070F 88 DUP9 0710 16 AND 0711 15 ISZERO 0712 02 MUL 0713 01 ADD 0714 90 SWAP1 0715 95 SWAP6 0716 16 AND 0717 94 SWAP5 0718 90 SWAP1 0719 94 SWAP5 071A 04 DIV 071B 93 SWAP4 071C 84 DUP5 071D 01 ADD 071E 81 DUP2 071F 90 SWAP1 0720 04 DIV 0721 81 DUP2 0722 02 MUL 0723 82 DUP3 0724 01 ADD 0725 81 DUP2 0726 01 ADD 0727 90 SWAP1 0728 92 SWAP3 0729 52 MSTORE 072A 82 DUP3 072B 81 DUP2 072C 52 MSTORE 072D 60 PUSH1 0x60 072F 93 SWAP4 0730 90 SWAP1 0731 92 SWAP3 0732 90 SWAP1 0733 91 SWAP2 0734 83 DUP4 0735 01 ADD 0736 82 DUP3 0737 82 DUP3 0738 80 DUP1 0739 15 ISZERO 073A 61 PUSH2 0x0784 073D 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0729 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @072C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @072F stack[0] = 0x60 // @0731 stack[1] = memory[0x40:0x60] // @0732 stack[3] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0733 stack[2] = 0x09 // @0735 stack[4] = memory[0x40:0x60] + 0x20 // @0736 stack[5] = 0x09 // @0737 stack[6] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0784, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) label_073E: // Incoming jump from 0x073D, if not !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @073E stack[-1] } 073E 80 DUP1 073F 60 PUSH1 0x1f 0741 10 LT 0742 61 PUSH2 0x0759 0745 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0759, if 0x1f < stack[-1] label_0746: // Incoming jump from 0x0745, if not 0x1f < stack[-1] // Inputs[4] // { // @074A stack[-2] // @074B storage[stack[-2]] // @074E stack[-3] // @0750 stack[-1] // } 0746 61 PUSH2 0x0100 0749 80 DUP1 074A 83 DUP4 074B 54 SLOAD 074C 04 DIV 074D 02 MUL 074E 83 DUP4 074F 52 MSTORE 0750 91 SWAP2 0751 60 PUSH1 0x20 0753 01 ADD 0754 91 SWAP2 0755 61 PUSH2 0x0784 0758 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @074F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0754 stack[-1] = stack[-1] // @0754 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0784 label_0759: // Incoming jump from 0x0D6E, if 0x1f < stack[-1] // Incoming jump from 0x0745, if 0x1f < stack[-1] // Inputs[5] // { // @075A stack[-3] // @075B stack[-1] // @075D stack[-2] // @0765 memory[0x00:0x20] // @0769 storage[keccak256(memory[0x00:0x20])] // } 0759 5B JUMPDEST 075A 82 DUP3 075B 01 ADD 075C 91 SWAP2 075D 90 SWAP1 075E 60 PUSH1 0x00 0760 52 MSTORE 0761 60 PUSH1 0x20 0763 60 PUSH1 0x00 0765 20 SHA3 0766 90 SWAP1 0767 5B JUMPDEST 0768 81 DUP2 0769 54 SLOAD 076A 81 DUP2 076B 52 MSTORE 076C 90 SWAP1 076D 60 PUSH1 0x01 076F 01 ADD 0770 90 SWAP1 0771 60 PUSH1 0x20 0773 01 ADD 0774 80 DUP1 0775 83 DUP4 0776 11 GT 0777 61 PUSH2 0x0767 077A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @075C stack[-3] = stack[-3] + stack[-1] // @0760 memory[0x00:0x20] = stack[-2] // @076B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0770 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0773 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0767, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_077B: // Incoming jump from 0x077A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x077A, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @077B stack[-3] // @077C stack[-1] // } 077B 82 DUP3 077C 90 SWAP1 077D 03 SUB 077E 60 PUSH1 0x1f 0780 16 AND 0781 82 DUP3 0782 01 ADD 0783 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0783 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0783 stack[-1] = stack[-3] // } // Block continues label_0784: // Incoming jump from 0x0758 // Incoming jump from 0x0D81 // Incoming jump from 0x073D, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0783 // Incoming jump from 0x0D66, if !((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[3] // { // @078A stack[-7] // @078A stack[-6] // @078D stack[-8] // } 0784 5B JUMPDEST 0785 50 POP 0786 50 POP 0787 50 POP 0788 50 POP 0789 50 POP 078A 90 SWAP1 078B 50 POP 078C 5B JUMPDEST 078D 90 SWAP1 078E 56 *JUMP // Stack delta = -7 // Outputs[1] { @078D stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_078F: // Incoming call from 0x0281, returns to 0x0282 // Incoming call from 0x10CE, returns to 0x10CF // Inputs[1] { @0795 stack[-1] } 078F 5B JUMPDEST 0790 60 PUSH1 0x00 0792 61 PUSH2 0x079a 0795 82 DUP3 0796 61 PUSH2 0x1076 0799 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0790 stack[0] = 0x00 // @0792 stack[1] = 0x079a // @0795 stack[2] = stack[-1] // } // Block ends with call to 0x1076, returns to 0x079A label_079A: // Incoming return from call to 0x1076 at 0x0799 // Inputs[1] { @079B stack[-1] } 079A 5B JUMPDEST 079B 15 ISZERO 079C 15 ISZERO 079D 61 PUSH2 0x07a5 07A0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07a5, if !!stack[-1] label_07A1: // Incoming jump from 0x07A0, if not !!stack[-1] // Inputs[1] { @07A4 memory[0x00:0x00] } 07A1 60 PUSH1 0x00 07A3 80 DUP1 07A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @07A4 revert(memory[0x00:0x00]); } // Block terminates label_07A5: // Incoming jump from 0x07A0, if !!stack[-1] // Inputs[4] // { // @07A9 stack[-2] // @07B4 memory[0x00:0x40] // @07B5 storage[keccak256(memory[0x00:0x40])] // @07BF stack[-3] // } 07A5 5B JUMPDEST 07A6 50 POP 07A7 60 PUSH1 0x00 07A9 90 SWAP1 07AA 81 DUP2 07AB 52 MSTORE 07AC 60 PUSH1 0x02 07AE 60 PUSH1 0x20 07B0 52 MSTORE 07B1 60 PUSH1 0x40 07B3 90 SWAP1 07B4 20 SHA3 07B5 54 SLOAD 07B6 60 PUSH1 0x01 07B8 60 PUSH1 0xa0 07BA 60 PUSH1 0x02 07BC 0A EXP 07BD 03 SUB 07BE 16 AND 07BF 90 SWAP1 07C0 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @07AB memory[0x00:0x20] = stack[-2] // @07B0 memory[0x20:0x40] = 0x02 // @07BF stack[-3] = 0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_07C1: // Incoming call from 0x02C1, returns to 0x01DE // Inputs[1] { @07C7 stack[-1] } 07C1 5B JUMPDEST 07C2 60 PUSH1 0x00 07C4 61 PUSH2 0x07cc 07C7 82 DUP3 07C8 61 PUSH2 0x0bf4 07CB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07C2 stack[0] = 0x00 // @07C4 stack[1] = 0x07cc // @07C7 stack[2] = stack[-1] // } // Block ends with call to 0x0bf4, returns to 0x07CC label_07CC: // Incoming return from call to 0x0BF4 at 0x07CB // Inputs[3] // { // @07CD stack[-1] // @07CD stack[-2] // @07D7 stack[-4] // } 07CC 5B JUMPDEST 07CD 90 SWAP1 07CE 50 POP 07CF 60 PUSH1 0x01 07D1 60 PUSH1 0xa0 07D3 60 PUSH1 0x02 07D5 0A EXP 07D6 03 SUB 07D7 83 DUP4 07D8 81 DUP2 07D9 16 AND 07DA 90 SWAP1 07DB 82 DUP3 07DC 16 AND 07DD 14 EQ 07DE 15 ISZERO 07DF 61 PUSH2 0x07e7 07E2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @07CD stack[-2] = stack[-1] } // Block ends with conditional jump to 0x07e7, if !(stack[-1] & 0x02 ** 0xa0 - 0x01 == 0x02 ** 0xa0 - 0x01 & stack[-4]) label_07E3: // Incoming jump from 0x07E2, if not !(stack[-1] & 0x02 ** 0xa0 - 0x01 == 0x02 ** 0xa0 - 0x01 & stack[-4]) // Inputs[1] { @07E6 memory[0x00:0x00] } 07E3 60 PUSH1 0x00 07E5 80 DUP1 07E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @07E6 revert(memory[0x00:0x00]); } // Block terminates label_07E7: // Incoming jump from 0x07E2, if !(stack[-1] & 0x02 ** 0xa0 - 0x01 == 0x02 ** 0xa0 - 0x01 & stack[-4]) // Inputs[2] // { // @07E8 msg.sender // @07F1 stack[-1] // } 07E7 5B JUMPDEST 07E8 33 CALLER 07E9 60 PUSH1 0x01 07EB 60 PUSH1 0xa0 07ED 60 PUSH1 0x02 07EF 0A EXP 07F0 03 SUB 07F1 82 DUP3 07F2 16 AND 07F3 14 EQ 07F4 80 DUP1 07F5 61 PUSH2 0x0803 07F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07F3 stack[0] = stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender } // Block ends with conditional jump to 0x0803, if stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender label_07F9: // Incoming jump from 0x07F8, if not stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender // Inputs[2] // { // @07FD stack[-2] // @07FE msg.sender // } 07F9 50 POP 07FA 61 PUSH2 0x0803 07FD 81 DUP2 07FE 33 CALLER 07FF 61 PUSH2 0x1029 0802 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07FA stack[-1] = 0x0803 // @07FD stack[0] = stack[-2] // @07FE stack[1] = msg.sender // } // Block ends with call to 0x1029, returns to 0x0803 label_0803: // Incoming jump from 0x07F8, if stack[-1] & 0x02 ** 0xa0 - 0x01 == msg.sender // Incoming return from call to 0x1029 at 0x0802 // Inputs[1] { @0804 stack[-1] } 0803 5B JUMPDEST 0804 15 ISZERO 0805 15 ISZERO 0806 61 PUSH2 0x080e 0809 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x080e, if !!stack[-1] label_080A: // Incoming jump from 0x0809, if not !!stack[-1] // Inputs[1] { @080D memory[0x00:0x00] } 080A 60 PUSH1 0x00 080C 80 DUP1 080D FD *REVERT // Stack delta = +0 // Outputs[1] { @080D revert(memory[0x00:0x00]); } // Block terminates label_080E: // Incoming jump from 0x0809, if !!stack[-1] // Inputs[8] // { // @0811 stack[-2] // @081D memory[0x00:0x40] // @081F storage[keccak256(memory[0x00:0x40])] // @0832 stack[-3] // @083C memory[0x40:0x60] // @0840 stack[-1] // @0865 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0869 stack[-4] // } 080E 5B JUMPDEST 080F 60 PUSH1 0x00 0811 82 DUP3 0812 81 DUP2 0813 52 MSTORE 0814 60 PUSH1 0x02 0816 60 PUSH1 0x20 0818 52 MSTORE 0819 60 PUSH1 0x40 081B 80 DUP1 081C 82 DUP3 081D 20 SHA3 081E 80 DUP1 081F 54 SLOAD 0820 60 PUSH1 0x01 0822 60 PUSH1 0xa0 0824 60 PUSH1 0x02 0826 0A EXP 0827 03 SUB 0828 19 NOT 0829 16 AND 082A 60 PUSH1 0x01 082C 60 PUSH1 0xa0 082E 60 PUSH1 0x02 0830 0A EXP 0831 03 SUB 0832 87 DUP8 0833 81 DUP2 0834 16 AND 0835 91 SWAP2 0836 82 DUP3 0837 17 OR 0838 90 SWAP1 0839 92 SWAP3 083A 55 SSTORE 083B 91 SWAP2 083C 51 MLOAD 083D 85 DUP6 083E 93 SWAP4 083F 91 SWAP2 0840 85 DUP6 0841 16 AND 0842 91 SWAP2 0843 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0864 91 SWAP2 0865 A4 LOG4 0866 50 POP 0867 50 POP 0868 50 POP 0869 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0813 memory[0x00:0x20] = stack[-2] // @0818 memory[0x20:0x40] = 0x02 // @083A storage[keccak256(memory[0x00:0x40])] = (stack[-3] & 0x02 ** 0xa0 - 0x01) | (~(0x02 ** 0xa0 - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0865 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_086A: // Incoming call from 0x0B50, returns to 0x0B51 // Incoming call from 0x02D6, returns to 0x02D7 // Inputs[2] // { // @086D storage[0x07] // @086E stack[-1] // } 086A 5B JUMPDEST 086B 60 PUSH1 0x07 086D 54 SLOAD 086E 90 SWAP1 086F 56 *JUMP // Stack delta = +0 // Outputs[1] { @086E stack[-1] = storage[0x07] } // Block ends with unconditional jump to stack[-1] label_0870: // Incoming call from 0x0312, returns to 0x01DE // Incoming call from 0x0E71, returns to 0x0E72 // Inputs[2] // { // @0874 msg.sender // @0875 stack[-1] // } 0870 5B JUMPDEST 0871 61 PUSH2 0x087a 0874 33 CALLER 0875 82 DUP3 0876 61 PUSH2 0x1093 0879 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0871 stack[0] = 0x087a // @0874 stack[1] = msg.sender // @0875 stack[2] = stack[-1] // } // Block ends with call to 0x1093, returns to 0x087A label_087A: // Incoming return from call to 0x1093 at 0x0879 // Inputs[1] { @087B stack[-1] } 087A 5B JUMPDEST 087B 15 ISZERO 087C 15 ISZERO 087D 61 PUSH2 0x0885 0880 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0885, if !!stack[-1] label_0881: // Incoming jump from 0x0880, if not !!stack[-1] // Inputs[1] { @0884 memory[0x00:0x00] } 0881 60 PUSH1 0x00 0883 80 DUP1 0884 FD *REVERT // Stack delta = +0 // Outputs[1] { @0884 revert(memory[0x00:0x00]); } // Block terminates label_0885: // Incoming jump from 0x0880, if !!stack[-1] // Inputs[1] { @088E stack[-2] } 0885 5B JUMPDEST 0886 60 PUSH1 0x01 0888 60 PUSH1 0xa0 088A 60 PUSH1 0x02 088C 0A EXP 088D 03 SUB 088E 82 DUP3 088F 16 AND 0890 15 ISZERO 0891 15 ISZERO 0892 61 PUSH2 0x089a 0895 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x089a, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) label_0896: // Incoming jump from 0x0895, if not !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @0899 memory[0x00:0x00] } 0896 60 PUSH1 0x00 0898 80 DUP1 0899 FD *REVERT // Stack delta = +0 // Outputs[1] { @0899 revert(memory[0x00:0x00]); } // Block terminates label_089A: // Incoming jump from 0x0895, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[2] // { // @089E stack[-3] // @089F stack[-1] // } 089A 5B JUMPDEST 089B 61 PUSH2 0x08a4 089E 83 DUP4 089F 82 DUP3 08A0 61 PUSH2 0x10f2 08A3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @089B stack[0] = 0x08a4 // @089E stack[1] = stack[-3] // @089F stack[2] = stack[-1] // } // Block ends with call to 0x10f2, returns to 0x08A4 label_08A4: // Incoming return from call to 0x10F2 at 0x08A3 // Inputs[2] // { // @08A8 stack[-3] // @08A9 stack[-1] // } 08A4 5B JUMPDEST 08A5 61 PUSH2 0x08ae 08A8 83 DUP4 08A9 82 DUP3 08AA 61 PUSH2 0x1154 08AD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08A5 stack[0] = 0x08ae // @08A8 stack[1] = stack[-3] // @08A9 stack[2] = stack[-1] // } // Block ends with call to 0x1154, returns to 0x08AE label_08AE: // Incoming return from call to 0x1154 at 0x08AD // Inputs[2] // { // @08B2 stack[-2] // @08B3 stack[-1] // } 08AE 5B JUMPDEST 08AF 61 PUSH2 0x08b8 08B2 82 DUP3 08B3 82 DUP3 08B4 61 PUSH2 0x125b 08B7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08AF stack[0] = 0x08b8 // @08B2 stack[1] = stack[-2] // @08B3 stack[2] = stack[-1] // } // Block ends with call to 0x125b, returns to 0x08B8 label_08B8: // Incoming return from call to 0x125B at 0x08B7 // Inputs[7] // { // @08B9 stack[-1] // @08BA stack[-2] // @08C4 stack[-3] // @08F1 memory[0x40:0x60] // @08F4 memory[0x40:0x60] // @08F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @08FD stack[-4] // } 08B8 5B JUMPDEST 08B9 80 DUP1 08BA 82 DUP3 08BB 60 PUSH1 0x01 08BD 60 PUSH1 0xa0 08BF 60 PUSH1 0x02 08C1 0A EXP 08C2 03 SUB 08C3 16 AND 08C4 84 DUP5 08C5 60 PUSH1 0x01 08C7 60 PUSH1 0xa0 08C9 60 PUSH1 0x02 08CB 0A EXP 08CC 03 SUB 08CD 16 AND 08CE 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 08EF 60 PUSH1 0x40 08F1 51 MLOAD 08F2 60 PUSH1 0x40 08F4 51 MLOAD 08F5 80 DUP1 08F6 91 SWAP2 08F7 03 SUB 08F8 90 SWAP1 08F9 A4 LOG4 08FA 50 POP 08FB 50 POP 08FC 50 POP 08FD 56 *JUMP // Stack delta = -4 // Outputs[1] { @08F9 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_08FE: // Incoming jump from 0x0370 // Inputs[1] { @08FF stack[-2] } 08FE 5B JUMPDEST 08FF 81 DUP2 0900 60 PUSH1 0x00 0902 61 PUSH2 0x090a 0905 82 DUP3 0906 61 PUSH2 0x0bf4 0909 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08FF stack[0] = stack[-2] // @0900 stack[1] = 0x00 // @0902 stack[2] = 0x090a // @0905 stack[3] = stack[-2] // } // Block ends with call to 0x0bf4, returns to 0x090A label_090A: // Incoming return from call to 0x0BF4 at 0x0909 // Inputs[3] // { // @090B stack[-2] // @090B stack[-1] // @0917 msg.sender // } 090A 5B JUMPDEST 090B 90 SWAP1 090C 50 POP 090D 60 PUSH1 0x01 090F 60 PUSH1 0xa0 0911 60 PUSH1 0x02 0913 0A EXP 0914 03 SUB 0915 81 DUP2 0916 16 AND 0917 33 CALLER 0918 14 EQ 0919 61 PUSH2 0x096c 091C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @090B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x096c, if msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 label_091D: // Incoming jump from 0x091C, if not msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 // Inputs[3] // { // @0920 memory[0x40:0x60] // @0962 memory[0x40:0x60] // @096B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 091D 60 PUSH1 0x40 091F 80 DUP1 0920 51 MLOAD 0921 60 PUSH1 0xe5 0923 60 PUSH1 0x02 0925 0A EXP 0926 62 PUSH3 0x461bcd 092A 02 MUL 092B 81 DUP2 092C 52 MSTORE 092D 60 PUSH1 0x20 092F 60 PUSH1 0x04 0931 82 DUP3 0932 01 ADD 0933 52 MSTORE 0934 60 PUSH1 0x1e 0936 60 PUSH1 0x24 0938 82 DUP3 0939 01 ADD 093A 52 MSTORE 093B 7F PUSH32 0x6d75737420626520746865206f776e6572206f662074686520746f6b656e0000 095C 60 PUSH1 0x44 095E 82 DUP3 095F 01 ADD 0960 52 MSTORE 0961 90 SWAP1 0962 51 MLOAD 0963 90 SWAP1 0964 81 DUP2 0965 90 SWAP1 0966 03 SUB 0967 60 PUSH1 0x64 0969 01 ADD 096A 90 SWAP1 096B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @092C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * 0x02 ** 0xe5 // @0933 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @093A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0960 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6d75737420626520746865206f776e6572206f662074686520746f6b656e0000 // @096B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_096C: // Incoming jump from 0x091C, if msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 // Inputs[1] { @096D stack[-4] } 096C 5B JUMPDEST 096D 83 DUP4 096E 60 PUSH1 0x00 0970 61 PUSH2 0x0978 0973 82 DUP3 0974 61 PUSH2 0x0b0b 0977 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @096D stack[0] = stack[-4] // @096E stack[1] = 0x00 // @0970 stack[2] = 0x0978 // @0973 stack[3] = stack[-4] // } // Block ends with call to 0x0b0b, returns to 0x0978 label_0978: // Incoming return from call to 0x0B0B at 0x0977 // Inputs[3] // { // @0979 stack[-1] // @0979 stack[-2] // @0985 msg.sender // } 0978 5B JUMPDEST 0979 90 SWAP1 097A 50 POP 097B 60 PUSH1 0x01 097D 60 PUSH1 0xa0 097F 60 PUSH1 0x02 0981 0A EXP 0982 03 SUB 0983 81 DUP2 0984 16 AND 0985 33 CALLER 0986 14 EQ 0987 61 PUSH2 0x09da 098A 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0979 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x09da, if msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 label_098B: // Incoming jump from 0x098A, if not msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 // Inputs[3] // { // @098E memory[0x40:0x60] // @09D0 memory[0x40:0x60] // @09D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 098B 60 PUSH1 0x40 098D 80 DUP1 098E 51 MLOAD 098F 60 PUSH1 0xe5 0991 60 PUSH1 0x02 0993 0A EXP 0994 62 PUSH3 0x461bcd 0998 02 MUL 0999 81 DUP2 099A 52 MSTORE 099B 60 PUSH1 0x20 099D 60 PUSH1 0x04 099F 82 DUP3 09A0 01 ADD 09A1 81 DUP2 09A2 90 SWAP1 09A3 52 MSTORE 09A4 60 PUSH1 0x24 09A6 82 DUP3 09A7 01 ADD 09A8 52 MSTORE 09A9 7F PUSH32 0x6d757374206265207468652063726561746f72206f662074686520746f6b656e 09CA 60 PUSH1 0x44 09CC 82 DUP3 09CD 01 ADD 09CE 52 MSTORE 09CF 90 SWAP1 09D0 51 MLOAD 09D1 90 SWAP1 09D2 81 DUP2 09D3 90 SWAP1 09D4 03 SUB 09D5 60 PUSH1 0x64 09D7 01 ADD 09D8 90 SWAP1 09D9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @099A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * 0x02 ** 0xe5 // @09A3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09A8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @09CE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6d757374206265207468652063726561746f72206f662074686520746f6b656e // @09D9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_09DA: // Incoming jump from 0x098A, if msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 // Inputs[2] // { // @09DE stack[-6] // @09DF stack[-5] // } 09DA 5B JUMPDEST 09DB 61 PUSH2 0x09e4 09DE 86 DUP7 09DF 86 DUP7 09E0 61 PUSH2 0x12a4 09E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09DB stack[0] = 0x09e4 // @09DE stack[1] = stack[-6] // @09DF stack[2] = stack[-5] // } // Block ends with unconditional jump to 0x12a4 09E4 5B JUMPDEST 09E5 85 DUP6 09E6 7F PUSH32 0x931f495b9a8e5d8e61946ea5d61e021f636cfe213a801f97589c18c152e408bd 0A07 86 DUP7 0A08 60 PUSH1 0x40 0A0A 51 MLOAD 0A0B 80 DUP1 0A0C 80 DUP1 0A0D 60 PUSH1 0x20 0A0F 01 ADD 0A10 82 DUP3 0A11 81 DUP2 0A12 03 SUB 0A13 82 DUP3 0A14 52 MSTORE 0A15 83 DUP4 0A16 81 DUP2 0A17 81 DUP2 0A18 51 MLOAD 0A19 81 DUP2 0A1A 52 MSTORE 0A1B 60 PUSH1 0x20 0A1D 01 ADD 0A1E 91 SWAP2 0A1F 50 POP 0A20 80 DUP1 0A21 51 MLOAD 0A22 90 SWAP1 0A23 60 PUSH1 0x20 0A25 01 ADD 0A26 90 SWAP1 0A27 80 DUP1 0A28 83 DUP4 0A29 83 DUP4 0A2A 60 PUSH1 0x00 0A2C 5B JUMPDEST 0A2D 83 DUP4 0A2E 81 DUP2 0A2F 10 LT 0A30 15 ISZERO 0A31 61 PUSH2 0x0a44 0A34 57 *JUMPI 0A35 81 DUP2 0A36 81 DUP2 0A37 01 ADD 0A38 51 MLOAD 0A39 83 DUP4 0A3A 82 DUP3 0A3B 01 ADD 0A3C 52 MSTORE 0A3D 60 PUSH1 0x20 0A3F 01 ADD 0A40 61 PUSH2 0x0a2c 0A43 56 *JUMP 0A44 5B JUMPDEST 0A45 50 POP 0A46 50 POP 0A47 50 POP 0A48 50 POP 0A49 90 SWAP1 0A4A 50 POP 0A4B 90 SWAP1 0A4C 81 DUP2 0A4D 01 ADD 0A4E 90 SWAP1 0A4F 60 PUSH1 0x1f 0A51 16 AND 0A52 80 DUP1 0A53 15 ISZERO 0A54 61 PUSH2 0x0a71 0A57 57 *JUMPI 0A58 80 DUP1 0A59 82 DUP3 0A5A 03 SUB 0A5B 80 DUP1 0A5C 51 MLOAD 0A5D 60 PUSH1 0x01 0A5F 83 DUP4 0A60 60 PUSH1 0x20 0A62 03 SUB 0A63 61 PUSH2 0x0100 0A66 0A EXP 0A67 03 SUB 0A68 19 NOT 0A69 16 AND 0A6A 81 DUP2 0A6B 52 MSTORE 0A6C 60 PUSH1 0x20 0A6E 01 ADD 0A6F 91 SWAP2 0A70 50 POP 0A71 5B JUMPDEST 0A72 50 POP 0A73 92 SWAP3 0A74 50 POP 0A75 50 POP 0A76 50 POP 0A77 60 PUSH1 0x40 0A79 51 MLOAD 0A7A 80 DUP1 0A7B 91 SWAP2 0A7C 03 SUB 0A7D 90 SWAP1 0A7E A2 LOG2 0A7F 50 POP 0A80 50 POP 0A81 50 POP 0A82 50 POP 0A83 50 POP 0A84 50 POP 0A85 56 *JUMP label_0A86: // Incoming call from 0x0394, returns to 0x02D7 // Inputs[1] { @0A8C stack[-2] } 0A86 5B JUMPDEST 0A87 60 PUSH1 0x00 0A89 61 PUSH2 0x0a91 0A8C 83 DUP4 0A8D 61 PUSH2 0x0c1e 0A90 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A87 stack[0] = 0x00 // @0A89 stack[1] = 0x0a91 // @0A8C stack[2] = stack[-2] // } // Block ends with call to 0x0c1e, returns to 0x0A91 label_0A91: // Incoming return from call to 0x0C1E at 0x0A90 // Inputs[2] // { // @0A92 stack[-3] // @0A93 stack[-1] // } 0A91 5B JUMPDEST 0A92 82 DUP3 0A93 10 LT 0A94 61 PUSH2 0x0a9c 0A97 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a9c, if stack[-3] < stack[-1] label_0A98: // Incoming jump from 0x0A97, if not stack[-3] < stack[-1] // Inputs[1] { @0A9B memory[0x00:0x00] } 0A98 60 PUSH1 0x00 0A9A 80 DUP1 0A9B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A9B revert(memory[0x00:0x00]); } // Block terminates label_0A9C: // Incoming jump from 0x0A97, if stack[-3] < stack[-1] // Inputs[4] // { // @0AA5 stack[-3] // @0AB4 memory[0x00:0x40] // @0AB6 storage[keccak256(memory[0x00:0x40])] // @0AB7 stack[-2] // } 0A9C 5B JUMPDEST 0A9D 60 PUSH1 0x01 0A9F 60 PUSH1 0xa0 0AA1 60 PUSH1 0x02 0AA3 0A EXP 0AA4 03 SUB 0AA5 83 DUP4 0AA6 16 AND 0AA7 60 PUSH1 0x00 0AA9 90 SWAP1 0AAA 81 DUP2 0AAB 52 MSTORE 0AAC 60 PUSH1 0x05 0AAE 60 PUSH1 0x20 0AB0 52 MSTORE 0AB1 60 PUSH1 0x40 0AB3 90 SWAP1 0AB4 20 SHA3 0AB5 80 DUP1 0AB6 54 SLOAD 0AB7 83 DUP4 0AB8 90 SWAP1 0AB9 81 DUP2 0ABA 10 LT 0ABB 61 PUSH2 0x0ac0 0ABE 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0AAB memory[0x00:0x20] = stack[-3] & 0x02 ** 0xa0 - 0x01 // @0AB0 memory[0x20:0x40] = 0x05 // @0AB4 stack[0] = keccak256(memory[0x00:0x40]) // @0AB8 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0ac0, if stack[-2] < storage[keccak256(memory[0x00:0x40])] label_0ABF: // Incoming jump from 0x0ABE, if not stack[-2] < storage[keccak256(memory[0x00:0x40])] 0ABF FE *ASSERT // Stack delta = +0 // Outputs[1] { @0ABF assert(); } // Block terminates label_0AC0: // Incoming jump from 0x0ABE, if stack[-2] < storage[keccak256(memory[0x00:0x40])] // Inputs[7] // { // @0AC1 stack[-1] // @0AC1 stack[-2] // @0AC9 memory[0x00:0x20] // @0ACB storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0ACC stack[-3] // @0ACE stack[-6] // @0ACF stack[-5] // } 0AC0 5B JUMPDEST 0AC1 90 SWAP1 0AC2 60 PUSH1 0x00 0AC4 52 MSTORE 0AC5 60 PUSH1 0x20 0AC7 60 PUSH1 0x00 0AC9 20 SHA3 0ACA 01 ADD 0ACB 54 SLOAD 0ACC 90 SWAP1 0ACD 50 POP 0ACE 92 SWAP3 0ACF 91 SWAP2 0AD0 50 POP 0AD1 50 POP 0AD2 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @0AC4 memory[0x00:0x20] = stack[-2] // @0ACE stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] label_0AD3: // Incoming call from 0x03B5, returns to 0x01B0 // Incoming call from 0x0F4C, returns to 0x0F4D // Incoming call from 0x0E4C, returns to 0x0E4D // Inputs[1] { @0AD6 storage[0x0e] } 0AD3 5B JUMPDEST 0AD4 60 PUSH1 0x0e 0AD6 54 SLOAD 0AD7 60 PUSH1 0x00 0AD9 90 SWAP1 0ADA 60 PUSH1 0xff 0ADC 16 AND 0ADD 15 ISZERO 0ADE 61 PUSH2 0x0b03 0AE1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AD9 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b03, if !(0xff & storage[0x0e]) label_0AE2: // Incoming jump from 0x0AE1, if not !(0xff & storage[0x0e]) // Inputs[3] // { // @0AEB stack[-2] // @0AFA memory[0x00:0x40] // @0AFB storage[keccak256(memory[0x00:0x40])] // } 0AE2 50 POP 0AE3 60 PUSH1 0x01 0AE5 60 PUSH1 0xa0 0AE7 60 PUSH1 0x02 0AE9 0A EXP 0AEA 03 SUB 0AEB 81 DUP2 0AEC 16 AND 0AED 60 PUSH1 0x00 0AEF 90 SWAP1 0AF0 81 DUP2 0AF1 52 MSTORE 0AF2 60 PUSH1 0x0d 0AF4 60 PUSH1 0x20 0AF6 52 MSTORE 0AF7 60 PUSH1 0x40 0AF9 90 SWAP1 0AFA 20 SHA3 0AFB 54 SLOAD 0AFC 60 PUSH1 0xff 0AFE 16 AND 0AFF 61 PUSH2 0x06cd 0B02 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AF1 memory[0x00:0x20] = stack[-2] & 0x02 ** 0xa0 - 0x01 // @0AF6 memory[0x20:0x40] = 0x0d // @0AFE stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x06cd label_0B03: // Incoming jump from 0x0AE1, if !(0xff & storage[0x0e]) 0B03 5B JUMPDEST 0B04 50 POP 0B05 60 PUSH1 0x01 0B07 61 PUSH2 0x06cd 0B0A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0B05 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x06cd label_0B0B: // Incoming call from 0x0977, returns to 0x0978 // Incoming call from 0x03CD, returns to 0x0282 // Inputs[4] // { // @0B0E stack[-1] // @0B19 memory[0x00:0x40] // @0B1A storage[keccak256(memory[0x00:0x40])] // @0B24 stack[-2] // } 0B0B 5B JUMPDEST 0B0C 60 PUSH1 0x00 0B0E 90 SWAP1 0B0F 81 DUP2 0B10 52 MSTORE 0B11 60 PUSH1 0x0f 0B13 60 PUSH1 0x20 0B15 52 MSTORE 0B16 60 PUSH1 0x40 0B18 90 SWAP1 0B19 20 SHA3 0B1A 54 SLOAD 0B1B 60 PUSH1 0x01 0B1D 60 PUSH1 0xa0 0B1F 60 PUSH1 0x02 0B21 0A EXP 0B22 03 SUB 0B23 16 AND 0B24 90 SWAP1 0B25 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0B10 memory[0x00:0x20] = stack[-1] // @0B15 memory[0x20:0x40] = 0x0f // @0B24 stack[-2] = 0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0B26: // Incoming jump from 0x03F7 // Inputs[4] // { // @0B2A stack[-3] // @0B2B stack[-2] // @0B2C stack[-1] // @0B31 memory[0x40:0x60] // } 0B26 5B JUMPDEST 0B27 61 PUSH2 0x0b42 0B2A 83 DUP4 0B2B 83 DUP4 0B2C 83 DUP4 0B2D 60 PUSH1 0x20 0B2F 60 PUSH1 0x40 0B31 51 MLOAD 0B32 90 SWAP1 0B33 81 DUP2 0B34 01 ADD 0B35 60 PUSH1 0x40 0B37 52 MSTORE 0B38 80 DUP1 0B39 60 PUSH1 0x00 0B3B 81 DUP2 0B3C 52 MSTORE 0B3D 50 POP 0B3E 61 PUSH2 0x0e67 0B41 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0B27 stack[0] = 0x0b42 // @0B2A stack[1] = stack[-3] // @0B2B stack[2] = stack[-2] // @0B2C stack[3] = stack[-1] // @0B32 stack[4] = memory[0x40:0x60] // @0B37 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0B3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x0e67, returns to 0x0B42 label_0B42: // Incoming return from call to 0x12D7 at 0x0BF3 // Incoming jump from 0x18B8, if !(storage[stack[-2]] > stack[-1]) // Incoming return from call to 0x0E67 at 0x0B41 // Incoming return from call to 0x198D at 0x18CE // Incoming jump from 0x0E2A, if !(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0E2A, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[1] { @0B46 stack[-4] } 0B42 5B JUMPDEST 0B43 50 POP 0B44 50 POP 0B45 50 POP 0B46 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0B47: // Incoming call from 0x040F, returns to 0x02D7 0B47 5B JUMPDEST 0B48 60 PUSH1 0x00 0B4A 61 PUSH2 0x0b51 0B4D 61 PUSH2 0x086a 0B50 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B48 stack[0] = 0x00 // @0B4A stack[1] = 0x0b51 // } // Block ends with call to 0x086a, returns to 0x0B51 label_0B51: // Incoming return from call to 0x086A at 0x0B50 // Inputs[2] // { // @0B52 stack[-3] // @0B53 stack[-1] // } 0B51 5B JUMPDEST 0B52 82 DUP3 0B53 10 LT 0B54 61 PUSH2 0x0b5c 0B57 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b5c, if stack[-3] < stack[-1] label_0B58: // Incoming jump from 0x0B57, if not stack[-3] < stack[-1] // Inputs[1] { @0B5B memory[0x00:0x00] } 0B58 60 PUSH1 0x00 0B5A 80 DUP1 0B5B FD *REVERT // Stack delta = +0 // Outputs[1] { @0B5B revert(memory[0x00:0x00]); } // Block terminates label_0B5C: // Incoming jump from 0x0B57, if stack[-3] < stack[-1] // Inputs[2] // { // @0B60 storage[0x07] // @0B61 stack[-2] // } 0B5C 5B JUMPDEST 0B5D 60 PUSH1 0x07 0B5F 80 DUP1 0B60 54 SLOAD 0B61 83 DUP4 0B62 90 SWAP1 0B63 81 DUP2 0B64 10 LT 0B65 61 PUSH2 0x0b6a 0B68 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B5D stack[0] = 0x07 // @0B62 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0b6a, if stack[-2] < storage[0x07] label_0B69: // Incoming jump from 0x0B68, if not stack[-2] < storage[0x07] 0B69 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B69 assert(); } // Block terminates label_0B6A: // Incoming jump from 0x0B68, if stack[-2] < storage[0x07] // Inputs[7] // { // @0B6B stack[-2] // @0B6B stack[-1] // @0B73 memory[0x00:0x20] // @0B75 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0B76 stack[-3] // @0B78 stack[-5] // @0B79 stack[-4] // } 0B6A 5B JUMPDEST 0B6B 90 SWAP1 0B6C 60 PUSH1 0x00 0B6E 52 MSTORE 0B6F 60 PUSH1 0x20 0B71 60 PUSH1 0x00 0B73 20 SHA3 0B74 01 ADD 0B75 54 SLOAD 0B76 90 SWAP1 0B77 50 POP 0B78 91 SWAP2 0B79 90 SWAP1 0B7A 50 POP 0B7B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0B6E memory[0x00:0x20] = stack[-2] // @0B78 stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_0B7C: // Incoming jump from 0x0427 // Inputs[1] { @0B7D stack[-1] } 0B7C 5B JUMPDEST 0B7D 80 DUP1 0B7E 60 PUSH1 0x00 0B80 61 PUSH2 0x0b88 0B83 82 DUP3 0B84 61 PUSH2 0x0bf4 0B87 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B7D stack[0] = stack[-1] // @0B7E stack[1] = 0x00 // @0B80 stack[2] = 0x0b88 // @0B83 stack[3] = stack[-1] // } // Block ends with call to 0x0bf4, returns to 0x0B88 label_0B88: // Incoming return from call to 0x0BF4 at 0x0B87 // Inputs[3] // { // @0B89 stack[-1] // @0B89 stack[-2] // @0B95 msg.sender // } 0B88 5B JUMPDEST 0B89 90 SWAP1 0B8A 50 POP 0B8B 60 PUSH1 0x01 0B8D 60 PUSH1 0xa0 0B8F 60 PUSH1 0x02 0B91 0A EXP 0B92 03 SUB 0B93 81 DUP2 0B94 16 AND 0B95 33 CALLER 0B96 14 EQ 0B97 61 PUSH2 0x0bea 0B9A 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0B89 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0bea, if msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 label_0B9B: // Incoming jump from 0x0B9A, if not msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 // Inputs[3] // { // @0B9E memory[0x40:0x60] // @0BE0 memory[0x40:0x60] // @0BE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B9B 60 PUSH1 0x40 0B9D 80 DUP1 0B9E 51 MLOAD 0B9F 60 PUSH1 0xe5 0BA1 60 PUSH1 0x02 0BA3 0A EXP 0BA4 62 PUSH3 0x461bcd 0BA8 02 MUL 0BA9 81 DUP2 0BAA 52 MSTORE 0BAB 60 PUSH1 0x20 0BAD 60 PUSH1 0x04 0BAF 82 DUP3 0BB0 01 ADD 0BB1 52 MSTORE 0BB2 60 PUSH1 0x1e 0BB4 60 PUSH1 0x24 0BB6 82 DUP3 0BB7 01 ADD 0BB8 52 MSTORE 0BB9 7F PUSH32 0x6d75737420626520746865206f776e6572206f662074686520746f6b656e0000 0BDA 60 PUSH1 0x44 0BDC 82 DUP3 0BDD 01 ADD 0BDE 52 MSTORE 0BDF 90 SWAP1 0BE0 51 MLOAD 0BE1 90 SWAP1 0BE2 81 DUP2 0BE3 90 SWAP1 0BE4 03 SUB 0BE5 60 PUSH1 0x64 0BE7 01 ADD 0BE8 90 SWAP1 0BE9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * 0x02 ** 0xe5 // @0BB1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BB8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0BDE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6d75737420626520746865206f776e6572206f662074686520746f6b656e0000 // @0BE9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0BEA: // Incoming jump from 0x0B9A, if msg.sender == stack[-1] & 0x02 ** 0xa0 - 0x01 // Inputs[2] // { // @0BEE msg.sender // @0BEF stack[-3] // } 0BEA 5B JUMPDEST 0BEB 61 PUSH2 0x0b42 0BEE 33 CALLER 0BEF 84 DUP5 0BF0 61 PUSH2 0x12d7 0BF3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BEB stack[0] = 0x0b42 // @0BEE stack[1] = msg.sender // @0BEF stack[2] = stack[-3] // } // Block ends with call to 0x12d7, returns to 0x0B42 label_0BF4: // Incoming call from 0x043F, returns to 0x0282 // Incoming call from 0x0B87, returns to 0x0B88 // Incoming call from 0x1104, returns to 0x1105 // Incoming call from 0x159C, returns to 0x159D // Incoming call from 0x109E, returns to 0x109F // Incoming call from 0x07CB, returns to 0x07CC // Incoming call from 0x0909, returns to 0x090A // Inputs[3] // { // @0BF7 stack[-1] // @0C02 memory[0x00:0x40] // @0C03 storage[keccak256(memory[0x00:0x40])] // } 0BF4 5B JUMPDEST 0BF5 60 PUSH1 0x00 0BF7 81 DUP2 0BF8 81 DUP2 0BF9 52 MSTORE 0BFA 60 PUSH1 0x01 0BFC 60 PUSH1 0x20 0BFE 52 MSTORE 0BFF 60 PUSH1 0x40 0C01 81 DUP2 0C02 20 SHA3 0C03 54 SLOAD 0C04 60 PUSH1 0x01 0C06 60 PUSH1 0xa0 0C08 60 PUSH1 0x02 0C0A 0A EXP 0C0B 03 SUB 0C0C 16 AND 0C0D 80 DUP1 0C0E 15 ISZERO 0C0F 15 ISZERO 0C10 61 PUSH2 0x0c18 0C13 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0BF5 stack[0] = 0x00 // @0BF9 memory[0x00:0x20] = stack[-1] // @0BFE memory[0x20:0x40] = 0x01 // @0C0C stack[1] = 0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0c18, if !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_0C14: // Incoming jump from 0x0C13, if not !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0C17 memory[0x00:0x00] } 0C14 60 PUSH1 0x00 0C16 80 DUP1 0C17 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C17 revert(memory[0x00:0x00]); } // Block terminates label_0C18: // Incoming jump from 0x0C13, if !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0C19 stack[-4] // @0C19 stack[-1] // @0C1A stack[-3] // } 0C18 5B JUMPDEST 0C19 92 SWAP3 0C1A 91 SWAP2 0C1B 50 POP 0C1C 50 POP 0C1D 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C19 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0C1E: // Incoming call from 0x0460, returns to 0x02D7 // Incoming call from 0x0A90, returns to 0x0A91 // Inputs[1] { @0C29 stack[-1] } 0C1E 5B JUMPDEST 0C1F 60 PUSH1 0x00 0C21 60 PUSH1 0x01 0C23 60 PUSH1 0xa0 0C25 60 PUSH1 0x02 0C27 0A EXP 0C28 03 SUB 0C29 82 DUP3 0C2A 16 AND 0C2B 15 ISZERO 0C2C 15 ISZERO 0C2D 61 PUSH2 0x0c35 0C30 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C1F stack[0] = 0x00 } // Block ends with conditional jump to 0x0c35, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) label_0C31: // Incoming jump from 0x0C30, if not !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @0C34 memory[0x00:0x00] } 0C31 60 PUSH1 0x00 0C33 80 DUP1 0C34 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C34 revert(memory[0x00:0x00]); } // Block terminates label_0C35: // Incoming jump from 0x0C30, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[4] // { // @0C3F stack[-2] // @0C4D memory[0x00:0x40] // @0C4E storage[keccak256(memory[0x00:0x40])] // @0C4F stack[-3] // } 0C35 5B JUMPDEST 0C36 50 POP 0C37 60 PUSH1 0x01 0C39 60 PUSH1 0xa0 0C3B 60 PUSH1 0x02 0C3D 0A EXP 0C3E 03 SUB 0C3F 16 AND 0C40 60 PUSH1 0x00 0C42 90 SWAP1 0C43 81 DUP2 0C44 52 MSTORE 0C45 60 PUSH1 0x03 0C47 60 PUSH1 0x20 0C49 52 MSTORE 0C4A 60 PUSH1 0x40 0C4C 90 SWAP1 0C4D 20 SHA3 0C4E 54 SLOAD 0C4F 90 SWAP1 0C50 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0C44 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @0C49 memory[0x20:0x40] = 0x03 // @0C4F stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C51: // Incoming call from 0x0475, returns to 0x01DE 0C51 5B JUMPDEST 0C52 61 PUSH2 0x0c59 0C55 61 PUSH2 0x0d10 0C58 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C52 stack[0] = 0x0c59 } // Block ends with call to 0x0d10, returns to 0x0C59 label_0C59: // Incoming return from call to 0x0D10 at 0x0C58 // Inputs[1] { @0C5A stack[-1] } 0C59 5B JUMPDEST 0C5A 15 ISZERO 0C5B 15 ISZERO 0C5C 61 PUSH2 0x0c64 0C5F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c64, if !!stack[-1] label_0C60: // Incoming jump from 0x0C5F, if not !!stack[-1] // Inputs[1] { @0C63 memory[0x00:0x00] } 0C60 60 PUSH1 0x00 0C62 80 DUP1 0C63 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C63 revert(memory[0x00:0x00]); } // Block terminates label_0C64: // Incoming jump from 0x0C5F, if !!stack[-1] // Inputs[5] // { // @0C67 storage[0x0c] // @0C6A memory[0x40:0x60] // @0C9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0CA0 storage[0x0c] // @0CAD stack[-1] // } 0C64 5B JUMPDEST 0C65 60 PUSH1 0x0c 0C67 54 SLOAD 0C68 60 PUSH1 0x40 0C6A 51 MLOAD 0C6B 60 PUSH1 0x00 0C6D 91 SWAP2 0C6E 60 PUSH1 0x01 0C70 60 PUSH1 0xa0 0C72 60 PUSH1 0x02 0C74 0A EXP 0C75 03 SUB 0C76 16 AND 0C77 90 SWAP1 0C78 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0C99 90 SWAP1 0C9A 83 DUP4 0C9B 90 SWAP1 0C9C A3 LOG3 0C9D 60 PUSH1 0x0c 0C9F 80 DUP1 0CA0 54 SLOAD 0CA1 60 PUSH1 0x01 0CA3 60 PUSH1 0xa0 0CA5 60 PUSH1 0x02 0CA7 0A EXP 0CA8 03 SUB 0CA9 19 NOT 0CAA 16 AND 0CAB 90 SWAP1 0CAC 55 SSTORE 0CAD 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0C9C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0c] & 0x02 ** 0xa0 - 0x01, 0x00]); // @0CAC storage[0x0c] = ~(0x02 ** 0xa0 - 0x01) & storage[0x0c] // } // Block ends with unconditional jump to stack[-1] label_0CAE: // Incoming call from 0x0496, returns to 0x01DE 0CAE 5B JUMPDEST 0CAF 61 PUSH2 0x0cb6 0CB2 61 PUSH2 0x0d10 0CB5 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CAF stack[0] = 0x0cb6 } // Block ends with call to 0x0d10, returns to 0x0CB6 label_0CB6: // Incoming return from call to 0x0D10 at 0x0CB5 // Inputs[1] { @0CB7 stack[-1] } 0CB6 5B JUMPDEST 0CB7 15 ISZERO 0CB8 15 ISZERO 0CB9 61 PUSH2 0x0cc1 0CBC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cc1, if !!stack[-1] label_0CBD: // Incoming jump from 0x0CBC, if not !!stack[-1] // Inputs[1] { @0CC0 memory[0x00:0x00] } 0CBD 60 PUSH1 0x00 0CBF 80 DUP1 0CC0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CC0 revert(memory[0x00:0x00]); } // Block terminates label_0CC1: // Incoming jump from 0x0CBC, if !!stack[-1] // Inputs[1] { @0CC5 stack[-1] } 0CC1 5B JUMPDEST 0CC2 61 PUSH2 0x0cca 0CC5 81 DUP2 0CC6 61 PUSH2 0x131f 0CC9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CC2 stack[0] = 0x0cca // @0CC5 stack[1] = stack[-1] // } // Block ends with call to 0x131f, returns to 0x0CCA label_0CCA: // Incoming return from call to 0x131F at 0x0CC9 // Inputs[4] // { // @0CCD memory[0x40:0x60] // @0CD6 stack[-1] // @0CFE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0D00 stack[-2] // } 0CCA 5B JUMPDEST 0CCB 60 PUSH1 0x40 0CCD 51 MLOAD 0CCE 60 PUSH1 0x01 0CD0 60 PUSH1 0xa0 0CD2 60 PUSH1 0x02 0CD4 0A EXP 0CD5 03 SUB 0CD6 82 DUP3 0CD7 16 AND 0CD8 90 SWAP1 0CD9 7F PUSH32 0x1f756c8b089af6b33ee121fee8badac2553a2fa89c0575ea91ff8792617746c2 0CFA 90 SWAP1 0CFB 60 PUSH1 0x00 0CFD 90 SWAP1 0CFE A2 LOG2 0CFF 50 POP 0D00 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CFE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x1f756c8b089af6b33ee121fee8badac2553a2fa89c0575ea91ff8792617746c2, stack[-1] & 0x02 ** 0xa0 - 0x01]); } // Block ends with unconditional jump to stack[-2] label_0D01: // Incoming call from 0x04AB, returns to 0x0282 // Inputs[2] // { // @0D04 storage[0x0c] // @0D0E stack[-1] // } 0D01 5B JUMPDEST 0D02 60 PUSH1 0x0c 0D04 54 SLOAD 0D05 60 PUSH1 0x01 0D07 60 PUSH1 0xa0 0D09 60 PUSH1 0x02 0D0B 0A EXP 0D0C 03 SUB 0D0D 16 AND 0D0E 90 SWAP1 0D0F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D0E stack[-1] = 0x02 ** 0xa0 - 0x01 & storage[0x0c] } // Block ends with unconditional jump to stack[-1] label_0D10: // Incoming call from 0x0C58, returns to 0x0C59 // Incoming call from 0x105E, returns to 0x105F // Incoming call from 0x0E10, returns to 0x0E11 // Incoming call from 0x06D9, returns to 0x06DA // Incoming call from 0x04C0, returns to 0x01B0 // Incoming call from 0x0CB5, returns to 0x0CB6 // Incoming call from 0x0FDD, returns to 0x0FDE // Inputs[3] // { // @0D13 storage[0x0c] // @0D1D msg.sender // @0D1F stack[-1] // } 0D10 5B JUMPDEST 0D11 60 PUSH1 0x0c 0D13 54 SLOAD 0D14 60 PUSH1 0x01 0D16 60 PUSH1 0xa0 0D18 60 PUSH1 0x02 0D1A 0A EXP 0D1B 03 SUB 0D1C 16 AND 0D1D 33 CALLER 0D1E 14 EQ 0D1F 90 SWAP1 0D20 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D1F stack[-1] = msg.sender == 0x02 ** 0xa0 - 0x01 & storage[0x0c] } // Block ends with unconditional jump to stack[-1] label_0D21: // Incoming call from 0x04D5, returns to 0x01F5 // Inputs[2] // { // @0D25 storage[0x0a] // @0D29 memory[0x40:0x60] // } 0D21 5B JUMPDEST 0D22 60 PUSH1 0x0a 0D24 80 DUP1 0D25 54 SLOAD 0D26 60 PUSH1 0x40 0D28 80 DUP1 0D29 51 MLOAD 0D2A 60 PUSH1 0x20 0D2C 60 PUSH1 0x1f 0D2E 60 PUSH1 0x02 0D30 60 PUSH1 0x00 0D32 19 NOT 0D33 61 PUSH2 0x0100 0D36 60 PUSH1 0x01 0D38 88 DUP9 0D39 16 AND 0D3A 15 ISZERO 0D3B 02 MUL 0D3C 01 ADD 0D3D 90 SWAP1 0D3E 95 SWAP6 0D3F 16 AND 0D40 94 SWAP5 0D41 90 SWAP1 0D42 94 SWAP5 0D43 04 DIV 0D44 93 SWAP4 0D45 84 DUP5 0D46 01 ADD 0D47 81 DUP2 0D48 90 SWAP1 0D49 04 DIV 0D4A 81 DUP2 0D4B 02 MUL 0D4C 82 DUP3 0D4D 01 ADD 0D4E 81 DUP2 0D4F 01 ADD 0D50 90 SWAP1 0D51 92 SWAP3 0D52 52 MSTORE 0D53 82 DUP3 0D54 81 DUP2 0D55 52 MSTORE 0D56 60 PUSH1 0x60 0D58 93 SWAP4 0D59 90 SWAP1 0D5A 92 SWAP3 0D5B 90 SWAP1 0D5C 91 SWAP2 0D5D 83 DUP4 0D5E 01 ADD 0D5F 82 DUP3 0D60 82 DUP3 0D61 80 DUP1 0D62 15 ISZERO 0D63 61 PUSH2 0x0784 0D66 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0D52 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0D55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0D58 stack[0] = 0x60 // @0D5A stack[1] = memory[0x40:0x60] // @0D5B stack[3] = (storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0D5C stack[2] = 0x0a // @0D5E stack[4] = memory[0x40:0x60] + 0x20 // @0D5F stack[5] = 0x0a // @0D60 stack[6] = (storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0784, if !((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0D67: // Incoming jump from 0x0D66, if not !((storage[0x0a] & !(storage[0x0a] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0D67 stack[-1] } 0D67 80 DUP1 0D68 60 PUSH1 0x1f 0D6A 10 LT 0D6B 61 PUSH2 0x0759 0D6E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0759, if 0x1f < stack[-1] label_0D6F: // Incoming jump from 0x0D6E, if not 0x1f < stack[-1] // Inputs[4] // { // @0D73 stack[-2] // @0D74 storage[stack[-2]] // @0D77 stack[-3] // @0D79 stack[-1] // } 0D6F 61 PUSH2 0x0100 0D72 80 DUP1 0D73 83 DUP4 0D74 54 SLOAD 0D75 04 DIV 0D76 02 MUL 0D77 83 DUP4 0D78 52 MSTORE 0D79 91 SWAP2 0D7A 60 PUSH1 0x20 0D7C 01 ADD 0D7D 91 SWAP2 0D7E 61 PUSH2 0x0784 0D81 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D78 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0D7D stack[-1] = stack[-1] // @0D7D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0784 label_0D82: // Incoming call from 0x04FB, returns to 0x01DE // Inputs[2] // { // @0D8B stack[-2] // @0D8D msg.sender // } 0D82 5B JUMPDEST 0D83 60 PUSH1 0x01 0D85 60 PUSH1 0xa0 0D87 60 PUSH1 0x02 0D89 0A EXP 0D8A 03 SUB 0D8B 82 DUP3 0D8C 16 AND 0D8D 33 CALLER 0D8E 14 EQ 0D8F 15 ISZERO 0D90 61 PUSH2 0x0d98 0D93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d98, if !(msg.sender == stack[-2] & 0x02 ** 0xa0 - 0x01) label_0D94: // Incoming jump from 0x0D93, if not !(msg.sender == stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @0D97 memory[0x00:0x00] } 0D94 60 PUSH1 0x00 0D96 80 DUP1 0D97 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D97 revert(memory[0x00:0x00]); } // Block terminates label_0D98: // Incoming jump from 0x0D93, if !(msg.sender == stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[10] // { // @0D99 msg.sender // @0DAA memory[0x00:0x40] // @0DB3 stack[-2] // @0DBE memory[0x00:0x40] // @0DC0 storage[keccak256(memory[0x00:0x40])] // @0DC5 stack[-1] // @0DCF memory[0x40:0x60] // @0DD4 memory[0x40:0x60] // @0E02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @0E05 stack[-3] // } 0D98 5B JUMPDEST 0D99 33 CALLER 0D9A 60 PUSH1 0x00 0D9C 81 DUP2 0D9D 81 DUP2 0D9E 52 MSTORE 0D9F 60 PUSH1 0x04 0DA1 60 PUSH1 0x20 0DA3 90 SWAP1 0DA4 81 DUP2 0DA5 52 MSTORE 0DA6 60 PUSH1 0x40 0DA8 80 DUP1 0DA9 83 DUP4 0DAA 20 SHA3 0DAB 60 PUSH1 0x01 0DAD 60 PUSH1 0xa0 0DAF 60 PUSH1 0x02 0DB1 0A EXP 0DB2 03 SUB 0DB3 87 DUP8 0DB4 16 AND 0DB5 80 DUP1 0DB6 85 DUP6 0DB7 52 MSTORE 0DB8 90 SWAP1 0DB9 83 DUP4 0DBA 52 MSTORE 0DBB 92 SWAP3 0DBC 81 DUP2 0DBD 90 SWAP1 0DBE 20 SHA3 0DBF 80 DUP1 0DC0 54 SLOAD 0DC1 60 PUSH1 0xff 0DC3 19 NOT 0DC4 16 AND 0DC5 86 DUP7 0DC6 15 ISZERO 0DC7 15 ISZERO 0DC8 90 SWAP1 0DC9 81 DUP2 0DCA 17 OR 0DCB 90 SWAP1 0DCC 91 SWAP2 0DCD 55 SSTORE 0DCE 81 DUP2 0DCF 51 MLOAD 0DD0 90 SWAP1 0DD1 81 DUP2 0DD2 52 MSTORE 0DD3 90 SWAP1 0DD4 51 MLOAD 0DD5 92 SWAP3 0DD6 93 SWAP4 0DD7 92 SWAP3 0DD8 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0DF9 92 SWAP3 0DFA 91 SWAP2 0DFB 81 DUP2 0DFC 90 SWAP1 0DFD 03 SUB 0DFE 90 SWAP1 0DFF 91 SWAP2 0E00 01 ADD 0E01 90 SWAP1 0E02 A3 LOG3 0E03 50 POP 0E04 50 POP 0E05 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0D9E memory[0x00:0x20] = msg.sender // @0DA5 memory[0x20:0x40] = 0x04 // @0DB7 memory[0x00:0x20] = stack[-2] & 0x02 ** 0xa0 - 0x01 // @0DBA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0DCD storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0DD2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0E02 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_0E06: // Incoming call from 0x0550, returns to 0x01DE 0E06 5B JUMPDEST 0E07 60 PUSH1 0x00 0E09 80 DUP1 0E0A 61 PUSH2 0x0e11 0E0D 61 PUSH2 0x0d10 0E10 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E07 stack[0] = 0x00 // @0E09 stack[1] = 0x00 // @0E0A stack[2] = 0x0e11 // } // Block ends with call to 0x0d10, returns to 0x0E11 label_0E11: // Incoming return from call to 0x0D10 at 0x0E10 // Inputs[1] { @0E12 stack[-1] } 0E11 5B JUMPDEST 0E12 15 ISZERO 0E13 15 ISZERO 0E14 61 PUSH2 0x0e1c 0E17 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e1c, if !!stack[-1] label_0E18: // Incoming jump from 0x0E17, if not !!stack[-1] // Inputs[1] { @0E1B memory[0x00:0x00] } 0E18 60 PUSH1 0x00 0E1A 80 DUP1 0E1B FD *REVERT // Stack delta = +0 // Outputs[1] { @0E1B revert(memory[0x00:0x00]); } // Block terminates label_0E1C: // Incoming jump from 0x0E17, if !!stack[-1] // Inputs[3] // { // @0E1F stack[-2] // @0E22 stack[-3] // @0E23 memory[stack[-3]:stack[-3] + 0x20] // } 0E1C 5B JUMPDEST 0E1D 60 PUSH1 0x00 0E1F 91 SWAP2 0E20 50 POP 0E21 5B JUMPDEST 0E22 82 DUP3 0E23 51 MLOAD 0E24 82 DUP3 0E25 10 LT 0E26 15 ISZERO 0E27 61 PUSH2 0x0b42 0E2A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E1F stack[-2] = 0x00 } // Block ends with conditional jump to 0x0b42, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_0E2B: // Incoming jump from 0x0E2A, if not !(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0E2A, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @0E2B stack[-3] // @0E2C stack[-2] // @0E2E memory[stack[-3]:stack[-3] + 0x20] // } 0E2B 82 DUP3 0E2C 82 DUP3 0E2D 81 DUP2 0E2E 51 MLOAD 0E2F 81 DUP2 0E30 10 LT 0E31 15 ISZERO 0E32 15 ISZERO 0E33 61 PUSH2 0x0e38 0E36 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E2B stack[0] = stack[-3] // @0E2C stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0e38, if !!(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) label_0E37: // Incoming jump from 0x0E36, if not !!(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) 0E37 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E37 assert(); } // Block terminates label_0E38: // Incoming jump from 0x0E36, if !!(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @0E39 stack[-1] // @0E39 stack[-2] // @0E42 memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0E43 stack[-3] // } 0E38 5B JUMPDEST 0E39 90 SWAP1 0E3A 60 PUSH1 0x20 0E3C 01 ADD 0E3D 90 SWAP1 0E3E 60 PUSH1 0x20 0E40 02 MUL 0E41 01 ADD 0E42 51 MLOAD 0E43 90 SWAP1 0E44 50 POP 0E45 61 PUSH2 0x0e4d 0E48 81 DUP2 0E49 61 PUSH2 0x0ad3 0E4C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E43 stack[-3] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // @0E45 stack[-2] = 0x0e4d // @0E48 stack[-1] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] // } // Block ends with call to 0x0ad3, returns to 0x0E4D label_0E4D: // Incoming return from call to 0x0AD3 at 0x0E4C // Inputs[1] { @0E4E stack[-1] } 0E4D 5B JUMPDEST 0E4E 15 ISZERO 0E4F 15 ISZERO 0E50 61 PUSH2 0x0e5c 0E53 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e5c, if !!stack[-1] label_0E54: // Incoming jump from 0x0E53, if not !!stack[-1] // Inputs[1] { @0E57 stack[-1] } 0E54 61 PUSH2 0x0e5c 0E57 81 DUP2 0E58 61 PUSH2 0x1340 0E5B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E54 stack[0] = 0x0e5c // @0E57 stack[1] = stack[-1] // } // Block ends with call to 0x1340, returns to 0x0E5C label_0E5C: // Incoming return from call to 0x1340 at 0x0E5B // Incoming jump from 0x0E53, if !!stack[-1] // Inputs[2] // { // @0E5F stack[-1] // @0E60 stack[-2] // } 0E5C 5B JUMPDEST 0E5D 60 PUSH1 0x01 0E5F 90 SWAP1 0E60 91 SWAP2 0E61 01 ADD 0E62 90 SWAP1 0E63 61 PUSH2 0x0e21 0E66 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E62 stack[-2] = stack[-2] + 0x01 // @0E62 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x0e21 label_0E67: // Incoming call from 0x0B41, returns to 0x0B42 // Incoming call from 0x05BF, returns to 0x01DE // Inputs[3] // { // @0E6B stack[-4] // @0E6C stack[-3] // @0E6D stack[-2] // } 0E67 5B JUMPDEST 0E68 61 PUSH2 0x0e72 0E6B 84 DUP5 0E6C 84 DUP5 0E6D 84 DUP5 0E6E 61 PUSH2 0x0870 0E71 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E68 stack[0] = 0x0e72 // @0E6B stack[1] = stack[-4] // @0E6C stack[2] = stack[-3] // @0E6D stack[3] = stack[-2] // } // Block ends with call to 0x0870, returns to 0x0E72 label_0E72: // Incoming return from call to 0x0870 at 0x0E71 // Inputs[4] // { // @0E76 stack[-4] // @0E77 stack[-3] // @0E78 stack[-2] // @0E79 stack[-1] // } 0E72 5B JUMPDEST 0E73 61 PUSH2 0x0e7e 0E76 84 DUP5 0E77 84 DUP5 0E78 84 DUP5 0E79 84 DUP5 0E7A 61 PUSH2 0x1364 0E7D 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0E73 stack[0] = 0x0e7e // @0E76 stack[1] = stack[-4] // @0E77 stack[2] = stack[-3] // @0E78 stack[3] = stack[-2] // @0E79 stack[4] = stack[-1] // } // Block ends with call to 0x1364, returns to 0x0E7E label_0E7E: // Incoming return from call to 0x1364 at 0x0E7D // Inputs[1] { @0E7F stack[-1] } 0E7E 5B JUMPDEST 0E7F 15 ISZERO 0E80 15 ISZERO 0E81 61 PUSH2 0x0e89 0E84 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e89, if !!stack[-1] label_0E85: // Incoming jump from 0x0E84, if not !!stack[-1] // Inputs[1] { @0E88 memory[0x00:0x00] } 0E85 60 PUSH1 0x00 0E87 80 DUP1 0E88 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E88 revert(memory[0x00:0x00]); } // Block terminates label_0E89: // Incoming jump from 0x0E84, if !!stack[-1] // Inputs[1] { @0E8E stack[-5] } 0E89 5B JUMPDEST 0E8A 50 POP 0E8B 50 POP 0E8C 50 POP 0E8D 50 POP 0E8E 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0E8F: // Incoming call from 0x05D7, returns to 0x01F5 // Inputs[1] { @0E95 stack[-1] } 0E8F 5B JUMPDEST 0E90 60 PUSH1 0x60 0E92 61 PUSH2 0x0e9a 0E95 82 DUP3 0E96 61 PUSH2 0x1076 0E99 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E90 stack[0] = 0x60 // @0E92 stack[1] = 0x0e9a // @0E95 stack[2] = stack[-1] // } // Block ends with call to 0x1076, returns to 0x0E9A label_0E9A: // Incoming return from call to 0x1076 at 0x0E99 // Inputs[1] { @0E9B stack[-1] } 0E9A 5B JUMPDEST 0E9B 15 ISZERO 0E9C 15 ISZERO 0E9D 61 PUSH2 0x0ea5 0EA0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ea5, if !!stack[-1] label_0EA1: // Incoming jump from 0x0EA0, if not !!stack[-1] // Inputs[1] { @0EA4 memory[0x00:0x00] } 0EA1 60 PUSH1 0x00 0EA3 80 DUP1 0EA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EA4 revert(memory[0x00:0x00]); } // Block terminates label_0EA5: // Incoming jump from 0x0EA0, if !!stack[-1] // Inputs[4] // { // @0EA8 stack[-2] // @0EB7 memory[0x00:0x40] // @0EB9 storage[keccak256(memory[0x00:0x40])] // @0EBB memory[0x40:0x60] // } 0EA5 5B JUMPDEST 0EA6 60 PUSH1 0x00 0EA8 82 DUP3 0EA9 81 DUP2 0EAA 52 MSTORE 0EAB 60 PUSH1 0x0b 0EAD 60 PUSH1 0x20 0EAF 90 SWAP1 0EB0 81 DUP2 0EB1 52 MSTORE 0EB2 60 PUSH1 0x40 0EB4 91 SWAP2 0EB5 82 DUP3 0EB6 90 SWAP1 0EB7 20 SHA3 0EB8 80 DUP1 0EB9 54 SLOAD 0EBA 83 DUP4 0EBB 51 MLOAD 0EBC 60 PUSH1 0x1f 0EBE 60 PUSH1 0x02 0EC0 60 PUSH1 0x00 0EC2 19 NOT 0EC3 61 PUSH2 0x0100 0EC6 60 PUSH1 0x01 0EC8 86 DUP7 0EC9 16 AND 0ECA 15 ISZERO 0ECB 02 MUL 0ECC 01 ADD 0ECD 90 SWAP1 0ECE 93 SWAP4 0ECF 16 AND 0ED0 92 SWAP3 0ED1 90 SWAP1 0ED2 92 SWAP3 0ED3 04 DIV 0ED4 91 SWAP2 0ED5 82 DUP3 0ED6 01 ADD 0ED7 84 DUP5 0ED8 90 SWAP1 0ED9 04 DIV 0EDA 84 DUP5 0EDB 02 MUL 0EDC 81 DUP2 0EDD 01 ADD 0EDE 84 DUP5 0EDF 01 ADD 0EE0 90 SWAP1 0EE1 94 SWAP5 0EE2 52 MSTORE 0EE3 80 DUP1 0EE4 84 DUP5 0EE5 52 MSTORE 0EE6 90 SWAP1 0EE7 91 SWAP2 0EE8 83 DUP4 0EE9 01 ADD 0EEA 82 DUP3 0EEB 82 DUP3 0EEC 80 DUP1 0EED 15 ISZERO 0EEE 61 PUSH2 0x0f38 0EF1 57 *JUMPI // Stack delta = +6 // Outputs[10] // { // @0EAA memory[0x00:0x20] = stack[-2] // @0EB1 memory[0x20:0x40] = 0x0b // @0EE1 stack[0] = memory[0x40:0x60] // @0EE2 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0EE5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0EE6 stack[2] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0EE7 stack[1] = keccak256(memory[0x00:0x40]) // @0EE9 stack[3] = memory[0x40:0x60] + 0x20 // @0EEA stack[4] = keccak256(memory[0x00:0x40]) // @0EEB stack[5] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0f38, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0EF2: // Incoming jump from 0x0EF1, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0EF2 stack[-1] } 0EF2 80 DUP1 0EF3 60 PUSH1 0x1f 0EF5 10 LT 0EF6 61 PUSH2 0x0f0d 0EF9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f0d, if 0x1f < stack[-1] label_0EFA: // Incoming jump from 0x0EF9, if not 0x1f < stack[-1] // Inputs[4] // { // @0EFE stack[-2] // @0EFF storage[stack[-2]] // @0F02 stack[-3] // @0F04 stack[-1] // } 0EFA 61 PUSH2 0x0100 0EFD 80 DUP1 0EFE 83 DUP4 0EFF 54 SLOAD 0F00 04 DIV 0F01 02 MUL 0F02 83 DUP4 0F03 52 MSTORE 0F04 91 SWAP2 0F05 60 PUSH1 0x20 0F07 01 ADD 0F08 91 SWAP2 0F09 61 PUSH2 0x0f38 0F0C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0F03 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0F08 stack[-1] = stack[-1] // @0F08 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0f38 label_0F0D: // Incoming jump from 0x0EF9, if 0x1f < stack[-1] // Inputs[5] // { // @0F0E stack[-3] // @0F0F stack[-1] // @0F11 stack[-2] // @0F19 memory[0x00:0x20] // @0F1D storage[keccak256(memory[0x00:0x20])] // } 0F0D 5B JUMPDEST 0F0E 82 DUP3 0F0F 01 ADD 0F10 91 SWAP2 0F11 90 SWAP1 0F12 60 PUSH1 0x00 0F14 52 MSTORE 0F15 60 PUSH1 0x20 0F17 60 PUSH1 0x00 0F19 20 SHA3 0F1A 90 SWAP1 0F1B 5B JUMPDEST 0F1C 81 DUP2 0F1D 54 SLOAD 0F1E 81 DUP2 0F1F 52 MSTORE 0F20 90 SWAP1 0F21 60 PUSH1 0x01 0F23 01 ADD 0F24 90 SWAP1 0F25 60 PUSH1 0x20 0F27 01 ADD 0F28 80 DUP1 0F29 83 DUP4 0F2A 11 GT 0F2B 61 PUSH2 0x0f1b 0F2E 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0F10 stack[-3] = stack[-3] + stack[-1] // @0F14 memory[0x00:0x20] = stack[-2] // @0F1F memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0F24 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0F27 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0f1b, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0F2F: // Incoming jump from 0x0F2E, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0F2E, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0F2F stack[-3] // @0F30 stack[-1] // } 0F2F 82 DUP3 0F30 90 SWAP1 0F31 03 SUB 0F32 60 PUSH1 0x1f 0F34 16 AND 0F35 82 DUP3 0F36 01 ADD 0F37 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0F37 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0F37 stack[-1] = stack[-3] // } // Block continues label_0F38: // Incoming jump from 0x0F37 // Incoming jump from 0x0EF1, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0F0C // Inputs[4] // { // @0F3E stack[-7] // @0F3E stack[-6] // @0F40 stack[-9] // @0F41 stack[-8] // } 0F38 5B JUMPDEST 0F39 50 POP 0F3A 50 POP 0F3B 50 POP 0F3C 50 POP 0F3D 50 POP 0F3E 90 SWAP1 0F3F 50 POP 0F40 91 SWAP2 0F41 90 SWAP1 0F42 50 POP 0F43 56 *JUMP // Stack delta = -8 // Outputs[1] { @0F40 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_0F44: // Incoming jump from 0x0630 // Inputs[1] { @0F48 msg.sender } 0F44 5B JUMPDEST 0F45 61 PUSH2 0x0f4d 0F48 33 CALLER 0F49 61 PUSH2 0x0ad3 0F4C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F45 stack[0] = 0x0f4d // @0F48 stack[1] = msg.sender // } // Block ends with call to 0x0ad3, returns to 0x0F4D label_0F4D: // Incoming return from call to 0x0AD3 at 0x0F4C // Inputs[1] { @0F4E stack[-1] } 0F4D 5B JUMPDEST 0F4E 15 ISZERO 0F4F 15 ISZERO 0F50 61 PUSH2 0x0fc8 0F53 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fc8, if !!stack[-1] label_0F54: // Incoming jump from 0x0F53, if not !!stack[-1] // Inputs[3] // { // @0F57 memory[0x40:0x60] // @0FBE memory[0x40:0x60] // @0FC7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x84 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F54 60 PUSH1 0x40 0F56 80 DUP1 0F57 51 MLOAD 0F58 60 PUSH1 0xe5 0F5A 60 PUSH1 0x02 0F5C 0A EXP 0F5D 62 PUSH3 0x461bcd 0F61 02 MUL 0F62 81 DUP2 0F63 52 MSTORE 0F64 60 PUSH1 0x20 0F66 60 PUSH1 0x04 0F68 82 DUP3 0F69 01 ADD 0F6A 52 MSTORE 0F6B 60 PUSH1 0x24 0F6D 80 DUP1 0F6E 82 DUP3 0F6F 01 ADD 0F70 52 MSTORE 0F71 7F PUSH32 0x6d7573742062652077686974656c697374656420746f2063726561746520746f 0F92 60 PUSH1 0x44 0F94 82 DUP3 0F95 01 ADD 0F96 52 MSTORE 0F97 7F PUSH32 0x6b656e7300000000000000000000000000000000000000000000000000000000 0FB8 60 PUSH1 0x64 0FBA 82 DUP3 0FBB 01 ADD 0FBC 52 MSTORE 0FBD 90 SWAP1 0FBE 51 MLOAD 0FBF 90 SWAP1 0FC0 81 DUP2 0FC1 90 SWAP1 0FC2 03 SUB 0FC3 60 PUSH1 0x84 0FC5 01 ADD 0FC6 90 SWAP1 0FC7 FD *REVERT // Stack delta = +0 // Outputs[6] // { // @0F63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * 0x02 ** 0xe5 // @0F6A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F70 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @0F96 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6d7573742062652077686974656c697374656420746f2063726561746520746f // @0FBC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6b656e7300000000000000000000000000000000000000000000000000000000 // @0FC7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x84 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0FC8: // Incoming jump from 0x0F53, if !!stack[-1] // Inputs[2] // { // @0FCC stack[-1] // @0FCD msg.sender // } 0FC8 5B JUMPDEST 0FC9 61 PUSH2 0x0fd2 0FCC 81 DUP2 0FCD 33 CALLER 0FCE 61 PUSH2 0x14e6 0FD1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FC9 stack[0] = 0x0fd2 // @0FCC stack[1] = stack[-1] // @0FCD stack[2] = msg.sender // } // Block ends with unconditional jump to 0x14e6 label_0FD2: // Incoming return from call to 0x194D at 0x131E // Incoming jump from 0x1308, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x1135, if !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0FD5 stack[-3] } 0FD2 5B JUMPDEST 0FD3 50 POP 0FD4 50 POP 0FD5 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0FD6: // Incoming call from 0x0651, returns to 0x01DE 0FD6 5B JUMPDEST 0FD7 61 PUSH2 0x0fde 0FDA 61 PUSH2 0x0d10 0FDD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FD7 stack[0] = 0x0fde } // Block ends with call to 0x0d10, returns to 0x0FDE label_0FDE: // Incoming return from call to 0x0D10 at 0x0FDD // Inputs[1] { @0FDF stack[-1] } 0FDE 5B JUMPDEST 0FDF 15 ISZERO 0FE0 15 ISZERO 0FE1 61 PUSH2 0x0fe9 0FE4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fe9, if !!stack[-1] label_0FE5: // Incoming jump from 0x0FE4, if not !!stack[-1] // Inputs[1] { @0FE8 memory[0x00:0x00] } 0FE5 60 PUSH1 0x00 0FE7 80 DUP1 0FE8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FE8 revert(memory[0x00:0x00]); } // Block terminates label_0FE9: // Incoming jump from 0x0FE4, if !!stack[-1] // Inputs[1] { @0FED stack[-1] } 0FE9 5B JUMPDEST 0FEA 61 PUSH2 0x0ff2 0FED 81 DUP2 0FEE 61 PUSH2 0x1340 0FF1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FEA stack[0] = 0x0ff2 // @0FED stack[1] = stack[-1] // } // Block ends with call to 0x1340, returns to 0x0FF2 label_0FF2: // Incoming return from call to 0x1340 at 0x0FF1 // Inputs[4] // { // @0FF5 memory[0x40:0x60] // @0FFE stack[-1] // @1026 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1028 stack[-2] // } 0FF2 5B JUMPDEST 0FF3 60 PUSH1 0x40 0FF5 51 MLOAD 0FF6 60 PUSH1 0x01 0FF8 60 PUSH1 0xa0 0FFA 60 PUSH1 0x02 0FFC 0A EXP 0FFD 03 SUB 0FFE 82 DUP3 0FFF 16 AND 1000 90 SWAP1 1001 7F PUSH32 0x75b2135d1c8c3519f3c09c43fe6527089ef09f40c7981ebf0ed46e79e79032c7 1022 90 SWAP1 1023 60 PUSH1 0x00 1025 90 SWAP1 1026 A2 LOG2 1027 50 POP 1028 56 *JUMP // Stack delta = -2 // Outputs[1] { @1026 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x75b2135d1c8c3519f3c09c43fe6527089ef09f40c7981ebf0ed46e79e79032c7, stack[-1] & 0x02 ** 0xa0 - 0x01]); } // Block ends with unconditional jump to stack[-2] label_1029: // Incoming call from 0x0678, returns to 0x01B0 // Incoming call from 0x0802, returns to 0x0803 // Incoming call from 0x10E9, returns to 0x10EA // Inputs[6] // { // @1032 stack[-2] // @1045 memory[0x00:0x40] // @1046 stack[-1] // @1050 memory[0x00:0x40] // @1051 storage[keccak256(memory[0x00:0x40])] // @1055 stack[-3] // } 1029 5B JUMPDEST 102A 60 PUSH1 0x01 102C 60 PUSH1 0xa0 102E 60 PUSH1 0x02 1030 0A EXP 1031 03 SUB 1032 91 SWAP2 1033 82 DUP3 1034 16 AND 1035 60 PUSH1 0x00 1037 90 SWAP1 1038 81 DUP2 1039 52 MSTORE 103A 60 PUSH1 0x04 103C 60 PUSH1 0x20 103E 90 SWAP1 103F 81 DUP2 1040 52 MSTORE 1041 60 PUSH1 0x40 1043 80 DUP1 1044 83 DUP4 1045 20 SHA3 1046 93 SWAP4 1047 90 SWAP1 1048 94 SWAP5 1049 16 AND 104A 82 DUP3 104B 52 MSTORE 104C 91 SWAP2 104D 90 SWAP1 104E 91 SWAP2 104F 52 MSTORE 1050 20 SHA3 1051 54 SLOAD 1052 60 PUSH1 0xff 1054 16 AND 1055 90 SWAP1 1056 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1039 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @1040 memory[0x20:0x40] = 0x04 // @104B memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @104F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1055 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1057: // Incoming call from 0x0699, returns to 0x01DE 1057 5B JUMPDEST 1058 61 PUSH2 0x105f 105B 61 PUSH2 0x0d10 105E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1058 stack[0] = 0x105f } // Block ends with call to 0x0d10, returns to 0x105F label_105F: // Incoming return from call to 0x0D10 at 0x105E // Inputs[1] { @1060 stack[-1] } 105F 5B JUMPDEST 1060 15 ISZERO 1061 15 ISZERO 1062 61 PUSH2 0x106a 1065 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x106a, if !!stack[-1] label_1066: // Incoming jump from 0x1065, if not !!stack[-1] // Inputs[1] { @1069 memory[0x00:0x00] } 1066 60 PUSH1 0x00 1068 80 DUP1 1069 FD *REVERT // Stack delta = +0 // Outputs[1] { @1069 revert(memory[0x00:0x00]); } // Block terminates label_106A: // Incoming jump from 0x1065, if !!stack[-1] // Inputs[1] { @106E stack[-1] } 106A 5B JUMPDEST 106B 61 PUSH2 0x1073 106E 81 DUP2 106F 61 PUSH2 0x1519 1072 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @106B stack[0] = 0x1073 // @106E stack[1] = stack[-1] // } // Block ends with call to 0x1519, returns to 0x1073 label_1073: // Incoming return from call to 0x1519 at 0x1072 // Incoming jump from 0x1972 // Inputs[1] { @1075 stack[-2] } 1073 5B JUMPDEST 1074 50 POP 1075 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1076: // Incoming call from 0x12AC, returns to 0x12AD // Incoming call from 0x0E99, returns to 0x0E9A // Incoming call from 0x0799, returns to 0x079A // Inputs[4] // { // @1079 stack[-1] // @1084 memory[0x00:0x40] // @1085 storage[keccak256(memory[0x00:0x40])] // @1091 stack[-2] // } 1076 5B JUMPDEST 1077 60 PUSH1 0x00 1079 90 SWAP1 107A 81 DUP2 107B 52 MSTORE 107C 60 PUSH1 0x01 107E 60 PUSH1 0x20 1080 52 MSTORE 1081 60 PUSH1 0x40 1083 90 SWAP1 1084 20 SHA3 1085 54 SLOAD 1086 60 PUSH1 0x01 1088 60 PUSH1 0xa0 108A 60 PUSH1 0x02 108C 0A EXP 108D 03 SUB 108E 16 AND 108F 15 ISZERO 1090 15 ISZERO 1091 90 SWAP1 1092 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @107B memory[0x00:0x20] = stack[-1] // @1080 memory[0x20:0x40] = 0x01 // @1091 stack[-2] = !!(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_1093: // Incoming call from 0x0879, returns to 0x087A // Inputs[1] { @109A stack[-1] } 1093 5B JUMPDEST 1094 60 PUSH1 0x00 1096 80 DUP1 1097 61 PUSH2 0x109f 109A 83 DUP4 109B 61 PUSH2 0x0bf4 109E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1094 stack[0] = 0x00 // @1096 stack[1] = 0x00 // @1097 stack[2] = 0x109f // @109A stack[3] = stack[-1] // } // Block ends with call to 0x0bf4, returns to 0x109F label_109F: // Incoming return from call to 0x0BF4 at 0x109E // Inputs[3] // { // @10A0 stack[-2] // @10A0 stack[-1] // @10AC stack[-5] // } 109F 5B JUMPDEST 10A0 90 SWAP1 10A1 50 POP 10A2 80 DUP1 10A3 60 PUSH1 0x01 10A5 60 PUSH1 0xa0 10A7 60 PUSH1 0x02 10A9 0A EXP 10AA 03 SUB 10AB 16 AND 10AC 84 DUP5 10AD 60 PUSH1 0x01 10AF 60 PUSH1 0xa0 10B1 60 PUSH1 0x02 10B3 0A EXP 10B4 03 SUB 10B5 16 AND 10B6 14 EQ 10B7 80 DUP1 10B8 61 PUSH2 0x10da 10BB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @10A0 stack[-2] = stack[-1] // @10B6 stack[-1] = 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x10da, if 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] label_10BC: // Incoming jump from 0x10BB, if not 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] // Inputs[2] // { // @10BD stack[-5] // @10CA stack[-4] // } 10BC 50 POP 10BD 83 DUP4 10BE 60 PUSH1 0x01 10C0 60 PUSH1 0xa0 10C2 60 PUSH1 0x02 10C4 0A EXP 10C5 03 SUB 10C6 16 AND 10C7 61 PUSH2 0x10cf 10CA 84 DUP5 10CB 61 PUSH2 0x078f 10CE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10C6 stack[-1] = 0x02 ** 0xa0 - 0x01 & stack[-5] // @10C7 stack[0] = 0x10cf // @10CA stack[1] = stack[-4] // } // Block ends with call to 0x078f, returns to 0x10CF label_10CF: // Incoming return from call to 0x078F at 0x10CE // Inputs[2] // { // @10D8 stack[-1] // @10D9 stack[-2] // } 10CF 5B JUMPDEST 10D0 60 PUSH1 0x01 10D2 60 PUSH1 0xa0 10D4 60 PUSH1 0x02 10D6 0A EXP 10D7 03 SUB 10D8 16 AND 10D9 14 EQ // Stack delta = -1 // Outputs[1] { @10D9 stack[-2] = 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] } // Block continues label_10DA: // Incoming jump from 0x10BB, if 0x02 ** 0xa0 - 0x01 & stack[-5] == 0x02 ** 0xa0 - 0x01 & stack[-1] // Incoming jump from 0x10D9 // Inputs[1] { @10DB stack[-1] } 10DA 5B JUMPDEST 10DB 80 DUP1 10DC 61 PUSH2 0x10ea 10DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10ea, if stack[-1] label_10E0: // Incoming jump from 0x10DF, if not stack[-1] // Inputs[2] // { // @10E4 stack[-2] // @10E5 stack[-5] // } 10E0 50 POP 10E1 61 PUSH2 0x10ea 10E4 81 DUP2 10E5 85 DUP6 10E6 61 PUSH2 0x1029 10E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10E1 stack[-1] = 0x10ea // @10E4 stack[0] = stack[-2] // @10E5 stack[1] = stack[-5] // } // Block ends with call to 0x1029, returns to 0x10EA label_10EA: // Incoming return from call to 0x1029 at 0x10E9 // Incoming jump from 0x10DF, if stack[-1] // Inputs[3] // { // @10EB stack[-1] // @10EB stack[-6] // @10EC stack[-5] // } 10EA 5B JUMPDEST 10EB 94 SWAP5 10EC 93 SWAP4 10ED 50 POP 10EE 50 POP 10EF 50 POP 10F0 50 POP 10F1 56 *JUMP // Stack delta = -5 // Outputs[1] { @10EB stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_10F2: // Incoming call from 0x08A3, returns to 0x08A4 // Incoming call from 0x1809, returns to 0x180A // Inputs[2] // { // @10F3 stack[-2] // @1100 stack[-1] // } 10F2 5B JUMPDEST 10F3 81 DUP2 10F4 60 PUSH1 0x01 10F6 60 PUSH1 0xa0 10F8 60 PUSH1 0x02 10FA 0A EXP 10FB 03 SUB 10FC 16 AND 10FD 61 PUSH2 0x1105 1100 82 DUP3 1101 61 PUSH2 0x0bf4 1104 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10FC stack[0] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @10FD stack[1] = 0x1105 // @1100 stack[2] = stack[-1] // } // Block ends with call to 0x0bf4, returns to 0x1105 label_1105: // Incoming return from call to 0x0BF4 at 0x1104 // Inputs[2] // { // @110E stack[-1] // @110F stack[-2] // } 1105 5B JUMPDEST 1106 60 PUSH1 0x01 1108 60 PUSH1 0xa0 110A 60 PUSH1 0x02 110C 0A EXP 110D 03 SUB 110E 16 AND 110F 14 EQ 1110 61 PUSH2 0x1118 1113 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1118, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] label_1114: // Incoming jump from 0x1113, if not 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1117 memory[0x00:0x00] } 1114 60 PUSH1 0x00 1116 80 DUP1 1117 FD *REVERT // Stack delta = +0 // Outputs[1] { @1117 revert(memory[0x00:0x00]); } // Block terminates label_1118: // Incoming jump from 0x1113, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @111B stack[-1] // @1126 memory[0x00:0x40] // @1127 storage[keccak256(memory[0x00:0x40])] // } 1118 5B JUMPDEST 1119 60 PUSH1 0x00 111B 81 DUP2 111C 81 DUP2 111D 52 MSTORE 111E 60 PUSH1 0x02 1120 60 PUSH1 0x20 1122 52 MSTORE 1123 60 PUSH1 0x40 1125 90 SWAP1 1126 20 SHA3 1127 54 SLOAD 1128 60 PUSH1 0x01 112A 60 PUSH1 0xa0 112C 60 PUSH1 0x02 112E 0A EXP 112F 03 SUB 1130 16 AND 1131 15 ISZERO 1132 61 PUSH2 0x0fd2 1135 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @111D memory[0x00:0x20] = stack[-1] // @1122 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0fd2, if !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_1136: // Incoming jump from 0x1135, if not !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @1138 stack[-1] // @1143 memory[0x00:0x40] // @1145 storage[keccak256(memory[0x00:0x40])] // @1153 stack[-3] // } 1136 60 PUSH1 0x00 1138 90 SWAP1 1139 81 DUP2 113A 52 MSTORE 113B 60 PUSH1 0x02 113D 60 PUSH1 0x20 113F 52 MSTORE 1140 60 PUSH1 0x40 1142 90 SWAP1 1143 20 SHA3 1144 80 DUP1 1145 54 SLOAD 1146 60 PUSH1 0x01 1148 60 PUSH1 0xa0 114A 60 PUSH1 0x02 114C 0A EXP 114D 03 SUB 114E 19 NOT 114F 16 AND 1150 90 SWAP1 1151 55 SSTORE 1152 50 POP 1153 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @113A memory[0x00:0x20] = stack[-1] // @113F memory[0x20:0x40] = 0x02 // @1151 storage[keccak256(memory[0x00:0x40])] = ~(0x02 ** 0xa0 - 0x01) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1154: // Incoming call from 0x1813, returns to 0x1814 // Incoming call from 0x08AD, returns to 0x08AE // Inputs[2] // { // @115D stack[-2] // @115E stack[-1] // } 1154 5B JUMPDEST 1155 60 PUSH1 0x00 1157 80 DUP1 1158 60 PUSH1 0x00 115A 61 PUSH2 0x1163 115D 85 DUP6 115E 85 DUP6 115F 61 PUSH2 0x158a 1162 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1155 stack[0] = 0x00 // @1157 stack[1] = 0x00 // @1158 stack[2] = 0x00 // @115A stack[3] = 0x1163 // @115D stack[4] = stack[-2] // @115E stack[5] = stack[-1] // } // Block ends with call to 0x158a, returns to 0x1163 label_1163: // Incoming return from call to 0x158A at 0x1162 // Inputs[7] // { // @1166 stack[-4] // @1174 memory[0x00:0x40] // @1175 storage[keccak256(memory[0x00:0x40])] // @117E stack[-5] // @1189 memory[0x00:0x40] // @118A storage[keccak256(memory[0x00:0x40])] // @118C stack[-3] // } 1163 5B JUMPDEST 1164 60 PUSH1 0x00 1166 84 DUP5 1167 81 DUP2 1168 52 MSTORE 1169 60 PUSH1 0x06 116B 60 PUSH1 0x20 116D 90 SWAP1 116E 81 DUP2 116F 52 MSTORE 1170 60 PUSH1 0x40 1172 80 DUP1 1173 83 DUP4 1174 20 SHA3 1175 54 SLOAD 1176 60 PUSH1 0x01 1178 60 PUSH1 0xa0 117A 60 PUSH1 0x02 117C 0A EXP 117D 03 SUB 117E 89 DUP10 117F 16 AND 1180 84 DUP5 1181 52 MSTORE 1182 60 PUSH1 0x05 1184 90 SWAP1 1185 92 SWAP3 1186 52 MSTORE 1187 90 SWAP1 1188 91 SWAP2 1189 20 SHA3 118A 54 SLOAD 118B 90 SWAP1 118C 93 SWAP4 118D 50 POP 118E 61 PUSH2 0x119e 1191 90 SWAP1 1192 60 PUSH1 0x01 1194 63 PUSH4 0xffffffff 1199 61 PUSH2 0x1613 119C 16 AND 119D 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @1168 memory[0x00:0x20] = stack[-4] // @116F memory[0x20:0x40] = 0x06 // @1181 memory[0x00:0x20] = stack[-5] & 0x02 ** 0xa0 - 0x01 // @1186 memory[0x20:0x40] = 0x05 // @118C stack[-3] = storage[keccak256(memory[0x00:0x40])] // @1191 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1191 stack[0] = 0x119e // @1192 stack[2] = 0x01 // } // Block ends with call to 0x1613 & 0xffffffff, returns to 0x119E label_119E: // Incoming return from call to 0x1613 at 0x119D // Inputs[5] // { // @11A7 stack[-6] // @11B6 memory[0x00:0x40] // @11B8 storage[keccak256(memory[0x00:0x40])] // @11B9 stack[-1] // @11BA stack[-3] // } 119E 5B JUMPDEST 119F 60 PUSH1 0x01 11A1 60 PUSH1 0xa0 11A3 60 PUSH1 0x02 11A5 0A EXP 11A6 03 SUB 11A7 86 DUP7 11A8 16 AND 11A9 60 PUSH1 0x00 11AB 90 SWAP1 11AC 81 DUP2 11AD 52 MSTORE 11AE 60 PUSH1 0x05 11B0 60 PUSH1 0x20 11B2 52 MSTORE 11B3 60 PUSH1 0x40 11B5 90 SWAP1 11B6 20 SHA3 11B7 80 DUP1 11B8 54 SLOAD 11B9 91 SWAP2 11BA 93 SWAP4 11BB 50 POP 11BC 90 SWAP1 11BD 83 DUP4 11BE 90 SWAP1 11BF 81 DUP2 11C0 10 LT 11C1 61 PUSH2 0x11c6 11C4 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @11AD memory[0x00:0x20] = stack[-6] & 0x02 ** 0xa0 - 0x01 // @11B2 memory[0x20:0x40] = 0x05 // @11BA stack[-3] = stack[-1] // @11BC stack[-1] = keccak256(memory[0x00:0x40]) // @11BE stack[0] = stack[-1] // } // Block ends with conditional jump to 0x11c6, if stack[-1] < storage[keccak256(memory[0x00:0x40])] label_11C5: // Incoming jump from 0x11C4, if not stack[-1] < storage[keccak256(memory[0x00:0x40])] 11C5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @11C5 assert(); } // Block terminates label_11C6: // Incoming jump from 0x11C4, if stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[9] // { // @11C7 stack[-2] // @11C7 stack[-1] // @11CF memory[0x00:0x20] // @11D1 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @11D2 stack[-3] // @11D9 stack[-7] // @11F9 memory[0x00:0x40] // @11FA stack[-5] // @11FC storage[keccak256(memory[0x00:0x40])] // } 11C6 5B JUMPDEST 11C7 90 SWAP1 11C8 60 PUSH1 0x00 11CA 52 MSTORE 11CB 60 PUSH1 0x20 11CD 60 PUSH1 0x00 11CF 20 SHA3 11D0 01 ADD 11D1 54 SLOAD 11D2 90 SWAP1 11D3 50 POP 11D4 80 DUP1 11D5 60 PUSH1 0x05 11D7 60 PUSH1 0x00 11D9 87 DUP8 11DA 60 PUSH1 0x01 11DC 60 PUSH1 0xa0 11DE 60 PUSH1 0x02 11E0 0A EXP 11E1 03 SUB 11E2 16 AND 11E3 60 PUSH1 0x01 11E5 60 PUSH1 0xa0 11E7 60 PUSH1 0x02 11E9 0A EXP 11EA 03 SUB 11EB 16 AND 11EC 81 DUP2 11ED 52 MSTORE 11EE 60 PUSH1 0x20 11F0 01 ADD 11F1 90 SWAP1 11F2 81 DUP2 11F3 52 MSTORE 11F4 60 PUSH1 0x20 11F6 01 ADD 11F7 60 PUSH1 0x00 11F9 20 SHA3 11FA 84 DUP5 11FB 81 DUP2 11FC 54 SLOAD 11FD 81 DUP2 11FE 10 LT 11FF 15 ISZERO 1200 15 ISZERO 1201 61 PUSH2 0x1206 1204 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @11CA memory[0x00:0x20] = stack[-2] // @11D2 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @11D4 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @11ED memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & 0x02 ** 0xa0 - 0x01 & stack[-7] // @11F3 memory[0x20:0x40] = 0x05 // @11F9 stack[-1] = keccak256(memory[0x00:0x40]) // @11FA stack[0] = stack[-5] // } // Block ends with conditional jump to 0x1206, if !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) label_1205: // Incoming jump from 0x1204, if not !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) 1205 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1205 assert(); } // Block terminates label_1206: // Incoming jump from 0x1204, if !!(stack[-5] < storage[keccak256(memory[0x00:0x40])]) // Inputs[7] // { // @1209 stack[-2] // @1210 memory[0x00:0x20] // @1212 stack[-1] // @1214 stack[-3] // @1220 stack[-8] // @122C memory[0x00:0x40] // @122E storage[keccak256(memory[0x00:0x40])] // } 1206 5B JUMPDEST 1207 60 PUSH1 0x00 1209 91 SWAP2 120A 82 DUP3 120B 52 MSTORE 120C 60 PUSH1 0x20 120E 80 DUP1 120F 83 DUP4 1210 20 SHA3 1211 90 SWAP1 1212 91 SWAP2 1213 01 ADD 1214 92 SWAP3 1215 90 SWAP1 1216 92 SWAP3 1217 55 SSTORE 1218 60 PUSH1 0x01 121A 60 PUSH1 0xa0 121C 60 PUSH1 0x02 121E 0A EXP 121F 03 SUB 1220 87 DUP8 1221 16 AND 1222 81 DUP2 1223 52 MSTORE 1224 60 PUSH1 0x05 1226 90 SWAP1 1227 91 SWAP2 1228 52 MSTORE 1229 60 PUSH1 0x40 122B 90 SWAP1 122C 20 SHA3 122D 80 DUP1 122E 54 SLOAD 122F 90 SWAP1 1230 61 PUSH2 0x123d 1233 90 SWAP1 1234 60 PUSH1 0x00 1236 19 NOT 1237 83 DUP4 1238 01 ADD 1239 61 PUSH2 0x18ab 123C 56 *JUMP // Stack delta = +1 // Outputs[8] // { // @120B memory[0x00:0x20] = stack[-2] // @1217 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @1223 memory[0x00:0x20] = stack[-8] & 0x02 ** 0xa0 - 0x01 // @1228 memory[0x20:0x40] = 0x05 // @122F stack[-3] = storage[keccak256(memory[0x00:0x40])] // @1233 stack[-2] = 0x123d // @1233 stack[-1] = keccak256(memory[0x00:0x40]) // @1238 stack[0] = storage[keccak256(memory[0x00:0x40])] + ~0x00 // } // Block ends with call to 0x18ab, returns to 0x123D label_123D: // Incoming return from call to 0x18AB at 0x123C // Inputs[7] // { // @1241 stack[-5] // @124D memory[0x00:0x40] // @1251 stack[-2] // @1254 stack[-3] // @1256 memory[0x00:0x40] // @1257 stack[-4] // @125A stack[-7] // } 123D 5B JUMPDEST 123E 50 POP 123F 60 PUSH1 0x00 1241 93 SWAP4 1242 84 DUP5 1243 52 MSTORE 1244 60 PUSH1 0x06 1246 60 PUSH1 0x20 1248 52 MSTORE 1249 60 PUSH1 0x40 124B 80 DUP1 124C 85 DUP6 124D 20 SHA3 124E 85 DUP6 124F 90 SWAP1 1250 55 SSTORE 1251 90 SWAP1 1252 84 DUP5 1253 52 MSTORE 1254 90 SWAP1 1255 92 SWAP3 1256 20 SHA3 1257 55 SSTORE 1258 50 POP 1259 50 POP 125A 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @1243 memory[0x00:0x20] = stack[-5] // @1248 memory[0x20:0x40] = 0x06 // @1250 storage[keccak256(memory[0x00:0x40])] = 0x00 // @1253 memory[0x00:0x20] = stack[-2] // @1257 storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_125B: // Incoming call from 0x08B7, returns to 0x08B8 // Incoming call from 0x186E, returns to 0x186F // Inputs[2] // { // @1261 stack[-2] // @1262 stack[-1] // } 125B 5B JUMPDEST 125C 60 PUSH1 0x00 125E 61 PUSH2 0x1267 1261 83 DUP4 1262 83 DUP4 1263 61 PUSH2 0x162a 1266 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @125C stack[0] = 0x00 // @125E stack[1] = 0x1267 // @1261 stack[2] = stack[-2] // @1262 stack[3] = stack[-1] // } // Block ends with call to 0x162a, returns to 0x1267 label_1267: // Incoming return from call to 0x162A at 0x1266 // Inputs[7] // { // @1271 stack[-2] // @1272 stack[-3] // @1284 memory[0x00:0x40] // @1286 storage[keccak256(memory[0x00:0x40])] // @1292 memory[0x00:0x20] // @12A1 memory[0x00:0x40] // @12A3 stack[-4] // } 1267 5B JUMPDEST 1268 50 POP 1269 60 PUSH1 0x01 126B 60 PUSH1 0xa0 126D 60 PUSH1 0x02 126F 0A EXP 1270 03 SUB 1271 90 SWAP1 1272 91 SWAP2 1273 16 AND 1274 60 PUSH1 0x00 1276 90 SWAP1 1277 81 DUP2 1278 52 MSTORE 1279 60 PUSH1 0x05 127B 60 PUSH1 0x20 127D 90 SWAP1 127E 81 DUP2 127F 52 MSTORE 1280 60 PUSH1 0x40 1282 80 DUP1 1283 83 DUP4 1284 20 SHA3 1285 80 DUP1 1286 54 SLOAD 1287 60 PUSH1 0x01 1289 81 DUP2 128A 01 ADD 128B 82 DUP3 128C 55 SSTORE 128D 90 SWAP1 128E 84 DUP5 128F 52 MSTORE 1290 82 DUP3 1291 84 DUP5 1292 20 SHA3 1293 81 DUP2 1294 01 ADD 1295 85 DUP6 1296 90 SWAP1 1297 55 SSTORE 1298 93 SWAP4 1299 83 DUP4 129A 52 MSTORE 129B 60 PUSH1 0x06 129D 90 SWAP1 129E 91 SWAP2 129F 52 MSTORE 12A0 90 SWAP1 12A1 20 SHA3 12A2 55 SSTORE 12A3 56 *JUMP // Stack delta = -4 // Outputs[8] // { // @1278 memory[0x00:0x20] = stack[-3] & 0x02 ** 0xa0 - 0x01 // @127F memory[0x20:0x40] = 0x05 // @128C storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @128F memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @1297 storage[storage[keccak256(memory[0x00:0x40])] + keccak256(memory[0x00:0x20])] = stack[-2] // @129A memory[0x00:0x20] = stack[-2] // @129F memory[0x20:0x40] = 0x06 // @12A2 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_12A4: // Incoming jump from 0x1507 // Incoming jump from 0x09E3 // Inputs[1] { @12A8 stack[-2] } 12A4 5B JUMPDEST 12A5 61 PUSH2 0x12ad 12A8 82 DUP3 12A9 61 PUSH2 0x1076 12AC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12A5 stack[0] = 0x12ad // @12A8 stack[1] = stack[-2] // } // Block ends with call to 0x1076, returns to 0x12AD label_12AD: // Incoming return from call to 0x1076 at 0x12AC // Inputs[1] { @12AE stack[-1] } 12AD 5B JUMPDEST 12AE 15 ISZERO 12AF 15 ISZERO 12B0 61 PUSH2 0x12b8 12B3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12b8, if !!stack[-1] label_12B4: // Incoming jump from 0x12B3, if not !!stack[-1] // Inputs[1] { @12B7 memory[0x00:0x00] } 12B4 60 PUSH1 0x00 12B6 80 DUP1 12B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @12B7 revert(memory[0x00:0x00]); } // Block terminates label_12B8: // Incoming jump from 0x12B3, if !!stack[-1] // Inputs[4] // { // @12BB stack[-2] // @12C9 memory[0x00:0x40] // @12CA stack[-1] // @12CB memory[stack[-1]:stack[-1] + 0x20] // } 12B8 5B JUMPDEST 12B9 60 PUSH1 0x00 12BB 82 DUP3 12BC 81 DUP2 12BD 52 MSTORE 12BE 60 PUSH1 0x0b 12C0 60 PUSH1 0x20 12C2 90 SWAP1 12C3 81 DUP2 12C4 52 MSTORE 12C5 60 PUSH1 0x40 12C7 90 SWAP1 12C8 91 SWAP2 12C9 20 SHA3 12CA 82 DUP3 12CB 51 MLOAD 12CC 61 PUSH2 0x0b42 12CF 92 SWAP3 12D0 84 DUP5 12D1 01 ADD 12D2 90 SWAP1 12D3 61 PUSH2 0x18cf 12D6 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @12BD memory[0x00:0x20] = stack[-2] // @12C4 memory[0x20:0x40] = 0x0b // @12C9 stack[1] = keccak256(memory[0x00:0x40]) // @12CF stack[0] = 0x0b42 // @12D2 stack[2] = stack[-1] + 0x20 // @12D2 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x18cf label_12D7: // Incoming call from 0x0BF3, returns to 0x0B42 // Inputs[2] // { // @12DB stack[-2] // @12DC stack[-1] // } 12D7 5B JUMPDEST 12D8 61 PUSH2 0x12e1 12DB 82 DUP3 12DC 82 DUP3 12DD 61 PUSH2 0x16ad 12E0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12D8 stack[0] = 0x12e1 // @12DB stack[1] = stack[-2] // @12DC stack[2] = stack[-1] // } // Block ends with call to 0x16ad, returns to 0x12E1 label_12E1: // Incoming return from call to 0x16AD at 0x12E0 // Inputs[3] // { // @12E4 stack[-1] // @12EF memory[0x00:0x40] // @12F0 storage[keccak256(memory[0x00:0x40])] // } 12E1 5B JUMPDEST 12E2 60 PUSH1 0x00 12E4 81 DUP2 12E5 81 DUP2 12E6 52 MSTORE 12E7 60 PUSH1 0x0b 12E9 60 PUSH1 0x20 12EB 52 MSTORE 12EC 60 PUSH1 0x40 12EE 90 SWAP1 12EF 20 SHA3 12F0 54 SLOAD 12F1 60 PUSH1 0x02 12F3 60 PUSH1 0x00 12F5 19 NOT 12F6 61 PUSH2 0x0100 12F9 60 PUSH1 0x01 12FB 84 DUP5 12FC 16 AND 12FD 15 ISZERO 12FE 02 MUL 12FF 01 ADD 1300 90 SWAP1 1301 91 SWAP2 1302 16 AND 1303 04 DIV 1304 15 ISZERO 1305 61 PUSH2 0x0fd2 1308 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @12E6 memory[0x00:0x20] = stack[-1] // @12EB memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x0fd2, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_1309: // Incoming jump from 0x1308, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[2] // { // @130B stack[-1] // @1316 memory[0x00:0x40] // } 1309 60 PUSH1 0x00 130B 81 DUP2 130C 81 DUP2 130D 52 MSTORE 130E 60 PUSH1 0x0b 1310 60 PUSH1 0x20 1312 52 MSTORE 1313 60 PUSH1 0x40 1315 81 DUP2 1316 20 SHA3 1317 61 PUSH2 0x0fd2 131A 91 SWAP2 131B 61 PUSH2 0x194d 131E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @130D memory[0x00:0x20] = stack[-1] // @1312 memory[0x20:0x40] = 0x0b // @1316 stack[1] = keccak256(memory[0x00:0x40]) // @131A stack[0] = 0x0fd2 // @131A stack[2] = 0x00 // } // Block ends with call to 0x194d, returns to 0x0FD2 label_131F: // Incoming call from 0x0CC9, returns to 0x0CCA // Inputs[4] // { // @1328 stack[-1] // @1336 memory[0x00:0x40] // @1338 storage[keccak256(memory[0x00:0x40])] // @133F stack[-2] // } 131F 5B JUMPDEST 1320 60 PUSH1 0x01 1322 60 PUSH1 0xa0 1324 60 PUSH1 0x02 1326 0A EXP 1327 03 SUB 1328 16 AND 1329 60 PUSH1 0x00 132B 90 SWAP1 132C 81 DUP2 132D 52 MSTORE 132E 60 PUSH1 0x0d 1330 60 PUSH1 0x20 1332 52 MSTORE 1333 60 PUSH1 0x40 1335 90 SWAP1 1336 20 SHA3 1337 80 DUP1 1338 54 SLOAD 1339 60 PUSH1 0xff 133B 19 NOT 133C 16 AND 133D 90 SWAP1 133E 55 SSTORE 133F 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @132D memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @1332 memory[0x20:0x40] = 0x0d // @133E storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1340: // Incoming call from 0x0FF1, returns to 0x0FF2 // Incoming call from 0x0E5B, returns to 0x0E5C // Inputs[4] // { // @1349 stack[-1] // @1357 memory[0x00:0x40] // @1359 storage[keccak256(memory[0x00:0x40])] // @1363 stack[-2] // } 1340 5B JUMPDEST 1341 60 PUSH1 0x01 1343 60 PUSH1 0xa0 1345 60 PUSH1 0x02 1347 0A EXP 1348 03 SUB 1349 16 AND 134A 60 PUSH1 0x00 134C 90 SWAP1 134D 81 DUP2 134E 52 MSTORE 134F 60 PUSH1 0x0d 1351 60 PUSH1 0x20 1353 52 MSTORE 1354 60 PUSH1 0x40 1356 90 SWAP1 1357 20 SHA3 1358 80 DUP1 1359 54 SLOAD 135A 60 PUSH1 0xff 135C 19 NOT 135D 16 AND 135E 60 PUSH1 0x01 1360 17 OR 1361 90 SWAP1 1362 55 SSTORE 1363 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @134E memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @1353 memory[0x20:0x40] = 0x0d // @1362 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_1364: // Incoming call from 0x0E7D, returns to 0x0E7E // Inputs[1] { @136B stack[-3] } 1364 5B JUMPDEST 1365 60 PUSH1 0x00 1367 80 DUP1 1368 61 PUSH2 0x1379 136B 85 DUP6 136C 60 PUSH1 0x01 136E 60 PUSH1 0xa0 1370 60 PUSH1 0x02 1372 0A EXP 1373 03 SUB 1374 16 AND 1375 61 PUSH2 0x1769 1378 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1365 stack[0] = 0x00 // @1367 stack[1] = 0x00 // @1368 stack[2] = 0x1379 // @1374 stack[3] = 0x02 ** 0xa0 - 0x01 & stack[-3] // } // Block ends with call to 0x1769, returns to 0x1379 label_1379: // Incoming return from call to 0x1769 at 0x1378 // Inputs[1] { @137A stack[-1] } 1379 5B JUMPDEST 137A 15 ISZERO 137B 15 ISZERO 137C 61 PUSH2 0x1388 137F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1388, if !!stack[-1] label_1380: // Incoming jump from 0x137F, if not !!stack[-1] // Inputs[1] { @1382 stack[-2] } 1380 60 PUSH1 0x01 1382 91 SWAP2 1383 50 POP 1384 61 PUSH2 0x14dd 1387 56 *JUMP // Stack delta = +0 // Outputs[1] { @1382 stack[-2] = 0x01 } // Block ends with unconditional jump to 0x14dd label_1388: // Incoming jump from 0x137F, if !!stack[-1] // Inputs[8] // { // @138B memory[0x40:0x60] // @13AF msg.sender // @13BF stack[-6] // @13CB stack[-4] // @13D7 stack[-3] // @13D8 memory[stack[-3]:stack[-3] + 0x20] // @13DF memory[stack[-3]:stack[-3] + 0x20] // @13E1 stack[-5] // } 1388 5B JUMPDEST 1389 60 PUSH1 0x40 138B 51 MLOAD 138C 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 13AD 81 DUP2 13AE 52 MSTORE 13AF 33 CALLER 13B0 60 PUSH1 0x04 13B2 82 DUP3 13B3 01 ADD 13B4 81 DUP2 13B5 81 DUP2 13B6 52 MSTORE 13B7 60 PUSH1 0x01 13B9 60 PUSH1 0xa0 13BB 60 PUSH1 0x02 13BD 0A EXP 13BE 03 SUB 13BF 89 DUP10 13C0 81 DUP2 13C1 16 AND 13C2 60 PUSH1 0x24 13C4 85 DUP6 13C5 01 ADD 13C6 52 MSTORE 13C7 60 PUSH1 0x44 13C9 84 DUP5 13CA 01 ADD 13CB 88 DUP9 13CC 90 SWAP1 13CD 52 MSTORE 13CE 60 PUSH1 0x80 13D0 60 PUSH1 0x64 13D2 85 DUP6 13D3 01 ADD 13D4 90 SWAP1 13D5 81 DUP2 13D6 52 MSTORE 13D7 87 DUP8 13D8 51 MLOAD 13D9 60 PUSH1 0x84 13DB 86 DUP7 13DC 01 ADD 13DD 52 MSTORE 13DE 87 DUP8 13DF 51 MLOAD 13E0 91 SWAP2 13E1 8A DUP11 13E2 16 AND 13E3 94 SWAP5 13E4 63 PUSH4 0x150b7a02 13E9 94 SWAP5 13EA 93 SWAP4 13EB 8C DUP13 13EC 93 SWAP4 13ED 8B DUP12 13EE 93 SWAP4 13EF 8B DUP12 13F0 93 SWAP4 13F1 90 SWAP1 13F2 91 SWAP2 13F3 60 PUSH1 0xa4 13F5 90 SWAP1 13F6 91 SWAP2 13F7 01 ADD 13F8 90 SWAP1 13F9 60 PUSH1 0x20 13FB 85 DUP6 13FC 01 ADD 13FD 90 SWAP1 13FE 80 DUP1 13FF 83 DUP4 1400 83 DUP4 1401 60 PUSH1 0x00 1403 5B JUMPDEST 1404 83 DUP4 1405 81 DUP2 1406 10 LT 1407 15 ISZERO 1408 61 PUSH2 0x141b 140B 57 *JUMPI // Stack delta = +15 // Outputs[21] // { // @13AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x150b7a0200000000000000000000000000000000000000000000000000000000 // @13B6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @13C6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 ** 0xa0 - 0x01 & stack[-6] // @13CD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-4] // @13D6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x80 // @13DD memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @13E3 stack[0] = stack[-5] & 0x02 ** 0xa0 - 0x01 // @13E9 stack[1] = 0x150b7a02 // @13EA stack[2] = msg.sender // @13EA stack[6] = memory[0x40:0x60] + 0x04 // @13EC stack[3] = stack[-6] // @13EE stack[4] = stack[-4] // @13F0 stack[5] = stack[-3] // @13F2 stack[7] = memory[0x40:0x60] + 0x64 // @13F8 stack[8] = memory[0x40:0x60] + 0xa4 // @13FD stack[10] = memory[stack[-3]:stack[-3] + 0x20] // @13FD stack[9] = stack[-3] + 0x20 // @13FE stack[11] = memory[stack[-3]:stack[-3] + 0x20] // @13FF stack[12] = memory[0x40:0x60] + 0xa4 // @1400 stack[13] = stack[-3] + 0x20 // @1401 stack[14] = 0x00 // } // Block ends with conditional jump to 0x141b, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_140C: // Incoming jump from 0x140B, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x140B, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @140C stack[-2] // @140D stack[-1] // @140F memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1410 stack[-3] // } 140C 81 DUP2 140D 81 DUP2 140E 01 ADD 140F 51 MLOAD 1410 83 DUP4 1411 82 DUP3 1412 01 ADD 1413 52 MSTORE 1414 60 PUSH1 0x20 1416 01 ADD 1417 61 PUSH2 0x1403 141A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1413 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1416 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1403 label_141B: // Incoming jump from 0x140B, if !(stack[-1] < stack[-4]) // Incoming jump from 0x140B, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @1420 stack[-6] // @1420 stack[-5] // @1422 stack[-7] // } 141B 5B JUMPDEST 141C 50 POP 141D 50 POP 141E 50 POP 141F 50 POP 1420 90 SWAP1 1421 50 POP 1422 90 SWAP1 1423 81 DUP2 1424 01 ADD 1425 90 SWAP1 1426 60 PUSH1 0x1f 1428 16 AND 1429 80 DUP1 142A 15 ISZERO 142B 61 PUSH2 0x1448 142E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1425 stack[-7] = stack[-5] + stack[-7] // @1428 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1448, if !(0x1f & stack[-5]) label_142F: // Incoming jump from 0x142E, if not !(0x1f & stack[-5]) // Inputs[7] // { // @142F stack[-1] // @1430 stack[-2] // @1433 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @144A stack[-8] // @1455 memory[0x40:0x60] // @145C stack[-10] // @145E address(stack[-10]).code.length // } 142F 80 DUP1 1430 82 DUP3 1431 03 SUB 1432 80 DUP1 1433 51 MLOAD 1434 60 PUSH1 0x01 1436 83 DUP4 1437 60 PUSH1 0x20 1439 03 SUB 143A 61 PUSH2 0x0100 143D 0A EXP 143E 03 SUB 143F 19 NOT 1440 16 AND 1441 81 DUP2 1442 52 MSTORE 1443 60 PUSH1 0x20 1445 01 ADD 1446 91 SWAP2 1447 50 POP 1448 5B JUMPDEST 1449 50 POP 144A 95 SWAP6 144B 50 POP 144C 50 POP 144D 50 POP 144E 50 POP 144F 50 POP 1450 50 POP 1451 60 PUSH1 0x20 1453 60 PUSH1 0x40 1455 51 MLOAD 1456 80 DUP1 1457 83 DUP4 1458 03 SUB 1459 81 DUP2 145A 60 PUSH1 0x00 145C 87 DUP8 145D 80 DUP1 145E 3B EXTCODESIZE 145F 15 ISZERO 1460 80 DUP1 1461 15 ISZERO 1462 61 PUSH2 0x146a 1465 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1442 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] // @144A stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @1451 stack[-7] = 0x20 // @1455 stack[-6] = memory[0x40:0x60] // @1458 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @1459 stack[-4] = memory[0x40:0x60] // @145A stack[-3] = 0x00 // @145C stack[-2] = stack[-10] // @145F stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x146a, if !!address(stack[-10]).code.length label_1466: // Incoming jump from 0x1465, if not !!address(stack[-10]).code.length // Incoming jump from 0x1465, if not !!address(stack[-10]).code.length // Inputs[1] { @1469 memory[0x00:0x00] } 1466 60 PUSH1 0x00 1468 80 DUP1 1469 FD *REVERT // Stack delta = +0 // Outputs[1] { @1469 revert(memory[0x00:0x00]); } // Block terminates label_146A: // Incoming jump from 0x1465, if !!address(stack[-10]).code.length // Incoming jump from 0x1465, if !!address(stack[-10]).code.length // Inputs[9] // { // @146C msg.gas // @146D stack[-7] // @146D address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @146D stack[-5] // @146D stack[-2] // @146D stack[-3] // @146D stack[-6] // @146D memory[stack[-4]:stack[-4] + stack[-5]] // @146D stack[-4] // } 146A 5B JUMPDEST 146B 50 POP 146C 5A GAS 146D F1 CALL 146E 15 ISZERO 146F 80 DUP1 1470 15 ISZERO 1471 61 PUSH2 0x147e 1474 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @146D memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @146E 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 0x147e, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1475: // Incoming jump from 0x1474, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1475 returndata.length // @1479 returndata[0x00:0x00 + returndata.length] // @147A returndata.length // @147D memory[0x00:0x00 + returndata.length] // } 1475 3D RETURNDATASIZE 1476 60 PUSH1 0x00 1478 80 DUP1 1479 3E RETURNDATACOPY 147A 3D RETURNDATASIZE 147B 60 PUSH1 0x00 147D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1479 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @147D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_147E: // Incoming jump from 0x1474, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1485 memory[0x40:0x60] // @1486 returndata.length // } 147E 5B JUMPDEST 147F 50 POP 1480 50 POP 1481 50 POP 1482 50 POP 1483 60 PUSH1 0x40 1485 51 MLOAD 1486 3D RETURNDATASIZE 1487 60 PUSH1 0x20 1489 81 DUP2 148A 10 LT 148B 15 ISZERO 148C 61 PUSH2 0x1494 148F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1485 stack[-4] = memory[0x40:0x60] // @1486 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1494, if !(returndata.length < 0x20) label_1490: // Incoming jump from 0x148F, if not !(returndata.length < 0x20) // Inputs[1] { @1493 memory[0x00:0x00] } 1490 60 PUSH1 0x00 1492 80 DUP1 1493 FD *REVERT // Stack delta = +0 // Outputs[1] { @1493 revert(memory[0x00:0x00]); } // Block terminates label_1494: // Incoming jump from 0x148F, if !(returndata.length < 0x20) // Inputs[4] // { // @1496 stack[-2] // @1496 memory[stack[-2]:stack[-2] + 0x20] // @14D9 stack[-4] // @14DB stack[-3] // } 1494 5B JUMPDEST 1495 50 POP 1496 51 MLOAD 1497 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 14B4 19 NOT 14B5 81 DUP2 14B6 16 AND 14B7 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 14D8 14 EQ 14D9 92 SWAP3 14DA 50 POP 14DB 90 SWAP1 14DC 50 POP // Stack delta = -2 // Outputs[2] // { // @14D9 stack[-4] = 0x150b7a0200000000000000000000000000000000000000000000000000000000 == memory[stack[-2]:stack[-2] + 0x20] & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @14DB stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block continues label_14DD: // Incoming jump from 0x1387 // Incoming jump from 0x14DC // Inputs[3] // { // @14DF stack[-2] // @14DF stack[-7] // @14E0 stack[-6] // } 14DD 5B JUMPDEST 14DE 50 POP 14DF 94 SWAP5 14E0 93 SWAP4 14E1 50 POP 14E2 50 POP 14E3 50 POP 14E4 50 POP 14E5 56 *JUMP // Stack delta = -6 // Outputs[1] { @14DF stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_14E6: // Incoming jump from 0x0FD1 // Inputs[2] // { // @14EA storage[0x10] // @14F8 stack[-1] // } 14E6 5B JUMPDEST 14E7 60 PUSH1 0x10 14E9 80 DUP1 14EA 54 SLOAD 14EB 60 PUSH1 0x01 14ED 81 DUP2 14EE 01 ADD 14EF 90 SWAP1 14F0 91 SWAP2 14F1 55 SSTORE 14F2 60 PUSH1 0x00 14F4 90 SWAP1 14F5 61 PUSH2 0x14fe 14F8 83 DUP4 14F9 82 DUP3 14FA 61 PUSH2 0x1771 14FD 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @14F1 storage[0x10] = storage[0x10] + 0x01 // @14F4 stack[0] = 0x00 // @14F4 stack[1] = storage[0x10] // @14F5 stack[2] = 0x14fe // @14F8 stack[3] = stack[-1] // @14F9 stack[4] = storage[0x10] // } // Block ends with call to 0x1771, returns to 0x14FE label_14FE: // Incoming return from call to 0x1771 at 0x14FD // Inputs[2] // { // @1502 stack[-1] // @1503 stack[-4] // } 14FE 5B JUMPDEST 14FF 61 PUSH2 0x1508 1502 81 DUP2 1503 85 DUP6 1504 61 PUSH2 0x12a4 1507 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14FF stack[0] = 0x1508 // @1502 stack[1] = stack[-1] // @1503 stack[2] = stack[-4] // } // Block ends with unconditional jump to 0x12a4 1508 5B JUMPDEST 1509 61 PUSH2 0x1512 150C 81 DUP2 150D 84 DUP5 150E 61 PUSH2 0x17c0 1511 56 *JUMP label_1512: // Incoming jump from 0x17FB, if !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @1513 stack[-1] // @1513 stack[-5] // @1514 stack[-4] // } 1512 5B JUMPDEST 1513 93 SWAP4 1514 92 SWAP3 1515 50 POP 1516 50 POP 1517 50 POP 1518 56 *JUMP // Stack delta = -4 // Outputs[1] { @1513 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1519: // Incoming call from 0x1072, returns to 0x1073 // Inputs[1] { @1522 stack[-1] } 1519 5B JUMPDEST 151A 60 PUSH1 0x01 151C 60 PUSH1 0xa0 151E 60 PUSH1 0x02 1520 0A EXP 1521 03 SUB 1522 81 DUP2 1523 16 AND 1524 15 ISZERO 1525 15 ISZERO 1526 61 PUSH2 0x152e 1529 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x152e, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) label_152A: // Incoming jump from 0x1529, if not !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @152D memory[0x00:0x00] } 152A 60 PUSH1 0x00 152C 80 DUP1 152D FD *REVERT // Stack delta = +0 // Outputs[1] { @152D revert(memory[0x00:0x00]); } // Block terminates label_152E: // Incoming jump from 0x1529, if !!(stack[-1] & 0x02 ** 0xa0 - 0x01) // Inputs[6] // { // @1531 storage[0x0c] // @1534 memory[0x40:0x60] // @153E stack[-1] // @1568 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @156C storage[0x0c] // @1589 stack[-2] // } 152E 5B JUMPDEST 152F 60 PUSH1 0x0c 1531 54 SLOAD 1532 60 PUSH1 0x40 1534 51 MLOAD 1535 60 PUSH1 0x01 1537 60 PUSH1 0xa0 1539 60 PUSH1 0x02 153B 0A EXP 153C 03 SUB 153D 80 DUP1 153E 84 DUP5 153F 16 AND 1540 92 SWAP3 1541 16 AND 1542 90 SWAP1 1543 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1564 90 SWAP1 1565 60 PUSH1 0x00 1567 90 SWAP1 1568 A3 LOG3 1569 60 PUSH1 0x0c 156B 80 DUP1 156C 54 SLOAD 156D 60 PUSH1 0x01 156F 60 PUSH1 0xa0 1571 60 PUSH1 0x02 1573 0A EXP 1574 03 SUB 1575 19 NOT 1576 16 AND 1577 60 PUSH1 0x01 1579 60 PUSH1 0xa0 157B 60 PUSH1 0x02 157D 0A EXP 157E 03 SUB 157F 92 SWAP3 1580 90 SWAP1 1581 92 SWAP3 1582 16 AND 1583 91 SWAP2 1584 90 SWAP1 1585 91 SWAP2 1586 17 OR 1587 90 SWAP1 1588 55 SSTORE 1589 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1568 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0c] & 0x02 ** 0xa0 - 0x01, stack[-1] & 0x02 ** 0xa0 - 0x01]); // @1588 storage[0x0c] = (0x02 ** 0xa0 - 0x01 & stack[-1]) | (~(0x02 ** 0xa0 - 0x01) & storage[0x0c]) // } // Block ends with unconditional jump to stack[-2] label_158A: // Incoming call from 0x1162, returns to 0x1163 // Inputs[2] // { // @158B stack[-2] // @1598 stack[-1] // } 158A 5B JUMPDEST 158B 81 DUP2 158C 60 PUSH1 0x01 158E 60 PUSH1 0xa0 1590 60 PUSH1 0x02 1592 0A EXP 1593 03 SUB 1594 16 AND 1595 61 PUSH2 0x159d 1598 82 DUP3 1599 61 PUSH2 0x0bf4 159C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1594 stack[0] = 0x02 ** 0xa0 - 0x01 & stack[-2] // @1595 stack[1] = 0x159d // @1598 stack[2] = stack[-1] // } // Block ends with call to 0x0bf4, returns to 0x159D label_159D: // Incoming return from call to 0x0BF4 at 0x159C // Inputs[2] // { // @15A6 stack[-1] // @15A7 stack[-2] // } 159D 5B JUMPDEST 159E 60 PUSH1 0x01 15A0 60 PUSH1 0xa0 15A2 60 PUSH1 0x02 15A4 0A EXP 15A5 03 SUB 15A6 16 AND 15A7 14 EQ 15A8 61 PUSH2 0x15b0 15AB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x15b0, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] label_15AC: // Incoming jump from 0x15AB, if not 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @15AF memory[0x00:0x00] } 15AC 60 PUSH1 0x00 15AE 80 DUP1 15AF FD *REVERT // Stack delta = +0 // Outputs[1] { @15AF revert(memory[0x00:0x00]); } // Block terminates label_15B0: // Incoming jump from 0x15AB, if 0x02 ** 0xa0 - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @15B9 stack[-2] // @15C8 memory[0x00:0x40] // @15C9 storage[keccak256(memory[0x00:0x40])] // } 15B0 5B JUMPDEST 15B1 60 PUSH1 0x01 15B3 60 PUSH1 0xa0 15B5 60 PUSH1 0x02 15B7 0A EXP 15B8 03 SUB 15B9 82 DUP3 15BA 16 AND 15BB 60 PUSH1 0x00 15BD 90 SWAP1 15BE 81 DUP2 15BF 52 MSTORE 15C0 60 PUSH1 0x03 15C2 60 PUSH1 0x20 15C4 52 MSTORE 15C5 60 PUSH1 0x40 15C7 90 SWAP1 15C8 20 SHA3 15C9 54 SLOAD 15CA 61 PUSH2 0x15da 15CD 90 SWAP1 15CE 60 PUSH1 0x01 15D0 63 PUSH4 0xffffffff 15D5 61 PUSH2 0x1613 15D8 16 AND 15D9 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @15BF memory[0x00:0x20] = stack[-2] & 0x02 ** 0xa0 - 0x01 // @15C4 memory[0x20:0x40] = 0x03 // @15CD stack[0] = 0x15da // @15CD stack[1] = storage[keccak256(memory[0x00:0x40])] // @15CE stack[2] = 0x01 // } // Block ends with call to 0x1613 & 0xffffffff, returns to 0x15DA label_15DA: // Incoming return from call to 0x1613 at 0x15D9 // Inputs[7] // { // @15E3 stack[-1] // @15E4 stack[-3] // @15F6 memory[0x00:0x40] // @15FB stack[-2] // @1603 memory[0x00:0x40] // @1605 storage[keccak256(memory[0x00:0x40])] // @1612 stack[-4] // } 15DA 5B JUMPDEST 15DB 60 PUSH1 0x01 15DD 60 PUSH1 0xa0 15DF 60 PUSH1 0x02 15E1 0A EXP 15E2 03 SUB 15E3 90 SWAP1 15E4 92 SWAP3 15E5 16 AND 15E6 60 PUSH1 0x00 15E8 90 SWAP1 15E9 81 DUP2 15EA 52 MSTORE 15EB 60 PUSH1 0x03 15ED 60 PUSH1 0x20 15EF 90 SWAP1 15F0 81 DUP2 15F1 52 MSTORE 15F2 60 PUSH1 0x40 15F4 80 DUP1 15F5 83 DUP4 15F6 20 SHA3 15F7 94 SWAP5 15F8 90 SWAP1 15F9 94 SWAP5 15FA 55 SSTORE 15FB 91 SWAP2 15FC 81 DUP2 15FD 52 MSTORE 15FE 60 PUSH1 0x01 1600 90 SWAP1 1601 91 SWAP2 1602 52 MSTORE 1603 20 SHA3 1604 80 DUP1 1605 54 SLOAD 1606 60 PUSH1 0x01 1608 60 PUSH1 0xa0 160A 60 PUSH1 0x02 160C 0A EXP 160D 03 SUB 160E 19 NOT 160F 16 AND 1610 90 SWAP1 1611 55 SSTORE 1612 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @15EA memory[0x00:0x20] = stack[-3] & 0x02 ** 0xa0 - 0x01 // @15F1 memory[0x20:0x40] = 0x03 // @15FA storage[keccak256(memory[0x00:0x40])] = stack[-1] // @15FD memory[0x00:0x20] = stack[-2] // @1602 memory[0x20:0x40] = 0x01 // @1611 storage[keccak256(memory[0x00:0x40])] = ~(0x02 ** 0xa0 - 0x01) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_1613: // Incoming call from 0x119D, returns to 0x119E // Incoming call from 0x16E1, returns to 0x16E2 // Incoming call from 0x15D9, returns to 0x15DA // Inputs[2] // { // @1617 stack[-2] // @1618 stack[-1] // } 1613 5B JUMPDEST 1614 60 PUSH1 0x00 1616 80 DUP1 1617 83 DUP4 1618 83 DUP4 1619 11 GT 161A 15 ISZERO 161B 61 PUSH2 0x1623 161E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1614 stack[0] = 0x00 // @1616 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1623, if !(stack[-1] > stack[-2]) label_161F: // Incoming jump from 0x161E, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1622 memory[0x00:0x00] } 161F 60 PUSH1 0x00 1621 80 DUP1 1622 FD *REVERT // Stack delta = +0 // Outputs[1] { @1622 revert(memory[0x00:0x00]); } // Block terminates label_1623: // Incoming jump from 0x161E, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @1626 stack[-4] // @1626 stack[-3] // @1628 stack[-5] // } 1623 5B JUMPDEST 1624 50 POP 1625 50 POP 1626 90 SWAP1 1627 03 SUB 1628 90 SWAP1 1629 56 *JUMP // Stack delta = -4 // Outputs[1] { @1628 stack[-5] = stack[-4] - stack[-3] } // Block ends with unconditional jump to stack[-5] label_162A: // Incoming call from 0x1266, returns to 0x1267 // Inputs[3] // { // @162D stack[-1] // @1638 memory[0x00:0x40] // @1639 storage[keccak256(memory[0x00:0x40])] // } 162A 5B JUMPDEST 162B 60 PUSH1 0x00 162D 81 DUP2 162E 81 DUP2 162F 52 MSTORE 1630 60 PUSH1 0x01 1632 60 PUSH1 0x20 1634 52 MSTORE 1635 60 PUSH1 0x40 1637 90 SWAP1 1638 20 SHA3 1639 54 SLOAD 163A 60 PUSH1 0x01 163C 60 PUSH1 0xa0 163E 60 PUSH1 0x02 1640 0A EXP 1641 03 SUB 1642 16 AND 1643 15 ISZERO 1644 61 PUSH2 0x164c 1647 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @162F memory[0x00:0x20] = stack[-1] // @1634 memory[0x20:0x40] = 0x01 // } // Block ends with conditional jump to 0x164c, if !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_1648: // Incoming jump from 0x1647, if not !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @164B memory[0x00:0x00] } 1648 60 PUSH1 0x00 164A 80 DUP1 164B FD *REVERT // Stack delta = +0 // Outputs[1] { @164B revert(memory[0x00:0x00]); } // Block terminates label_164C: // Incoming jump from 0x1647, if !(0x02 ** 0xa0 - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[6] // { // @164F stack[-1] // @165D memory[0x00:0x40] // @165F storage[keccak256(memory[0x00:0x40])] // @1672 stack[-2] // @1683 memory[0x00:0x40] // @1684 storage[keccak256(memory[0x00:0x40])] // } 164C 5B JUMPDEST 164D 60 PUSH1 0x00 164F 81 DUP2 1650 81 DUP2 1651 52 MSTORE 1652 60 PUSH1 0x01 1654 60 PUSH1 0x20 1656 81 DUP2 1657 81 DUP2 1658 52 MSTORE 1659 60 PUSH1 0x40 165B 80 DUP1 165C 84 DUP5 165D 20 SHA3 165E 80 DUP1 165F 54 SLOAD 1660 60 PUSH1 0x01 1662 60 PUSH1 0xa0 1664 60 PUSH1 0x02 1666 0A EXP 1667 03 SUB 1668 19 NOT 1669 16 AND 166A 60 PUSH1 0x01 166C 60 PUSH1 0xa0 166E 60 PUSH1 0x02 1670 0A EXP 1671 03 SUB 1672 88 DUP9 1673 16 AND 1674 90 SWAP1 1675 81 DUP2 1676 17 OR 1677 90 SWAP1 1678 91 SWAP2 1679 55 SSTORE 167A 84 DUP5 167B 52 MSTORE 167C 60 PUSH1 0x03 167E 90 SWAP1 167F 91 SWAP2 1680 52 MSTORE 1681 90 SWAP1 1682 91 SWAP2 1683 20 SHA3 1684 54 SLOAD 1685 61 PUSH2 0x168d 1688 91 SWAP2 1689 61 PUSH2 0x17ee 168C 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @1651 memory[0x00:0x20] = stack[-1] // @1658 memory[0x20:0x40] = 0x01 // @1679 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & 0x02 ** 0xa0 - 0x01) | (~(0x02 ** 0xa0 - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @167B memory[0x00:0x20] = stack[-2] & 0x02 ** 0xa0 - 0x01 // @1680 memory[0x20:0x40] = 0x03 // @1684 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1688 stack[0] = 0x168d // @1688 stack[2] = 0x01 // } // Block ends with call to 0x17ee, returns to 0x168D label_168D: // Incoming return from call to 0x17EE at 0x168C // Inputs[5] // { // @1696 stack[-1] // @1697 stack[-3] // @16A6 memory[0x00:0x40] // @16A8 stack[-2] // @16AC stack[-4] // } 168D 5B JUMPDEST 168E 60 PUSH1 0x01 1690 60 PUSH1 0xa0 1692 60 PUSH1 0x02 1694 0A EXP 1695 03 SUB 1696 90 SWAP1 1697 92 SWAP3 1698 16 AND 1699 60 PUSH1 0x00 169B 90 SWAP1 169C 81 DUP2 169D 52 MSTORE 169E 60 PUSH1 0x03 16A0 60 PUSH1 0x20 16A2 52 MSTORE 16A3 60 PUSH1 0x40 16A5 90 SWAP1 16A6 20 SHA3 16A7 91 SWAP2 16A8 90 SWAP1 16A9 91 SWAP2 16AA 55 SSTORE 16AB 50 POP 16AC 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @169D memory[0x00:0x20] = stack[-3] & 0x02 ** 0xa0 - 0x01 // @16A2 memory[0x20:0x40] = 0x03 // @16AA storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-4] label_16AD: // Incoming call from 0x12E0, returns to 0x12E1 // Inputs[2] // { // @16B6 stack[-2] // @16B7 stack[-1] // } 16AD 5B JUMPDEST 16AE 60 PUSH1 0x00 16B0 80 DUP1 16B1 60 PUSH1 0x00 16B3 61 PUSH2 0x16bc 16B6 85 DUP6 16B7 85 DUP6 16B8 61 PUSH2 0x1800 16BB 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @16AE stack[0] = 0x00 // @16B0 stack[1] = 0x00 // @16B1 stack[2] = 0x00 // @16B3 stack[3] = 0x16bc // @16B6 stack[4] = stack[-2] // @16B7 stack[5] = stack[-1] // } // Block ends with call to 0x1800, returns to 0x16BC label_16BC: // Incoming return from call to 0x1800 at 0x16BB // Inputs[5] // { // @16BF stack[-4] // @16CA memory[0x00:0x40] // @16CB storage[keccak256(memory[0x00:0x40])] // @16CE storage[0x07] // @16D0 stack[-3] // } 16BC 5B JUMPDEST 16BD 60 PUSH1 0x00 16BF 84 DUP5 16C0 81 DUP2 16C1 52 MSTORE 16C2 60 PUSH1 0x08 16C4 60 PUSH1 0x20 16C6 52 MSTORE 16C7 60 PUSH1 0x40 16C9 90 SWAP1 16CA 20 SHA3 16CB 54 SLOAD 16CC 60 PUSH1 0x07 16CE 54 SLOAD 16CF 90 SWAP1 16D0 93 SWAP4 16D1 50 POP 16D2 61 PUSH2 0x16e2 16D5 90 SWAP1 16D6 60 PUSH1 0x01 16D8 63 PUSH4 0xffffffff 16DD 61 PUSH2 0x1613 16E0 16 AND 16E1 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @16C1 memory[0x00:0x20] = stack[-4] // @16C6 memory[0x20:0x40] = 0x08 // @16D0 stack[-3] = storage[keccak256(memory[0x00:0x40])] // @16D5 stack[1] = storage[0x07] // @16D5 stack[0] = 0x16e2 // @16D6 stack[2] = 0x01 // } // Block ends with call to 0x1613 & 0xffffffff, returns to 0x16E2 label_16E2: // Incoming return from call to 0x1613 at 0x16E1 // Inputs[3] // { // @16E3 stack[-3] // @16E3 stack[-1] // @16E9 storage[0x07] // } 16E2 5B JUMPDEST 16E3 91 SWAP2 16E4 50 POP 16E5 60 PUSH1 0x07 16E7 82 DUP3 16E8 81 DUP2 16E9 54 SLOAD 16EA 81 DUP2 16EB 10 LT 16EC 15 ISZERO 16ED 15 ISZERO 16EE 61 PUSH2 0x16f3 16F1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @16E3 stack[-3] = stack[-1] // @16E5 stack[-1] = 0x07 // @16E7 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x16f3, if !!(stack[-1] < storage[0x07]) label_16F2: // Incoming jump from 0x16F1, if not !!(stack[-1] < storage[0x07]) 16F2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @16F2 assert(); } // Block terminates label_16F3: // Incoming jump from 0x16F1, if !!(stack[-1] < storage[0x07]) // Inputs[7] // { // @16F4 stack[-2] // @16F4 stack[-1] // @16FC memory[0x00:0x20] // @16FE storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @16FF stack[-3] // @1704 stack[-5] // @1706 storage[0x07] // } 16F3 5B JUMPDEST 16F4 90 SWAP1 16F5 60 PUSH1 0x00 16F7 52 MSTORE 16F8 60 PUSH1 0x20 16FA 60 PUSH1 0x00 16FC 20 SHA3 16FD 01 ADD 16FE 54 SLOAD 16FF 90 SWAP1 1700 50 POP 1701 80 DUP1 1702 60 PUSH1 0x07 1704 84 DUP5 1705 81 DUP2 1706 54 SLOAD 1707 81 DUP2 1708 10 LT 1709 15 ISZERO 170A 15 ISZERO 170B 61 PUSH2 0x1710 170E 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @16F7 memory[0x00:0x20] = stack[-2] // @16FF stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1701 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1702 stack[-1] = 0x07 // @1704 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x1710, if !!(stack[-5] < storage[0x07]) label_170F: // Incoming jump from 0x170E, if not !!(stack[-5] < storage[0x07]) 170F FE *ASSERT // Stack delta = +0 // Outputs[1] { @170F assert(); } // Block terminates label_1710: // Incoming jump from 0x170E, if !!(stack[-5] < storage[0x07]) // Inputs[6] // { // @1713 stack[-2] // @1719 memory[0x00:0x20] // @171A stack[-1] // @171B stack[-3] // @1722 storage[0x07] // @1723 stack[-5] // } 1710 5B JUMPDEST 1711 60 PUSH1 0x00 1713 91 SWAP2 1714 82 DUP3 1715 52 MSTORE 1716 60 PUSH1 0x20 1718 82 DUP3 1719 20 SHA3 171A 01 ADD 171B 91 SWAP2 171C 90 SWAP1 171D 91 SWAP2 171E 55 SSTORE 171F 60 PUSH1 0x07 1721 80 DUP1 1722 54 SLOAD 1723 84 DUP5 1724 90 SWAP1 1725 81 DUP2 1726 10 LT 1727 61 PUSH2 0x172c 172A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1715 memory[0x00:0x20] = stack[-2] // @171D stack[-3] = 0x00 // @171E storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @171F stack[-2] = 0x07 // @1724 stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x172c, if stack[-5] < storage[0x07] label_172B: // Incoming jump from 0x172A, if not stack[-5] < storage[0x07] 172B FE *ASSERT // Stack delta = +0 // Outputs[1] { @172B assert(); } // Block terminates label_172C: // Incoming jump from 0x172A, if stack[-5] < storage[0x07] // Inputs[5] // { // @172F stack[-2] // @1734 stack[-1] // @1736 memory[0x00:0x20] // @1738 stack[-3] // @173C storage[0x07] // } 172C 5B JUMPDEST 172D 60 PUSH1 0x00 172F 91 SWAP2 1730 82 DUP3 1731 52 MSTORE 1732 60 PUSH1 0x20 1734 90 SWAP1 1735 91 SWAP2 1736 20 SHA3 1737 01 ADD 1738 55 SSTORE 1739 60 PUSH1 0x07 173B 80 DUP1 173C 54 SLOAD 173D 90 SWAP1 173E 61 PUSH2 0x174b 1741 90 SWAP1 1742 60 PUSH1 0x00 1744 19 NOT 1745 83 DUP4 1746 01 ADD 1747 61 PUSH2 0x18ab 174A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1731 memory[0x00:0x20] = stack[-2] // @1738 storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @173D stack[-3] = storage[0x07] // @1741 stack[-2] = 0x174b // @1741 stack[-1] = 0x07 // @1746 stack[0] = storage[0x07] + ~0x00 // } // Block ends with call to 0x18ab, returns to 0x174B label_174B: // Incoming return from call to 0x18AB at 0x174A // Inputs[7] // { // @174F stack[-5] // @175B memory[0x00:0x40] // @175F stack[-2] // @1762 stack[-3] // @1764 memory[0x00:0x40] // @1765 stack[-4] // @1768 stack[-7] // } 174B 5B JUMPDEST 174C 50 POP 174D 60 PUSH1 0x00 174F 93 SWAP4 1750 84 DUP5 1751 52 MSTORE 1752 60 PUSH1 0x08 1754 60 PUSH1 0x20 1756 52 MSTORE 1757 60 PUSH1 0x40 1759 80 DUP1 175A 85 DUP6 175B 20 SHA3 175C 85 DUP6 175D 90 SWAP1 175E 55 SSTORE 175F 90 SWAP1 1760 84 DUP5 1761 52 MSTORE 1762 90 SWAP1 1763 92 SWAP3 1764 20 SHA3 1765 55 SSTORE 1766 50 POP 1767 50 POP 1768 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @1751 memory[0x00:0x20] = stack[-5] // @1756 memory[0x20:0x40] = 0x08 // @175E storage[keccak256(memory[0x00:0x40])] = 0x00 // @1761 memory[0x00:0x20] = stack[-2] // @1765 storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1769: // Incoming call from 0x1378, returns to 0x1379 // Inputs[3] // { // @176C stack[-1] // @176D address(stack[-1]).code.length // @176F stack[-2] // } 1769 5B JUMPDEST 176A 60 PUSH1 0x00 176C 90 SWAP1 176D 3B EXTCODESIZE 176E 11 GT 176F 90 SWAP1 1770 56 *JUMP // Stack delta = -1 // Outputs[1] { @176F stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_1771: // Incoming call from 0x14FD, returns to 0x14FE // Inputs[2] // { // @1775 stack[-2] // @1776 stack[-1] // } 1771 5B JUMPDEST 1772 61 PUSH2 0x177b 1775 82 DUP3 1776 82 DUP3 1777 61 PUSH2 0x1850 177A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1772 stack[0] = 0x177b // @1775 stack[1] = stack[-2] // @1776 stack[2] = stack[-1] // } // Block ends with call to 0x1850, returns to 0x177B label_177B: // Incoming return from call to 0x1850 at 0x177A // Inputs[4] // { // @177F storage[0x07] // @1782 stack[-1] // @178D memory[0x00:0x40] // @17BF stack[-3] // } 177B 5B JUMPDEST 177C 60 PUSH1 0x07 177E 80 DUP1 177F 54 SLOAD 1780 60 PUSH1 0x00 1782 83 DUP4 1783 81 DUP2 1784 52 MSTORE 1785 60 PUSH1 0x08 1787 60 PUSH1 0x20 1789 52 MSTORE 178A 60 PUSH1 0x40 178C 81 DUP2 178D 20 SHA3 178E 82 DUP3 178F 90 SWAP1 1790 55 SSTORE 1791 60 PUSH1 0x01 1793 82 DUP3 1794 01 ADD 1795 83 DUP4 1796 55 SSTORE 1797 91 SWAP2 1798 90 SWAP1 1799 91 SWAP2 179A 52 MSTORE 179B 7F PUSH32 0xa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688 17BC 01 ADD 17BD 55 SSTORE 17BE 50 POP 17BF 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @1784 memory[0x00:0x20] = stack[-1] // @1789 memory[0x20:0x40] = 0x08 // @1790 storage[keccak256(memory[0x00:0x40])] = storage[0x07] // @1796 storage[0x07] = storage[0x07] + 0x01 // @179A memory[0x00:0x20] = 0x07 // @17BD storage[0xa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688 + storage[0x07]] = stack[-1] // } // Block ends with unconditional jump to stack[-3] 17C0 5B JUMPDEST 17C1 60 PUSH1 0x00 17C3 91 SWAP2 17C4 82 DUP3 17C5 52 MSTORE 17C6 60 PUSH1 0x0f 17C8 60 PUSH1 0x20 17CA 52 MSTORE 17CB 60 PUSH1 0x40 17CD 90 SWAP1 17CE 91 SWAP2 17CF 20 SHA3 17D0 80 DUP1 17D1 54 SLOAD 17D2 60 PUSH1 0x01 17D4 60 PUSH1 0xa0 17D6 60 PUSH1 0x02 17D8 0A EXP 17D9 03 SUB 17DA 19 NOT 17DB 16 AND 17DC 60 PUSH1 0x01 17DE 60 PUSH1 0xa0 17E0 60 PUSH1 0x02 17E2 0A EXP 17E3 03 SUB 17E4 90 SWAP1 17E5 92 SWAP3 17E6 16 AND 17E7 91 SWAP2 17E8 90 SWAP1 17E9 91 SWAP2 17EA 17 OR 17EB 90 SWAP1 17EC 55 SSTORE 17ED 56 *JUMP label_17EE: // Incoming call from 0x168C, returns to 0x168D // Inputs[2] // { // @17F1 stack[-2] // @17F2 stack[-1] // } 17EE 5B JUMPDEST 17EF 60 PUSH1 0x00 17F1 82 DUP3 17F2 82 DUP3 17F3 01 ADD 17F4 83 DUP4 17F5 81 DUP2 17F6 10 LT 17F7 15 ISZERO 17F8 61 PUSH2 0x1512 17FB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @17EF stack[0] = 0x00 // @17F3 stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x1512, if !(stack[-1] + stack[-2] < stack[-2]) label_17FC: // Incoming jump from 0x17FB, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[1] { @17FF memory[0x00:0x00] } 17FC 60 PUSH1 0x00 17FE 80 DUP1 17FF FD *REVERT // Stack delta = +0 // Outputs[1] { @17FF revert(memory[0x00:0x00]); } // Block terminates label_1800: // Incoming call from 0x16BB, returns to 0x16BC // Inputs[2] // { // @1804 stack[-2] // @1805 stack[-1] // } 1800 5B JUMPDEST 1801 61 PUSH2 0x180a 1804 82 DUP3 1805 82 DUP3 1806 61 PUSH2 0x10f2 1809 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1801 stack[0] = 0x180a // @1804 stack[1] = stack[-2] // @1805 stack[2] = stack[-1] // } // Block ends with call to 0x10f2, returns to 0x180A label_180A: // Incoming return from call to 0x10F2 at 0x1809 // Inputs[2] // { // @180E stack[-2] // @180F stack[-1] // } 180A 5B JUMPDEST 180B 61 PUSH2 0x1814 180E 82 DUP3 180F 82 DUP3 1810 61 PUSH2 0x1154 1813 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @180B stack[0] = 0x1814 // @180E stack[1] = stack[-2] // @180F stack[2] = stack[-1] // } // Block ends with call to 0x1154, returns to 0x1814 label_1814: // Incoming return from call to 0x1154 at 0x1813 // Inputs[5] // { // @1817 memory[0x40:0x60] // @1818 stack[-1] // @1825 stack[-2] // @184C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @184F stack[-3] // } 1814 5B JUMPDEST 1815 60 PUSH1 0x40 1817 51 MLOAD 1818 81 DUP2 1819 90 SWAP1 181A 60 PUSH1 0x00 181C 90 SWAP1 181D 60 PUSH1 0x01 181F 60 PUSH1 0xa0 1821 60 PUSH1 0x02 1823 0A EXP 1824 03 SUB 1825 85 DUP6 1826 16 AND 1827 90 SWAP1 1828 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1849 90 SWAP1 184A 83 DUP4 184B 90 SWAP1 184C A4 LOG4 184D 50 POP 184E 50 POP 184F 56 *JUMP // Stack delta = -3 // Outputs[1] { @184C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-2] & 0x02 ** 0xa0 - 0x01, 0x00, stack[-1]]); } // Block ends with unconditional jump to stack[-3] label_1850: // Incoming call from 0x177A, returns to 0x177B // Inputs[1] { @1859 stack[-2] } 1850 5B JUMPDEST 1851 60 PUSH1 0x01 1853 60 PUSH1 0xa0 1855 60 PUSH1 0x02 1857 0A EXP 1858 03 SUB 1859 82 DUP3 185A 16 AND 185B 15 ISZERO 185C 15 ISZERO 185D 61 PUSH2 0x1865 1860 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1865, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) label_1861: // Incoming jump from 0x1860, if not !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[1] { @1864 memory[0x00:0x00] } 1861 60 PUSH1 0x00 1863 80 DUP1 1864 FD *REVERT // Stack delta = +0 // Outputs[1] { @1864 revert(memory[0x00:0x00]); } // Block terminates label_1865: // Incoming jump from 0x1860, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[2] // { // @1869 stack[-2] // @186A stack[-1] // } 1865 5B JUMPDEST 1866 61 PUSH2 0x186f 1869 82 DUP3 186A 82 DUP3 186B 61 PUSH2 0x125b 186E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1866 stack[0] = 0x186f // @1869 stack[1] = stack[-2] // @186A stack[2] = stack[-1] // } // Block ends with call to 0x125b, returns to 0x186F label_186F: // Incoming return from call to 0x125B at 0x186E // Inputs[5] // { // @1872 memory[0x40:0x60] // @1873 stack[-1] // @187D stack[-2] // @18A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @18AA stack[-3] // } 186F 5B JUMPDEST 1870 60 PUSH1 0x40 1872 51 MLOAD 1873 81 DUP2 1874 90 SWAP1 1875 60 PUSH1 0x01 1877 60 PUSH1 0xa0 1879 60 PUSH1 0x02 187B 0A EXP 187C 03 SUB 187D 84 DUP5 187E 16 AND 187F 90 SWAP1 1880 60 PUSH1 0x00 1882 90 SWAP1 1883 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 18A4 90 SWAP1 18A5 82 DUP3 18A6 90 SWAP1 18A7 A4 LOG4 18A8 50 POP 18A9 50 POP 18AA 56 *JUMP // Stack delta = -3 // Outputs[1] { @18A7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-2] & 0x02 ** 0xa0 - 0x01, stack[-1]]); } // Block ends with unconditional jump to stack[-3] label_18AB: // Incoming call from 0x174A, returns to 0x174B // Incoming call from 0x123C, returns to 0x123D // Inputs[3] // { // @18AC stack[-2] // @18AD storage[stack[-2]] // @18AE stack[-1] // } 18AB 5B JUMPDEST 18AC 81 DUP2 18AD 54 SLOAD 18AE 81 DUP2 18AF 83 DUP4 18B0 55 SSTORE 18B1 81 DUP2 18B2 81 DUP2 18B3 11 GT 18B4 15 ISZERO 18B5 61 PUSH2 0x0b42 18B8 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @18AD stack[0] = storage[stack[-2]] // @18B0 storage[stack[-2]] = stack[-1] // } // Block ends with conditional jump to 0x0b42, if !(storage[stack[-2]] > stack[-1]) label_18B9: // Incoming jump from 0x18B8, if not !(storage[stack[-2]] > stack[-1]) // Inputs[4] // { // @18BB stack[-3] // @18C1 memory[0x00:0x20] // @18C5 stack[-1] // @18C9 stack[-2] // } 18B9 60 PUSH1 0x00 18BB 83 DUP4 18BC 81 DUP2 18BD 52 MSTORE 18BE 60 PUSH1 0x20 18C0 90 SWAP1 18C1 20 SHA3 18C2 61 PUSH2 0x0b42 18C5 91 SWAP2 18C6 81 DUP2 18C7 01 ADD 18C8 90 SWAP1 18C9 83 DUP4 18CA 01 ADD 18CB 61 PUSH2 0x198d 18CE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @18BD memory[0x00:0x20] = stack[-3] // @18C5 stack[-1] = 0x0b42 // @18C8 stack[0] = keccak256(memory[0x00:0x20]) + stack[-1] // @18CA stack[1] = stack[-2] + keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x198d, returns to 0x0B42 label_18CF: // Incoming jump from 0x12D6 // Inputs[5] // { // @18D0 stack[-3] // @18D2 storage[stack[-3]] // @18EC memory[0x00:0x20] // @18F7 stack[-2] // @18F8 stack[-1] // } 18CF 5B JUMPDEST 18D0 82 DUP3 18D1 80 DUP1 18D2 54 SLOAD 18D3 60 PUSH1 0x01 18D5 81 DUP2 18D6 60 PUSH1 0x01 18D8 16 AND 18D9 15 ISZERO 18DA 61 PUSH2 0x0100 18DD 02 MUL 18DE 03 SUB 18DF 16 AND 18E0 60 PUSH1 0x02 18E2 90 SWAP1 18E3 04 DIV 18E4 90 SWAP1 18E5 60 PUSH1 0x00 18E7 52 MSTORE 18E8 60 PUSH1 0x20 18EA 60 PUSH1 0x00 18EC 20 SHA3 18ED 90 SWAP1 18EE 60 PUSH1 0x1f 18F0 01 ADD 18F1 60 PUSH1 0x20 18F3 90 SWAP1 18F4 04 DIV 18F5 81 DUP2 18F6 01 ADD 18F7 92 SWAP3 18F8 82 DUP3 18F9 60 PUSH1 0x1f 18FB 10 LT 18FC 61 PUSH2 0x1910 18FF 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @18E7 memory[0x00:0x20] = stack[-3] // @18ED stack[0] = keccak256(memory[0x00:0x20]) // @18F7 stack[1] = stack[-2] // @18F7 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x1910, if 0x1f < stack[-1] label_1900: // Incoming jump from 0x18FF, if not 0x1f < stack[-1] // Inputs[4] // { // @1900 stack[-1] // @1901 memory[stack[-1]:stack[-1] + 0x20] // @1906 stack[-3] // @190A stack[-5] // } 1900 80 DUP1 1901 51 MLOAD 1902 60 PUSH1 0xff 1904 19 NOT 1905 16 AND 1906 83 DUP4 1907 80 DUP1 1908 01 ADD 1909 17 OR 190A 85 DUP6 190B 55 SSTORE 190C 61 PUSH2 0x193d 190F 56 *JUMP // Stack delta = +0 // Outputs[1] { @190B storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x193d label_1910: // Incoming jump from 0x18FF, if 0x1f < stack[-1] // Inputs[2] // { // @1911 stack[-3] // @1917 stack[-5] // } 1910 5B JUMPDEST 1911 82 DUP3 1912 80 DUP1 1913 01 ADD 1914 60 PUSH1 0x01 1916 01 ADD 1917 85 DUP6 1918 55 SSTORE 1919 82 DUP3 191A 15 ISZERO 191B 61 PUSH2 0x193d 191E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1918 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x193d, if !stack[-3] label_191F: // Incoming jump from 0x191E, if not !stack[-3] // Inputs[2] // { // @191F stack[-1] // @191F stack[-3] // } 191F 91 SWAP2 1920 82 DUP3 1921 01 ADD 1922 5B JUMPDEST 1923 82 DUP3 1924 81 DUP2 1925 11 GT 1926 15 ISZERO 1927 61 PUSH2 0x193d 192A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @191F stack[-3] = stack[-1] // @1921 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x193d, if !(stack[-1] + stack[-3] > stack[-1]) label_192B: // Incoming jump from 0x192A, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x192A, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @192B stack[-3] // @192C memory[stack[-3]:stack[-3] + 0x20] // @192D stack[-2] // @192F stack[-1] // } 192B 82 DUP3 192C 51 MLOAD 192D 82 DUP3 192E 55 SSTORE 192F 91 SWAP2 1930 60 PUSH1 0x20 1932 01 ADD 1933 91 SWAP2 1934 90 SWAP1 1935 60 PUSH1 0x01 1937 01 ADD 1938 90 SWAP1 1939 61 PUSH2 0x1922 193C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @192E storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1933 stack[-3] = 0x20 + stack[-3] // @1938 stack[-2] = 0x01 + stack[-2] // @1938 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1922 label_193D: // Incoming jump from 0x190F // Incoming jump from 0x192A, if !(stack[-1] > stack[-3]) // Incoming jump from 0x191E, if !stack[-3] // Incoming jump from 0x192A, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @1942 stack[-4] // @1943 stack[-3] // } 193D 5B JUMPDEST 193E 50 POP 193F 61 PUSH2 0x1949 1942 92 SWAP3 1943 91 SWAP2 1944 50 POP 1945 61 PUSH2 0x198d 1948 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1942 stack[-4] = 0x1949 // @1943 stack[-3] = stack[-4] // } // Block ends with call to 0x198d, returns to 0x1949 label_1949: // Incoming call from 0x199B, returns to 0x078C, if !(stack[-2] > stack[-1]) // Incoming jump from 0x199B, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x198D at 0x1948 // Inputs[2] // { // @194B stack[-2] // @194B stack[-3] // } 1949 5B JUMPDEST 194A 50 POP 194B 90 SWAP1 194C 56 *JUMP // Stack delta = -2 // Outputs[1] { @194B stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_194D: // Incoming call from 0x131E, returns to 0x0FD2 // Inputs[2] // { // @194F stack[-2] // @1950 storage[stack[-2]] // } 194D 5B JUMPDEST 194E 50 POP 194F 80 DUP1 1950 54 SLOAD 1951 60 PUSH1 0x01 1953 81 DUP2 1954 60 PUSH1 0x01 1956 16 AND 1957 15 ISZERO 1958 61 PUSH2 0x0100 195B 02 MUL 195C 03 SUB 195D 16 AND 195E 60 PUSH1 0x02 1960 90 SWAP1 1961 04 DIV 1962 60 PUSH1 0x00 1964 82 DUP3 1965 55 SSTORE 1966 80 DUP1 1967 60 PUSH1 0x1f 1969 10 LT 196A 61 PUSH2 0x1973 196D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1961 stack[-1] = (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 // @1965 storage[stack[-2]] = 0x00 // } // Block ends with conditional jump to 0x1973, if 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 label_196E: // Incoming jump from 0x196D, if not 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 196E 50 POP 196F 61 PUSH2 0x1073 1972 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1073 label_1973: // Incoming jump from 0x196D, if 0x1f < (0x0100 * !(0x01 & storage[stack[-2]]) - 0x01 & storage[stack[-2]]) / 0x02 // Inputs[3] // { // @1976 stack[-1] // @197B stack[-2] // @1983 memory[0x00:0x20] // } 1973 5B JUMPDEST 1974 60 PUSH1 0x1f 1976 01 ADD 1977 60 PUSH1 0x20 1979 90 SWAP1 197A 04 DIV 197B 90 SWAP1 197C 60 PUSH1 0x00 197E 52 MSTORE 197F 60 PUSH1 0x20 1981 60 PUSH1 0x00 1983 20 SHA3 1984 90 SWAP1 1985 81 DUP2 1986 01 ADD 1987 90 SWAP1 1988 61 PUSH2 0x1073 198B 91 SWAP2 198C 90 SWAP1 // Stack delta = +1 // Outputs[4] // { // @197E memory[0x00:0x20] = stack[-2] // @198B stack[-2] = 0x1073 // @198C stack[-1] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // @198C stack[0] = keccak256(memory[0x00:0x20]) // } // Block continues label_198D: // Incoming jump from 0x198C // Incoming call from 0x18CE, returns to 0x0B42 // Incoming call from 0x1948, returns to 0x1949 // Inputs[2] // { // @1991 stack[-2] // @1992 stack[-1] // } 198D 5B JUMPDEST 198E 61 PUSH2 0x078c 1991 91 SWAP2 1992 90 SWAP1 1993 5B JUMPDEST 1994 80 DUP1 1995 82 DUP3 1996 11 GT 1997 15 ISZERO 1998 61 PUSH2 0x1949 199B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1991 stack[-2] = 0x078c // @1992 stack[-1] = stack[-2] // @1992 stack[0] = stack[-1] // } // Block ends with conditional call to 0x1949, returns to 0x078C, if !(stack[-2] > stack[-1]) label_199C: // Incoming jump from 0x199B, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x199B, if not !(stack[-2] > stack[-1]) // Inputs[1] { @199E stack[-1] } 199C 60 PUSH1 0x00 199E 81 DUP2 199F 55 SSTORE 19A0 60 PUSH1 0x01 19A2 01 ADD 19A3 61 PUSH2 0x1993 19A6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @199F storage[stack[-1]] = 0x00 // @19A2 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1993 19A7 00 *STOP 19A8 A1 LOG1 19A9 65 PUSH6 0x627a7a723058 19B0 20 SHA3 19B1 6E PUSH15 0xd640e2fef44710535bd8c8b3b4729d 19C1 D9 D9 19C2 3A GASPRICE 19C3 83 DUP4 19C4 D3 D3 19C5 5C 5C 19C6 51 MLOAD 19C7 A0 LOG0 19C8 83 DUP4 19C9 B8 B8 19CA 00 *STOP 19CB 70 PUSH17 0x528623b22c0029