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 0x01e3 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01e3, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x6630208f 0019 11 GT 001A 61 PUSH2 0x0102 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0102, if 0x6630208f > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6630208f > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb6b6f0c3 0024 11 GT 0025 61 PUSH2 0x0095 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0xb6b6f0c3 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb6b6f0c3 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xe985e9c5 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xe985e9c5 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe985e9c5 003A 14 EQ 003B 61 PUSH2 0x0547 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0547, if 0xe985e9c5 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf2fde38b 0045 14 EQ 0046 61 PUSH2 0x0590 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0590, if 0xf2fde38b == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf2fde38b == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf46a04eb 0050 14 EQ 0051 61 PUSH2 0x05b0 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b0, if 0xf46a04eb == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf46a04eb == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf724be4e 005B 14 EQ 005C 61 PUSH2 0x05d0 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d0, if 0xf724be4e == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf724be4e == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x0033, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xb6b6f0c3 006B 14 EQ 006C 61 PUSH2 0x04d2 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d2, if 0xb6b6f0c3 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xb6b6f0c3 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xb88d4fde 0076 14 EQ 0077 61 PUSH2 0x04e7 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e7, if 0xb88d4fde == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc87b56dd 0081 14 EQ 0082 61 PUSH2 0x0507 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0507, if 0xc87b56dd == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xd060404c 008C 14 EQ 008D 61 PUSH2 0x0527 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0527, if 0xd060404c == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xd060404c == stack[-1] // Inputs[1] { @0094 memory[0x00:0x00] } 0091 60 PUSH1 0x00 0093 80 DUP1 0094 FD *REVERT // Stack delta = +0 // Outputs[1] { @0094 revert(memory[0x00:0x00]); } // Block terminates label_0095: // Incoming jump from 0x0028, if 0xb6b6f0c3 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0x95d89b41 009C 11 GT 009D 61 PUSH2 0x00d1 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d1, if 0x95d89b41 > stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x95d89b41 00A7 14 EQ 00A8 61 PUSH2 0x0468 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0468, if 0x95d89b41 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xa22cb465 00B2 14 EQ 00B3 61 PUSH2 0x047d 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047d, if 0xa22cb465 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0xa4766f9d 00BD 14 EQ 00BE 61 PUSH2 0x049d 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049d, if 0xa4766f9d == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0xa4766f9d == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xaddf02f5 00C8 14 EQ 00C9 61 PUSH2 0x04b2 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b2, if 0xaddf02f5 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xaddf02f5 == stack[-1] // Inputs[1] { @00D0 memory[0x00:0x00] } 00CD 60 PUSH1 0x00 00CF 80 DUP1 00D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D0 revert(memory[0x00:0x00]); } // Block terminates label_00D1: // Incoming jump from 0x00A0, if 0x95d89b41 > stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D1 5B JUMPDEST 00D2 80 DUP1 00D3 63 PUSH4 0x6630208f 00D8 14 EQ 00D9 61 PUSH2 0x03f5 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f5, if 0x6630208f == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x6630208f == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x70a08231 00E3 14 EQ 00E4 61 PUSH2 0x0415 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0415, if 0x70a08231 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x70a08231 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x715018a6 00EE 14 EQ 00EF 61 PUSH2 0x0435 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0435, if 0x715018a6 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x715018a6 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x8da5cb5b 00F9 14 EQ 00FA 61 PUSH2 0x044a 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044a, if 0x8da5cb5b == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0101 memory[0x00:0x00] } 00FE 60 PUSH1 0x00 0100 80 DUP1 0101 FD *REVERT // Stack delta = +0 // Outputs[1] { @0101 revert(memory[0x00:0x00]); } // Block terminates label_0102: // Incoming jump from 0x001D, if 0x6630208f > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0103 stack[-1] } 0102 5B JUMPDEST 0103 80 DUP1 0104 63 PUSH4 0x27c09c06 0109 11 GT 010A 61 PUSH2 0x017a 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017a, if 0x27c09c06 > stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x27c09c06 > stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x55f804b3 0114 11 GT 0115 61 PUSH2 0x0149 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0149, if 0x55f804b3 > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x55f804b3 > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x55f804b3 011F 14 EQ 0120 61 PUSH2 0x0375 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0375, if 0x55f804b3 == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x5c847e4f 012A 14 EQ 012B 61 PUSH2 0x0395 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0395, if 0x5c847e4f == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x5c847e4f == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x5e4c1b3d 0135 14 EQ 0136 61 PUSH2 0x03b5 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b5, if 0x5e4c1b3d == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x5e4c1b3d == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x6352211e 0140 14 EQ 0141 61 PUSH2 0x03d5 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d5, if 0x6352211e == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x6352211e == stack[-1] // Inputs[1] { @0148 memory[0x00:0x00] } 0145 60 PUSH1 0x00 0147 80 DUP1 0148 FD *REVERT // Stack delta = +0 // Outputs[1] { @0148 revert(memory[0x00:0x00]); } // Block terminates label_0149: // Incoming jump from 0x0118, if 0x55f804b3 > stack[-1] // Inputs[1] { @014A stack[-1] } 0149 5B JUMPDEST 014A 80 DUP1 014B 63 PUSH4 0x27c09c06 0150 14 EQ 0151 61 PUSH2 0x030d 0154 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030d, if 0x27c09c06 == stack[-1] label_0155: // Incoming jump from 0x0154, if not 0x27c09c06 == stack[-1] // Inputs[1] { @0155 stack[-1] } 0155 80 DUP1 0156 63 PUSH4 0x3ccfd60b 015B 14 EQ 015C 61 PUSH2 0x032d 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032d, if 0x3ccfd60b == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x42842e0e 0166 14 EQ 0167 61 PUSH2 0x0335 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0335, if 0x42842e0e == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x42842e0e == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x4a480242 0171 14 EQ 0172 61 PUSH2 0x0355 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0355, if 0x4a480242 == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x4a480242 == stack[-1] // Inputs[1] { @0179 memory[0x00:0x00] } 0176 60 PUSH1 0x00 0178 80 DUP1 0179 FD *REVERT // Stack delta = +0 // Outputs[1] { @0179 revert(memory[0x00:0x00]); } // Block terminates label_017A: // Incoming jump from 0x010D, if 0x27c09c06 > stack[-1] // Inputs[1] { @017B stack[-1] } 017A 5B JUMPDEST 017B 80 DUP1 017C 63 PUSH4 0x18160ddd 0181 11 GT 0182 61 PUSH2 0x01b6 0185 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b6, if 0x18160ddd > stack[-1] label_0186: // Incoming jump from 0x0185, if not 0x18160ddd > stack[-1] // Inputs[1] { @0186 stack[-1] } 0186 80 DUP1 0187 63 PUSH4 0x18160ddd 018C 14 EQ 018D 61 PUSH2 0x0299 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0299, if 0x18160ddd == stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x18160ddd == stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x18f4b3fa 0197 14 EQ 0198 61 PUSH2 0x02bc 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bc, if 0x18f4b3fa == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x18f4b3fa == stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x23b872dd 01A2 14 EQ 01A3 61 PUSH2 0x02d2 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d2, if 0x23b872dd == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x23b872dd == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x25de3fc2 01AD 14 EQ 01AE 61 PUSH2 0x02f2 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f2, if 0x25de3fc2 == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x25de3fc2 == stack[-1] // Inputs[1] { @01B5 memory[0x00:0x00] } 01B2 60 PUSH1 0x00 01B4 80 DUP1 01B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B5 revert(memory[0x00:0x00]); } // Block terminates label_01B6: // Incoming jump from 0x0185, if 0x18160ddd > stack[-1] // Inputs[1] { @01B7 stack[-1] } 01B6 5B JUMPDEST 01B7 80 DUP1 01B8 63 PUSH4 0x01ffc9a7 01BD 14 EQ 01BE 61 PUSH2 0x01e8 01C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e8, if 0x01ffc9a7 == stack[-1] label_01C2: // Incoming jump from 0x01C1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01C2 stack[-1] } 01C2 80 DUP1 01C3 63 PUSH4 0x06fdde03 01C8 14 EQ 01C9 61 PUSH2 0x021d 01CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021d, if 0x06fdde03 == stack[-1] label_01CD: // Incoming jump from 0x01CC, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01CD stack[-1] } 01CD 80 DUP1 01CE 63 PUSH4 0x081812fc 01D3 14 EQ 01D4 61 PUSH2 0x023f 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0x081812fc == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x081812fc == stack[-1] // Inputs[1] { @01D8 stack[-1] } 01D8 80 DUP1 01D9 63 PUSH4 0x095ea7b3 01DE 14 EQ 01DF 61 PUSH2 0x0277 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0277, if 0x095ea7b3 == stack[-1] label_01E3: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x01E2, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01E7 memory[0x00:0x00] } 01E3 5B JUMPDEST 01E4 60 PUSH1 0x00 01E6 80 DUP1 01E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E7 revert(memory[0x00:0x00]); } // Block terminates label_01E8: // Incoming jump from 0x01C1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01E9 msg.value } 01E8 5B JUMPDEST 01E9 34 CALLVALUE 01EA 80 DUP1 01EB 15 ISZERO 01EC 61 PUSH2 0x01f4 01EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01E9 stack[0] = msg.value } // Block ends with conditional jump to 0x01f4, if !msg.value label_01F0: // Incoming jump from 0x01EF, if not !msg.value // Inputs[1] { @01F3 memory[0x00:0x00] } 01F0 60 PUSH1 0x00 01F2 80 DUP1 01F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F3 revert(memory[0x00:0x00]); } // Block terminates label_01F4: // Incoming jump from 0x01EF, if !msg.value // Inputs[1] { @01FC msg.data.length } 01F4 5B JUMPDEST 01F5 50 POP 01F6 61 PUSH2 0x0208 01F9 61 PUSH2 0x0203 01FC 36 CALLDATASIZE 01FD 60 PUSH1 0x04 01FF 61 PUSH2 0x205b 0202 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01F6 stack[-1] = 0x0208 // @01F9 stack[0] = 0x0203 // @01FC stack[1] = msg.data.length // @01FD stack[2] = 0x04 // } // Block ends with call to 0x205b, returns to 0x0203 label_0203: // Incoming return from call to 0x205B at 0x0202 0203 5B JUMPDEST 0204 61 PUSH2 0x05e3 0207 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05e3 label_0208: // Incoming return from call to 0x0203 at 0x0202 // Incoming return from call to 0x0562 at 0x0561 // Inputs[2] // { // @020B memory[0x40:0x60] // @020C stack[-1] // } 0208 5B JUMPDEST 0209 60 PUSH1 0x40 020B 51 MLOAD 020C 90 SWAP1 020D 15 ISZERO 020E 15 ISZERO 020F 81 DUP2 0210 52 MSTORE 0211 60 PUSH1 0x20 0213 01 ADD // Stack delta = +0 // Outputs[2] // { // @0210 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0213 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0214: // Incoming jump from 0x0276 // Incoming jump from 0x0213 // Incoming return from call to 0x20D0 at 0x023E // Incoming jump from 0x02BB // Inputs[3] // { // @0217 memory[0x40:0x60] // @0219 stack[-1] // @021C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0214 5B JUMPDEST 0215 60 PUSH1 0x40 0217 51 MLOAD 0218 80 DUP1 0219 91 SWAP2 021A 03 SUB 021B 90 SWAP1 021C F3 *RETURN // Stack delta = -1 // Outputs[1] { @021C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_021D: // Incoming jump from 0x01CC, if 0x06fdde03 == stack[-1] // Inputs[1] { @021E msg.value } 021D 5B JUMPDEST 021E 34 CALLVALUE 021F 80 DUP1 0220 15 ISZERO 0221 61 PUSH2 0x0229 0224 57 *JUMPI // Stack delta = +1 // Outputs[1] { @021E stack[0] = msg.value } // Block ends with conditional jump to 0x0229, if !msg.value label_0225: // Incoming jump from 0x0224, if not !msg.value // Inputs[1] { @0228 memory[0x00:0x00] } 0225 60 PUSH1 0x00 0227 80 DUP1 0228 FD *REVERT // Stack delta = +0 // Outputs[1] { @0228 revert(memory[0x00:0x00]); } // Block terminates label_0229: // Incoming jump from 0x0224, if !msg.value 0229 5B JUMPDEST 022A 50 POP 022B 61 PUSH2 0x0232 022E 61 PUSH2 0x0680 0231 56 *JUMP // Stack delta = +0 // Outputs[1] { @022B stack[-1] = 0x0232 } // Block ends with call to 0x0680, returns to 0x0232 label_0232: // Incoming return from call to 0x0D16 at 0x047C // Incoming return from call to 0x0680 at 0x0231 // Incoming return from call to 0x0522 at 0x0521 // Inputs[2] // { // @0235 memory[0x40:0x60] // @0239 stack[-1] // } 0232 5B JUMPDEST 0233 60 PUSH1 0x40 0235 51 MLOAD 0236 61 PUSH2 0x0214 0239 91 SWAP2 023A 90 SWAP1 023B 61 PUSH2 0x20d0 023E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0239 stack[-1] = 0x0214 // @023A stack[1] = memory[0x40:0x60] // @023A stack[0] = stack[-1] // } // Block ends with call to 0x20d0, returns to 0x0214 label_023F: // Incoming jump from 0x01D7, if 0x081812fc == stack[-1] // Inputs[1] { @0240 msg.value } 023F 5B JUMPDEST 0240 34 CALLVALUE 0241 80 DUP1 0242 15 ISZERO 0243 61 PUSH2 0x024b 0246 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0240 stack[0] = msg.value } // Block ends with conditional jump to 0x024b, if !msg.value label_0247: // Incoming jump from 0x0246, if not !msg.value // Inputs[1] { @024A memory[0x00:0x00] } 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming jump from 0x0246, if !msg.value // Inputs[1] { @0253 msg.data.length } 024B 5B JUMPDEST 024C 50 POP 024D 61 PUSH2 0x025f 0250 61 PUSH2 0x025a 0253 36 CALLDATASIZE 0254 60 PUSH1 0x04 0256 61 PUSH2 0x20e3 0259 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @024D stack[-1] = 0x025f // @0250 stack[0] = 0x025a // @0253 stack[1] = msg.data.length // @0254 stack[2] = 0x04 // } // Block ends with call to 0x20e3, returns to 0x025A label_025A: // Incoming return from call to 0x20E3 at 0x0259 025A 5B JUMPDEST 025B 61 PUSH2 0x0712 025E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0712 label_025F: // Incoming jump from 0x0467 // Incoming return from call to 0x03F0 at 0x03EF // Incoming jump from 0x032C // Incoming return from call to 0x025A at 0x0259 // Inputs[2] // { // @0262 memory[0x40:0x60] // @026C stack[-1] // } 025F 5B JUMPDEST 0260 60 PUSH1 0x40 0262 51 MLOAD 0263 60 PUSH1 0x01 0265 60 PUSH1 0x01 0267 60 PUSH1 0xa0 0269 1B SHL 026A 03 SUB 026B 90 SWAP1 026C 91 SWAP2 026D 16 AND 026E 81 DUP2 026F 52 MSTORE 0270 60 PUSH1 0x20 0272 01 ADD 0273 61 PUSH2 0x0214 0276 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @026F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0272 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0214 label_0277: // Incoming jump from 0x01E2, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0278 msg.value } 0277 5B JUMPDEST 0278 34 CALLVALUE 0279 80 DUP1 027A 15 ISZERO 027B 61 PUSH2 0x0283 027E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0278 stack[0] = msg.value } // Block ends with conditional jump to 0x0283, if !msg.value label_027F: // Incoming jump from 0x027E, if not !msg.value // Inputs[1] { @0282 memory[0x00:0x00] } 027F 60 PUSH1 0x00 0281 80 DUP1 0282 FD *REVERT // Stack delta = +0 // Outputs[1] { @0282 revert(memory[0x00:0x00]); } // Block terminates label_0283: // Incoming jump from 0x027E, if !msg.value // Inputs[1] { @028B msg.data.length } 0283 5B JUMPDEST 0284 50 POP 0285 61 PUSH2 0x0297 0288 61 PUSH2 0x0292 028B 36 CALLDATASIZE 028C 60 PUSH1 0x04 028E 61 PUSH2 0x2111 0291 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0285 stack[-1] = 0x0297 // @0288 stack[0] = 0x0292 // @028B stack[1] = msg.data.length // @028C stack[2] = 0x04 // } // Block ends with call to 0x2111, returns to 0x0292 label_0292: // Incoming return from call to 0x2111 at 0x0291 0292 5B JUMPDEST 0293 61 PUSH2 0x076f 0296 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x076f label_0297: // Incoming return from call to 0x0CB0 at 0x0449 // Incoming return from call to 0x05AB at 0x05AA // Incoming return from call to 0x083A at 0x0334 // Incoming return from call to 0x05CB at 0x05CA // Incoming return from call to 0x03B0 at 0x03AF // Incoming return from call to 0x04CD at 0x04CC // Incoming return from call to 0x0498 at 0x0497 // Incoming return from call to 0x03D0 at 0x03CF // Incoming return from call to 0x05DE at 0x05DD // Incoming return from call to 0x0370 at 0x036F // Incoming return from call to 0x0410 at 0x040F 0297 5B JUMPDEST 0298 00 *STOP // Stack delta = +0 // Outputs[1] { @0298 stop(); } // Block terminates label_0299: // Incoming jump from 0x0190, if 0x18160ddd == stack[-1] // Inputs[1] { @029A msg.value } 0299 5B JUMPDEST 029A 34 CALLVALUE 029B 80 DUP1 029C 15 ISZERO 029D 61 PUSH2 0x02a5 02A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @029A stack[0] = msg.value } // Block ends with conditional jump to 0x02a5, if !msg.value label_02A1: // Incoming jump from 0x02A0, if not !msg.value // Inputs[1] { @02A4 memory[0x00:0x00] } 02A1 60 PUSH1 0x00 02A3 80 DUP1 02A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A4 revert(memory[0x00:0x00]); } // Block terminates label_02A5: // Incoming jump from 0x02A0, if !msg.value // Inputs[2] // { // @02A9 storage[0x01] // @02AC storage[0x00] // } 02A5 5B JUMPDEST 02A6 50 POP 02A7 60 PUSH1 0x01 02A9 54 SLOAD 02AA 60 PUSH1 0x00 02AC 54 SLOAD 02AD 03 SUB // Stack delta = +0 // Outputs[1] { @02AD stack[-1] = storage[0x00] - storage[0x01] } // Block continues label_02AE: // Incoming return from call to 0x0430 at 0x042F // Incoming jump from 0x02AD // Incoming jump from 0x04B1 // Incoming return from call to 0x0542 at 0x0541 // Incoming jump from 0x02D1 // Incoming jump from 0x030C // Incoming jump from 0x04E6 // Inputs[2] // { // @02B1 memory[0x40:0x60] // @02B2 stack[-1] // } 02AE 5B JUMPDEST 02AF 60 PUSH1 0x40 02B1 51 MLOAD 02B2 90 SWAP1 02B3 81 DUP2 02B4 52 MSTORE 02B5 60 PUSH1 0x20 02B7 01 ADD 02B8 61 PUSH2 0x0214 02BB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02B7 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0214 label_02BC: // Incoming jump from 0x019B, if 0x18f4b3fa == stack[-1] // Inputs[1] { @02BD msg.value } 02BC 5B JUMPDEST 02BD 34 CALLVALUE 02BE 80 DUP1 02BF 15 ISZERO 02C0 61 PUSH2 0x02c8 02C3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02BD stack[0] = msg.value } // Block ends with conditional jump to 0x02c8, if !msg.value label_02C4: // Incoming jump from 0x02C3, if not !msg.value // Inputs[1] { @02C7 memory[0x00:0x00] } 02C4 60 PUSH1 0x00 02C6 80 DUP1 02C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C7 revert(memory[0x00:0x00]); } // Block terminates label_02C8: // Incoming jump from 0x02C3, if !msg.value 02C8 5B JUMPDEST 02C9 50 POP 02CA 61 PUSH2 0x02ae 02CD 61 PUSH2 0x3a98 02D0 81 DUP2 02D1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02CA stack[-1] = 0x02ae // @02CD stack[0] = 0x3a98 // } // Block ends with unconditional jump to 0x02ae label_02D2: // Incoming jump from 0x01A6, if 0x23b872dd == stack[-1] // Inputs[1] { @02D3 msg.value } 02D2 5B JUMPDEST 02D3 34 CALLVALUE 02D4 80 DUP1 02D5 15 ISZERO 02D6 61 PUSH2 0x02de 02D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02D3 stack[0] = msg.value } // Block ends with conditional jump to 0x02de, if !msg.value label_02DA: // Incoming jump from 0x02D9, if not !msg.value // Inputs[1] { @02DD memory[0x00:0x00] } 02DA 60 PUSH1 0x00 02DC 80 DUP1 02DD FD *REVERT // Stack delta = +0 // Outputs[1] { @02DD revert(memory[0x00:0x00]); } // Block terminates label_02DE: // Incoming jump from 0x02D9, if !msg.value // Inputs[1] { @02E6 msg.data.length } 02DE 5B JUMPDEST 02DF 50 POP 02E0 61 PUSH2 0x0297 02E3 61 PUSH2 0x02ed 02E6 36 CALLDATASIZE 02E7 60 PUSH1 0x04 02E9 61 PUSH2 0x213d 02EC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02E0 stack[-1] = 0x0297 // @02E3 stack[0] = 0x02ed // @02E6 stack[1] = msg.data.length // @02E7 stack[2] = 0x04 // } // Block ends with call to 0x213d, returns to 0x02ED label_02ED: // Incoming return from call to 0x213D at 0x02EC 02ED 5B JUMPDEST 02EE 61 PUSH2 0x082f 02F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x082f label_02F2: // Incoming jump from 0x01B1, if 0x25de3fc2 == stack[-1] // Inputs[1] { @02F3 msg.value } 02F2 5B JUMPDEST 02F3 34 CALLVALUE 02F4 80 DUP1 02F5 15 ISZERO 02F6 61 PUSH2 0x02fe 02F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F3 stack[0] = msg.value } // Block ends with conditional jump to 0x02fe, if !msg.value label_02FA: // Incoming jump from 0x02F9, if not !msg.value // Inputs[1] { @02FD memory[0x00:0x00] } 02FA 60 PUSH1 0x00 02FC 80 DUP1 02FD FD *REVERT // Stack delta = +0 // Outputs[1] { @02FD revert(memory[0x00:0x00]); } // Block terminates label_02FE: // Incoming jump from 0x02F9, if !msg.value 02FE 5B JUMPDEST 02FF 50 POP 0300 61 PUSH2 0x02ae 0303 66 PUSH7 0xd529ae9e860000 030B 81 DUP2 030C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0300 stack[-1] = 0x02ae // @0303 stack[0] = 0xd529ae9e860000 // } // Block ends with unconditional jump to 0x02ae label_030D: // Incoming jump from 0x0154, if 0x27c09c06 == stack[-1] // Inputs[1] { @030E msg.value } 030D 5B JUMPDEST 030E 34 CALLVALUE 030F 80 DUP1 0310 15 ISZERO 0311 61 PUSH2 0x0319 0314 57 *JUMPI // Stack delta = +1 // Outputs[1] { @030E stack[0] = msg.value } // Block ends with conditional jump to 0x0319, if !msg.value label_0315: // Incoming jump from 0x0314, if not !msg.value // Inputs[1] { @0318 memory[0x00:0x00] } 0315 60 PUSH1 0x00 0317 80 DUP1 0318 FD *REVERT // Stack delta = +0 // Outputs[1] { @0318 revert(memory[0x00:0x00]); } // Block terminates label_0319: // Incoming jump from 0x0314, if !msg.value // Inputs[1] { @031D storage[0x0b] } 0319 5B JUMPDEST 031A 50 POP 031B 60 PUSH1 0x0b 031D 54 SLOAD 031E 61 PUSH2 0x025f 0321 90 SWAP1 0322 60 PUSH1 0x01 0324 60 PUSH1 0x01 0326 60 PUSH1 0xa0 0328 1B SHL 0329 03 SUB 032A 16 AND 032B 81 DUP2 032C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0321 stack[-1] = 0x025f // @032A stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0b] // } // Block ends with unconditional jump to 0x025f label_032D: // Incoming jump from 0x015F, if 0x3ccfd60b == stack[-1] 032D 5B JUMPDEST 032E 61 PUSH2 0x0297 0331 61 PUSH2 0x083a 0334 56 *JUMP // Stack delta = +1 // Outputs[1] { @032E stack[0] = 0x0297 } // Block ends with call to 0x083a, returns to 0x0297 label_0335: // Incoming jump from 0x016A, if 0x42842e0e == stack[-1] // Inputs[1] { @0336 msg.value } 0335 5B JUMPDEST 0336 34 CALLVALUE 0337 80 DUP1 0338 15 ISZERO 0339 61 PUSH2 0x0341 033C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0336 stack[0] = msg.value } // Block ends with conditional jump to 0x0341, if !msg.value label_033D: // Incoming jump from 0x033C, if not !msg.value // Inputs[1] { @0340 memory[0x00:0x00] } 033D 60 PUSH1 0x00 033F 80 DUP1 0340 FD *REVERT // Stack delta = +0 // Outputs[1] { @0340 revert(memory[0x00:0x00]); } // Block terminates label_0341: // Incoming jump from 0x033C, if !msg.value // Inputs[1] { @0349 msg.data.length } 0341 5B JUMPDEST 0342 50 POP 0343 61 PUSH2 0x0297 0346 61 PUSH2 0x0350 0349 36 CALLDATASIZE 034A 60 PUSH1 0x04 034C 61 PUSH2 0x213d 034F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0343 stack[-1] = 0x0297 // @0346 stack[0] = 0x0350 // @0349 stack[1] = msg.data.length // @034A stack[2] = 0x04 // } // Block ends with call to 0x213d, returns to 0x0350 label_0350: // Incoming return from call to 0x213D at 0x034F 0350 5B JUMPDEST 0351 61 PUSH2 0x0953 0354 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0953 label_0355: // Incoming jump from 0x0175, if 0x4a480242 == stack[-1] // Inputs[1] { @0356 msg.value } 0355 5B JUMPDEST 0356 34 CALLVALUE 0357 80 DUP1 0358 15 ISZERO 0359 61 PUSH2 0x0361 035C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0356 stack[0] = msg.value } // Block ends with conditional jump to 0x0361, if !msg.value label_035D: // Incoming jump from 0x035C, if not !msg.value // Inputs[1] { @0360 memory[0x00:0x00] } 035D 60 PUSH1 0x00 035F 80 DUP1 0360 FD *REVERT // Stack delta = +0 // Outputs[1] { @0360 revert(memory[0x00:0x00]); } // Block terminates label_0361: // Incoming jump from 0x035C, if !msg.value // Inputs[1] { @0369 msg.data.length } 0361 5B JUMPDEST 0362 50 POP 0363 61 PUSH2 0x0297 0366 61 PUSH2 0x0370 0369 36 CALLDATASIZE 036A 60 PUSH1 0x04 036C 61 PUSH2 0x20e3 036F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0363 stack[-1] = 0x0297 // @0366 stack[0] = 0x0370 // @0369 stack[1] = msg.data.length // @036A stack[2] = 0x04 // } // Block ends with call to 0x20e3, returns to 0x0370 label_0370: // Incoming return from call to 0x20E3 at 0x036F 0370 5B JUMPDEST 0371 61 PUSH2 0x096e 0374 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x096e label_0375: // Incoming jump from 0x0123, if 0x55f804b3 == stack[-1] // Inputs[1] { @0376 msg.value } 0375 5B JUMPDEST 0376 34 CALLVALUE 0377 80 DUP1 0378 15 ISZERO 0379 61 PUSH2 0x0381 037C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0376 stack[0] = msg.value } // Block ends with conditional jump to 0x0381, if !msg.value label_037D: // Incoming jump from 0x037C, if not !msg.value // Inputs[1] { @0380 memory[0x00:0x00] } 037D 60 PUSH1 0x00 037F 80 DUP1 0380 FD *REVERT // Stack delta = +0 // Outputs[1] { @0380 revert(memory[0x00:0x00]); } // Block terminates label_0381: // Incoming jump from 0x037C, if !msg.value // Inputs[1] { @0389 msg.data.length } 0381 5B JUMPDEST 0382 50 POP 0383 61 PUSH2 0x0297 0386 61 PUSH2 0x0390 0389 36 CALLDATASIZE 038A 60 PUSH1 0x04 038C 61 PUSH2 0x220a 038F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0383 stack[-1] = 0x0297 // @0386 stack[0] = 0x0390 // @0389 stack[1] = msg.data.length // @038A stack[2] = 0x04 // } // Block ends with call to 0x220a, returns to 0x0390 label_0390: // Incoming return from call to 0x220A at 0x038F 0390 5B JUMPDEST 0391 61 PUSH2 0x09e3 0394 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09e3 label_0395: // Incoming jump from 0x012E, if 0x5c847e4f == 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] { @03A9 msg.data.length } 03A1 5B JUMPDEST 03A2 50 POP 03A3 61 PUSH2 0x0297 03A6 61 PUSH2 0x03b0 03A9 36 CALLDATASIZE 03AA 60 PUSH1 0x04 03AC 61 PUSH2 0x2253 03AF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03A3 stack[-1] = 0x0297 // @03A6 stack[0] = 0x03b0 // @03A9 stack[1] = msg.data.length // @03AA stack[2] = 0x04 // } // Block ends with call to 0x2253, returns to 0x03B0 label_03B0: // Incoming return from call to 0x2253 at 0x03AF 03B0 5B JUMPDEST 03B1 61 PUSH2 0x0a54 03B4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a54 label_03B5: // Incoming jump from 0x0139, if 0x5e4c1b3d == stack[-1] // Inputs[1] { @03B6 msg.value } 03B5 5B JUMPDEST 03B6 34 CALLVALUE 03B7 80 DUP1 03B8 15 ISZERO 03B9 61 PUSH2 0x03c1 03BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B6 stack[0] = msg.value } // Block ends with conditional jump to 0x03c1, if !msg.value label_03BD: // Incoming jump from 0x03BC, if not !msg.value // Inputs[1] { @03C0 memory[0x00:0x00] } 03BD 60 PUSH1 0x00 03BF 80 DUP1 03C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C0 revert(memory[0x00:0x00]); } // Block terminates label_03C1: // Incoming jump from 0x03BC, if !msg.value // Inputs[1] { @03C9 msg.data.length } 03C1 5B JUMPDEST 03C2 50 POP 03C3 61 PUSH2 0x0297 03C6 61 PUSH2 0x03d0 03C9 36 CALLDATASIZE 03CA 60 PUSH1 0x04 03CC 61 PUSH2 0x22b5 03CF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03C3 stack[-1] = 0x0297 // @03C6 stack[0] = 0x03d0 // @03C9 stack[1] = msg.data.length // @03CA stack[2] = 0x04 // } // Block ends with call to 0x22b5, returns to 0x03D0 label_03D0: // Incoming return from call to 0x22B5 at 0x03CF 03D0 5B JUMPDEST 03D1 61 PUSH2 0x0add 03D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0add label_03D5: // Incoming jump from 0x0144, if 0x6352211e == stack[-1] // Inputs[1] { @03D6 msg.value } 03D5 5B JUMPDEST 03D6 34 CALLVALUE 03D7 80 DUP1 03D8 15 ISZERO 03D9 61 PUSH2 0x03e1 03DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D6 stack[0] = msg.value } // Block ends with conditional jump to 0x03e1, if !msg.value label_03DD: // Incoming jump from 0x03DC, if not !msg.value // Inputs[1] { @03E0 memory[0x00:0x00] } 03DD 60 PUSH1 0x00 03DF 80 DUP1 03E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E0 revert(memory[0x00:0x00]); } // Block terminates label_03E1: // Incoming jump from 0x03DC, if !msg.value // Inputs[1] { @03E9 msg.data.length } 03E1 5B JUMPDEST 03E2 50 POP 03E3 61 PUSH2 0x025f 03E6 61 PUSH2 0x03f0 03E9 36 CALLDATASIZE 03EA 60 PUSH1 0x04 03EC 61 PUSH2 0x20e3 03EF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03E3 stack[-1] = 0x025f // @03E6 stack[0] = 0x03f0 // @03E9 stack[1] = msg.data.length // @03EA stack[2] = 0x04 // } // Block ends with call to 0x20e3, returns to 0x03F0 label_03F0: // Incoming return from call to 0x20E3 at 0x03EF 03F0 5B JUMPDEST 03F1 61 PUSH2 0x0bad 03F4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bad label_03F5: // Incoming jump from 0x00DC, if 0x6630208f == stack[-1] // Inputs[1] { @03F6 msg.value } 03F5 5B JUMPDEST 03F6 34 CALLVALUE 03F7 80 DUP1 03F8 15 ISZERO 03F9 61 PUSH2 0x0401 03FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F6 stack[0] = msg.value } // Block ends with conditional jump to 0x0401, if !msg.value label_03FD: // Incoming jump from 0x03FC, if not !msg.value // Inputs[1] { @0400 memory[0x00:0x00] } 03FD 60 PUSH1 0x00 03FF 80 DUP1 0400 FD *REVERT // Stack delta = +0 // Outputs[1] { @0400 revert(memory[0x00:0x00]); } // Block terminates label_0401: // Incoming jump from 0x03FC, if !msg.value // Inputs[1] { @0409 msg.data.length } 0401 5B JUMPDEST 0402 50 POP 0403 61 PUSH2 0x0297 0406 61 PUSH2 0x0410 0409 36 CALLDATASIZE 040A 60 PUSH1 0x04 040C 61 PUSH2 0x2253 040F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0403 stack[-1] = 0x0297 // @0406 stack[0] = 0x0410 // @0409 stack[1] = msg.data.length // @040A stack[2] = 0x04 // } // Block ends with call to 0x2253, returns to 0x0410 label_0410: // Incoming return from call to 0x2253 at 0x040F 0410 5B JUMPDEST 0411 61 PUSH2 0x0bbf 0414 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bbf label_0415: // Incoming jump from 0x00E7, if 0x70a08231 == stack[-1] // Inputs[1] { @0416 msg.value } 0415 5B JUMPDEST 0416 34 CALLVALUE 0417 80 DUP1 0418 15 ISZERO 0419 61 PUSH2 0x0421 041C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0416 stack[0] = msg.value } // Block ends with conditional jump to 0x0421, if !msg.value label_041D: // Incoming jump from 0x041C, if not !msg.value // Inputs[1] { @0420 memory[0x00:0x00] } 041D 60 PUSH1 0x00 041F 80 DUP1 0420 FD *REVERT // Stack delta = +0 // Outputs[1] { @0420 revert(memory[0x00:0x00]); } // Block terminates label_0421: // Incoming jump from 0x041C, if !msg.value // Inputs[1] { @0429 msg.data.length } 0421 5B JUMPDEST 0422 50 POP 0423 61 PUSH2 0x02ae 0426 61 PUSH2 0x0430 0429 36 CALLDATASIZE 042A 60 PUSH1 0x04 042C 61 PUSH2 0x2253 042F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0423 stack[-1] = 0x02ae // @0426 stack[0] = 0x0430 // @0429 stack[1] = msg.data.length // @042A stack[2] = 0x04 // } // Block ends with call to 0x2253, returns to 0x0430 label_0430: // Incoming return from call to 0x2253 at 0x042F 0430 5B JUMPDEST 0431 61 PUSH2 0x0c48 0434 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c48 label_0435: // Incoming jump from 0x00F2, if 0x715018a6 == stack[-1] // Inputs[1] { @0436 msg.value } 0435 5B JUMPDEST 0436 34 CALLVALUE 0437 80 DUP1 0438 15 ISZERO 0439 61 PUSH2 0x0441 043C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0436 stack[0] = msg.value } // Block ends with conditional jump to 0x0441, if !msg.value label_043D: // Incoming jump from 0x043C, if not !msg.value // Inputs[1] { @0440 memory[0x00:0x00] } 043D 60 PUSH1 0x00 043F 80 DUP1 0440 FD *REVERT // Stack delta = +0 // Outputs[1] { @0440 revert(memory[0x00:0x00]); } // Block terminates label_0441: // Incoming jump from 0x043C, if !msg.value 0441 5B JUMPDEST 0442 50 POP 0443 61 PUSH2 0x0297 0446 61 PUSH2 0x0cb0 0449 56 *JUMP // Stack delta = +0 // Outputs[1] { @0443 stack[-1] = 0x0297 } // Block ends with call to 0x0cb0, returns to 0x0297 label_044A: // Incoming jump from 0x00FD, if 0x8da5cb5b == stack[-1] // Inputs[1] { @044B msg.value } 044A 5B JUMPDEST 044B 34 CALLVALUE 044C 80 DUP1 044D 15 ISZERO 044E 61 PUSH2 0x0456 0451 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044B stack[0] = msg.value } // Block ends with conditional jump to 0x0456, if !msg.value label_0452: // Incoming jump from 0x0451, if not !msg.value // Inputs[1] { @0455 memory[0x00:0x00] } 0452 60 PUSH1 0x00 0454 80 DUP1 0455 FD *REVERT // Stack delta = +0 // Outputs[1] { @0455 revert(memory[0x00:0x00]); } // Block terminates label_0456: // Incoming jump from 0x0451, if !msg.value // Inputs[1] { @045A storage[0x08] } 0456 5B JUMPDEST 0457 50 POP 0458 60 PUSH1 0x08 045A 54 SLOAD 045B 60 PUSH1 0x01 045D 60 PUSH1 0x01 045F 60 PUSH1 0xa0 0461 1B SHL 0462 03 SUB 0463 16 AND 0464 61 PUSH2 0x025f 0467 56 *JUMP // Stack delta = +0 // Outputs[1] { @0463 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x025f label_0468: // Incoming jump from 0x00AB, if 0x95d89b41 == stack[-1] // Inputs[1] { @0469 msg.value } 0468 5B JUMPDEST 0469 34 CALLVALUE 046A 80 DUP1 046B 15 ISZERO 046C 61 PUSH2 0x0474 046F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0469 stack[0] = msg.value } // Block ends with conditional jump to 0x0474, if !msg.value label_0470: // Incoming jump from 0x046F, if not !msg.value // Inputs[1] { @0473 memory[0x00:0x00] } 0470 60 PUSH1 0x00 0472 80 DUP1 0473 FD *REVERT // Stack delta = +0 // Outputs[1] { @0473 revert(memory[0x00:0x00]); } // Block terminates label_0474: // Incoming jump from 0x046F, if !msg.value 0474 5B JUMPDEST 0475 50 POP 0476 61 PUSH2 0x0232 0479 61 PUSH2 0x0d16 047C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0476 stack[-1] = 0x0232 } // Block ends with call to 0x0d16, returns to 0x0232 label_047D: // Incoming jump from 0x00B6, if 0xa22cb465 == stack[-1] // Inputs[1] { @047E msg.value } 047D 5B JUMPDEST 047E 34 CALLVALUE 047F 80 DUP1 0480 15 ISZERO 0481 61 PUSH2 0x0489 0484 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047E stack[0] = msg.value } // Block ends with conditional jump to 0x0489, if !msg.value label_0485: // Incoming jump from 0x0484, if not !msg.value // Inputs[1] { @0488 memory[0x00:0x00] } 0485 60 PUSH1 0x00 0487 80 DUP1 0488 FD *REVERT // Stack delta = +0 // Outputs[1] { @0488 revert(memory[0x00:0x00]); } // Block terminates label_0489: // Incoming jump from 0x0484, if !msg.value // Inputs[1] { @0491 msg.data.length } 0489 5B JUMPDEST 048A 50 POP 048B 61 PUSH2 0x0297 048E 61 PUSH2 0x0498 0491 36 CALLDATASIZE 0492 60 PUSH1 0x04 0494 61 PUSH2 0x2336 0497 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @048B stack[-1] = 0x0297 // @048E stack[0] = 0x0498 // @0491 stack[1] = msg.data.length // @0492 stack[2] = 0x04 // } // Block ends with call to 0x2336, returns to 0x0498 label_0498: // Incoming return from call to 0x2336 at 0x0497 0498 5B JUMPDEST 0499 61 PUSH2 0x0d25 049C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d25 label_049D: // Incoming jump from 0x00C1, if 0xa4766f9d == stack[-1] // Inputs[1] { @049E msg.value } 049D 5B JUMPDEST 049E 34 CALLVALUE 049F 80 DUP1 04A0 15 ISZERO 04A1 61 PUSH2 0x04a9 04A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049E stack[0] = msg.value } // Block ends with conditional jump to 0x04a9, if !msg.value label_04A5: // Incoming jump from 0x04A4, if not !msg.value // Inputs[1] { @04A8 memory[0x00:0x00] } 04A5 60 PUSH1 0x00 04A7 80 DUP1 04A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A8 revert(memory[0x00:0x00]); } // Block terminates label_04A9: // Incoming jump from 0x04A4, if !msg.value 04A9 5B JUMPDEST 04AA 50 POP 04AB 61 PUSH2 0x02ae 04AE 60 PUSH1 0x04 04B0 81 DUP2 04B1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04AB stack[-1] = 0x02ae // @04AE stack[0] = 0x04 // } // Block ends with unconditional jump to 0x02ae label_04B2: // Incoming jump from 0x00CC, if 0xaddf02f5 == stack[-1] // Inputs[1] { @04B3 msg.value } 04B2 5B JUMPDEST 04B3 34 CALLVALUE 04B4 80 DUP1 04B5 15 ISZERO 04B6 61 PUSH2 0x04be 04B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B3 stack[0] = msg.value } // Block ends with conditional jump to 0x04be, if !msg.value label_04BA: // Incoming jump from 0x04B9, if not !msg.value // Inputs[1] { @04BD memory[0x00:0x00] } 04BA 60 PUSH1 0x00 04BC 80 DUP1 04BD FD *REVERT // Stack delta = +0 // Outputs[1] { @04BD revert(memory[0x00:0x00]); } // Block terminates label_04BE: // Incoming jump from 0x04B9, if !msg.value // Inputs[1] { @04C6 msg.data.length } 04BE 5B JUMPDEST 04BF 50 POP 04C0 61 PUSH2 0x0297 04C3 61 PUSH2 0x04cd 04C6 36 CALLDATASIZE 04C7 60 PUSH1 0x04 04C9 61 PUSH2 0x22b5 04CC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04C0 stack[-1] = 0x0297 // @04C3 stack[0] = 0x04cd // @04C6 stack[1] = msg.data.length // @04C7 stack[2] = 0x04 // } // Block ends with call to 0x22b5, returns to 0x04CD label_04CD: // Incoming return from call to 0x22B5 at 0x04CC 04CD 5B JUMPDEST 04CE 61 PUSH2 0x0dd4 04D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dd4 label_04D2: // Incoming jump from 0x006F, if 0xb6b6f0c3 == stack[-1] // Inputs[1] { @04D3 msg.value } 04D2 5B JUMPDEST 04D3 34 CALLVALUE 04D4 80 DUP1 04D5 15 ISZERO 04D6 61 PUSH2 0x04de 04D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D3 stack[0] = msg.value } // Block ends with conditional jump to 0x04de, if !msg.value label_04DA: // Incoming jump from 0x04D9, if not !msg.value // Inputs[1] { @04DD memory[0x00:0x00] } 04DA 60 PUSH1 0x00 04DC 80 DUP1 04DD FD *REVERT // Stack delta = +0 // Outputs[1] { @04DD revert(memory[0x00:0x00]); } // Block terminates label_04DE: // Incoming jump from 0x04D9, if !msg.value 04DE 5B JUMPDEST 04DF 50 POP 04E0 61 PUSH2 0x02ae 04E3 60 PUSH1 0x03 04E5 81 DUP2 04E6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04E0 stack[-1] = 0x02ae // @04E3 stack[0] = 0x03 // } // Block ends with unconditional jump to 0x02ae label_04E7: // Incoming jump from 0x007A, if 0xb88d4fde == stack[-1] // Inputs[1] { @04E8 msg.value } 04E7 5B JUMPDEST 04E8 34 CALLVALUE 04E9 80 DUP1 04EA 15 ISZERO 04EB 61 PUSH2 0x04f3 04EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E8 stack[0] = msg.value } // Block ends with conditional jump to 0x04f3, if !msg.value label_04EF: // Incoming jump from 0x04EE, if not !msg.value // Inputs[1] { @04F2 memory[0x00:0x00] } 04EF 60 PUSH1 0x00 04F1 80 DUP1 04F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F2 revert(memory[0x00:0x00]); } // Block terminates label_04F3: // Incoming jump from 0x04EE, if !msg.value // Inputs[1] { @04FB msg.data.length } 04F3 5B JUMPDEST 04F4 50 POP 04F5 61 PUSH2 0x0297 04F8 61 PUSH2 0x0502 04FB 36 CALLDATASIZE 04FC 60 PUSH1 0x04 04FE 61 PUSH2 0x238b 0501 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F5 stack[-1] = 0x0297 // @04F8 stack[0] = 0x0502 // @04FB stack[1] = msg.data.length // @04FC stack[2] = 0x04 // } // Block ends with call to 0x238b, returns to 0x0502 label_0502: // Incoming return from call to 0x238B at 0x0501 0502 5B JUMPDEST 0503 61 PUSH2 0x0e8a 0506 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e8a label_0507: // Incoming jump from 0x0085, if 0xc87b56dd == stack[-1] // Inputs[1] { @0508 msg.value } 0507 5B JUMPDEST 0508 34 CALLVALUE 0509 80 DUP1 050A 15 ISZERO 050B 61 PUSH2 0x0513 050E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0508 stack[0] = msg.value } // Block ends with conditional jump to 0x0513, if !msg.value label_050F: // Incoming jump from 0x050E, if not !msg.value // Inputs[1] { @0512 memory[0x00:0x00] } 050F 60 PUSH1 0x00 0511 80 DUP1 0512 FD *REVERT // Stack delta = +0 // Outputs[1] { @0512 revert(memory[0x00:0x00]); } // Block terminates label_0513: // Incoming jump from 0x050E, if !msg.value // Inputs[1] { @051B msg.data.length } 0513 5B JUMPDEST 0514 50 POP 0515 61 PUSH2 0x0232 0518 61 PUSH2 0x0522 051B 36 CALLDATASIZE 051C 60 PUSH1 0x04 051E 61 PUSH2 0x20e3 0521 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0515 stack[-1] = 0x0232 // @0518 stack[0] = 0x0522 // @051B stack[1] = msg.data.length // @051C stack[2] = 0x04 // } // Block ends with call to 0x20e3, returns to 0x0522 label_0522: // Incoming return from call to 0x20E3 at 0x0521 0522 5B JUMPDEST 0523 61 PUSH2 0x0edb 0526 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0edb label_0527: // Incoming jump from 0x0090, if 0xd060404c == stack[-1] // Inputs[1] { @0528 msg.value } 0527 5B JUMPDEST 0528 34 CALLVALUE 0529 80 DUP1 052A 15 ISZERO 052B 61 PUSH2 0x0533 052E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0528 stack[0] = msg.value } // Block ends with conditional jump to 0x0533, if !msg.value label_052F: // Incoming jump from 0x052E, if not !msg.value // Inputs[1] { @0532 memory[0x00:0x00] } 052F 60 PUSH1 0x00 0531 80 DUP1 0532 FD *REVERT // Stack delta = +0 // Outputs[1] { @0532 revert(memory[0x00:0x00]); } // Block terminates label_0533: // Incoming jump from 0x052E, if !msg.value // Inputs[1] { @053B msg.data.length } 0533 5B JUMPDEST 0534 50 POP 0535 61 PUSH2 0x02ae 0538 61 PUSH2 0x0542 053B 36 CALLDATASIZE 053C 60 PUSH1 0x04 053E 61 PUSH2 0x2253 0541 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0535 stack[-1] = 0x02ae // @0538 stack[0] = 0x0542 // @053B stack[1] = msg.data.length // @053C stack[2] = 0x04 // } // Block ends with call to 0x2253, returns to 0x0542 label_0542: // Incoming return from call to 0x2253 at 0x0541 0542 5B JUMPDEST 0543 61 PUSH2 0x0f0f 0546 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f0f label_0547: // Incoming jump from 0x003E, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0548 msg.value } 0547 5B JUMPDEST 0548 34 CALLVALUE 0549 80 DUP1 054A 15 ISZERO 054B 61 PUSH2 0x0553 054E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0548 stack[0] = msg.value } // Block ends with conditional jump to 0x0553, if !msg.value label_054F: // Incoming jump from 0x054E, if not !msg.value // Inputs[1] { @0552 memory[0x00:0x00] } 054F 60 PUSH1 0x00 0551 80 DUP1 0552 FD *REVERT // Stack delta = +0 // Outputs[1] { @0552 revert(memory[0x00:0x00]); } // Block terminates label_0553: // Incoming jump from 0x054E, if !msg.value // Inputs[1] { @055B msg.data.length } 0553 5B JUMPDEST 0554 50 POP 0555 61 PUSH2 0x0208 0558 61 PUSH2 0x0562 055B 36 CALLDATASIZE 055C 60 PUSH1 0x04 055E 61 PUSH2 0x23f7 0561 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0555 stack[-1] = 0x0208 // @0558 stack[0] = 0x0562 // @055B stack[1] = msg.data.length // @055C stack[2] = 0x04 // } // Block ends with call to 0x23f7, returns to 0x0562 label_0562: // Incoming call from 0x132A, returns to 0x132B // Incoming return from call to 0x23F7 at 0x0561 // Incoming call from 0x07E5, returns to 0x07E6 // Inputs[6] // { // @056B stack[-2] // @057E memory[0x00:0x40] // @057F stack[-1] // @0589 memory[0x00:0x40] // @058A storage[keccak256(memory[0x00:0x40])] // @058E stack[-3] // } 0562 5B JUMPDEST 0563 60 PUSH1 0x01 0565 60 PUSH1 0x01 0567 60 PUSH1 0xa0 0569 1B SHL 056A 03 SUB 056B 91 SWAP2 056C 82 DUP3 056D 16 AND 056E 60 PUSH1 0x00 0570 90 SWAP1 0571 81 DUP2 0572 52 MSTORE 0573 60 PUSH1 0x07 0575 60 PUSH1 0x20 0577 90 SWAP1 0578 81 DUP2 0579 52 MSTORE 057A 60 PUSH1 0x40 057C 80 DUP1 057D 83 DUP4 057E 20 SHA3 057F 93 SWAP4 0580 90 SWAP1 0581 94 SWAP5 0582 16 AND 0583 82 DUP3 0584 52 MSTORE 0585 91 SWAP2 0586 90 SWAP1 0587 91 SWAP2 0588 52 MSTORE 0589 20 SHA3 058A 54 SLOAD 058B 60 PUSH1 0xff 058D 16 AND 058E 90 SWAP1 058F 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0572 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0579 memory[0x20:0x40] = 0x07 // @0584 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0588 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @058E stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0590: // Incoming jump from 0x0049, if 0xf2fde38b == stack[-1] // Inputs[1] { @0591 msg.value } 0590 5B JUMPDEST 0591 34 CALLVALUE 0592 80 DUP1 0593 15 ISZERO 0594 61 PUSH2 0x059c 0597 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0591 stack[0] = msg.value } // Block ends with conditional jump to 0x059c, if !msg.value label_0598: // Incoming jump from 0x0597, if not !msg.value // Inputs[1] { @059B memory[0x00:0x00] } 0598 60 PUSH1 0x00 059A 80 DUP1 059B FD *REVERT // Stack delta = +0 // Outputs[1] { @059B revert(memory[0x00:0x00]); } // Block terminates label_059C: // Incoming jump from 0x0597, if !msg.value // Inputs[1] { @05A4 msg.data.length } 059C 5B JUMPDEST 059D 50 POP 059E 61 PUSH2 0x0297 05A1 61 PUSH2 0x05ab 05A4 36 CALLDATASIZE 05A5 60 PUSH1 0x04 05A7 61 PUSH2 0x2253 05AA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @059E stack[-1] = 0x0297 // @05A1 stack[0] = 0x05ab // @05A4 stack[1] = msg.data.length // @05A5 stack[2] = 0x04 // } // Block ends with call to 0x2253, returns to 0x05AB label_05AB: // Incoming return from call to 0x2253 at 0x05AA 05AB 5B JUMPDEST 05AC 61 PUSH2 0x0f43 05AF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f43 label_05B0: // Incoming jump from 0x0054, if 0xf46a04eb == stack[-1] // Inputs[1] { @05B1 msg.value } 05B0 5B JUMPDEST 05B1 34 CALLVALUE 05B2 80 DUP1 05B3 15 ISZERO 05B4 61 PUSH2 0x05bc 05B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B1 stack[0] = msg.value } // Block ends with conditional jump to 0x05bc, if !msg.value label_05B8: // Incoming jump from 0x05B7, if not !msg.value // Inputs[1] { @05BB memory[0x00:0x00] } 05B8 60 PUSH1 0x00 05BA 80 DUP1 05BB FD *REVERT // Stack delta = +0 // Outputs[1] { @05BB revert(memory[0x00:0x00]); } // Block terminates label_05BC: // Incoming jump from 0x05B7, if !msg.value // Inputs[1] { @05C4 msg.data.length } 05BC 5B JUMPDEST 05BD 50 POP 05BE 61 PUSH2 0x0297 05C1 61 PUSH2 0x05cb 05C4 36 CALLDATASIZE 05C5 60 PUSH1 0x04 05C7 61 PUSH2 0x2430 05CA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05BE stack[-1] = 0x0297 // @05C1 stack[0] = 0x05cb // @05C4 stack[1] = msg.data.length // @05C5 stack[2] = 0x04 // } // Block ends with call to 0x2430, returns to 0x05CB label_05CB: // Incoming return from call to 0x2430 at 0x05CA 05CB 5B JUMPDEST 05CC 61 PUSH2 0x1022 05CF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1022 label_05D0: // Incoming jump from 0x005F, if 0xf724be4e == stack[-1] // Inputs[1] { @05D7 msg.data.length } 05D0 5B JUMPDEST 05D1 61 PUSH2 0x0297 05D4 61 PUSH2 0x05de 05D7 36 CALLDATASIZE 05D8 60 PUSH1 0x04 05DA 61 PUSH2 0x244b 05DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05D1 stack[0] = 0x0297 // @05D4 stack[1] = 0x05de // @05D7 stack[2] = msg.data.length // @05D8 stack[3] = 0x04 // } // Block ends with call to 0x244b, returns to 0x05DE label_05DE: // Incoming return from call to 0x244B at 0x05DD 05DE 5B JUMPDEST 05DF 61 PUSH2 0x10b5 05E2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10b5 label_05E3: // Incoming jump from 0x0207 // Inputs[1] { @05EF stack[-1] } 05E3 5B JUMPDEST 05E4 60 PUSH1 0x00 05E6 60 PUSH1 0x01 05E8 60 PUSH1 0x01 05EA 60 PUSH1 0xe0 05EC 1B SHL 05ED 03 SUB 05EE 19 NOT 05EF 82 DUP3 05F0 16 AND 05F1 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 0612 14 EQ 0613 80 DUP1 0614 61 PUSH2 0x0646 0617 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05E4 stack[0] = 0x00 // @0612 stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0646, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0618: // Incoming jump from 0x0617, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0622 stack[-3] } 0618 50 POP 0619 60 PUSH1 0x01 061B 60 PUSH1 0x01 061D 60 PUSH1 0xe0 061F 1B SHL 0620 03 SUB 0621 19 NOT 0622 82 DUP3 0623 16 AND 0624 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 0645 14 EQ 0646 5B JUMPDEST 0647 80 DUP1 0648 61 PUSH2 0x067a 064B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0645 stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x067a, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_064C: // Incoming jump from 0x064B, if not stack[-1] // Incoming jump from 0x064B, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0677 stack[-3] } 064C 50 POP 064D 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 066E 60 PUSH1 0x01 0670 60 PUSH1 0x01 0672 60 PUSH1 0xe0 0674 1B SHL 0675 03 SUB 0676 19 NOT 0677 83 DUP4 0678 16 AND 0679 14 EQ // Stack delta = +0 // Outputs[1] { @0679 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block continues label_067A: // Incoming jump from 0x1229, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x0679 // Incoming jump from 0x0F42 // Incoming jump from 0x064B, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x064B, if stack[-1] // Inputs[3] // { // @067B stack[-1] // @067B stack[-4] // @067C stack[-3] // } 067A 5B JUMPDEST 067B 92 SWAP3 067C 91 SWAP2 067D 50 POP 067E 50 POP 067F 56 *JUMP // Stack delta = -3 // Outputs[1] { @067B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0680: // Incoming call from 0x0231, returns to 0x0232 // Inputs[1] { @0686 storage[0x02] } 0680 5B JUMPDEST 0681 60 PUSH1 0x60 0683 60 PUSH1 0x02 0685 80 DUP1 0686 54 SLOAD 0687 61 PUSH2 0x068f 068A 90 SWAP1 068B 61 PUSH2 0x24b3 068E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0681 stack[0] = 0x60 // @0683 stack[1] = 0x02 // @068A stack[2] = 0x068f // @068A stack[3] = storage[0x02] // } // Block ends with call to 0x24b3, returns to 0x068F label_068F: // Incoming return from call to 0x24B3 at 0x0D24 // Incoming return from call to 0x24B3 at 0x068E // Inputs[4] // { // @0690 stack[-1] // @069F memory[0x40:0x60] // @06A7 stack[-2] // @06B2 storage[stack[-2]] // } 068F 5B JUMPDEST 0690 80 DUP1 0691 60 PUSH1 0x1f 0693 01 ADD 0694 60 PUSH1 0x20 0696 80 DUP1 0697 91 SWAP2 0698 04 DIV 0699 02 MUL 069A 60 PUSH1 0x20 069C 01 ADD 069D 60 PUSH1 0x40 069F 51 MLOAD 06A0 90 SWAP1 06A1 81 DUP2 06A2 01 ADD 06A3 60 PUSH1 0x40 06A5 52 MSTORE 06A6 80 DUP1 06A7 92 SWAP3 06A8 91 SWAP2 06A9 90 SWAP1 06AA 81 DUP2 06AB 81 DUP2 06AC 52 MSTORE 06AD 60 PUSH1 0x20 06AF 01 ADD 06B0 82 DUP3 06B1 80 DUP1 06B2 54 SLOAD 06B3 61 PUSH2 0x06bb 06B6 90 SWAP1 06B7 61 PUSH2 0x24b3 06BA 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @06A5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @06A7 stack[-2] = memory[0x40:0x60] // @06A8 stack[-1] = stack[-2] // @06A9 stack[0] = stack[-1] // @06AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06AF stack[1] = 0x20 + memory[0x40:0x60] // @06B0 stack[2] = stack[-2] // @06B6 stack[4] = storage[stack[-2]] // @06B6 stack[3] = 0x06bb // } // Block ends with call to 0x24b3, returns to 0x06BB label_06BB: // Incoming return from call to 0x24B3 at 0x06BA // Inputs[1] { @06BC stack[-1] } 06BB 5B JUMPDEST 06BC 80 DUP1 06BD 15 ISZERO 06BE 61 PUSH2 0x0708 06C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0708, if !stack[-1] label_06C2: // Incoming jump from 0x06C1, if not !stack[-1] // Inputs[1] { @06C2 stack[-1] } 06C2 80 DUP1 06C3 60 PUSH1 0x1f 06C5 10 LT 06C6 61 PUSH2 0x06dd 06C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06dd, if 0x1f < stack[-1] label_06CA: // Incoming jump from 0x06C9, if not 0x1f < stack[-1] // Inputs[4] // { // @06CE stack[-2] // @06CF storage[stack[-2]] // @06D2 stack[-3] // @06D4 stack[-1] // } 06CA 61 PUSH2 0x0100 06CD 80 DUP1 06CE 83 DUP4 06CF 54 SLOAD 06D0 04 DIV 06D1 02 MUL 06D2 83 DUP4 06D3 52 MSTORE 06D4 91 SWAP2 06D5 60 PUSH1 0x20 06D7 01 ADD 06D8 91 SWAP2 06D9 61 PUSH2 0x0708 06DC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06D3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06D8 stack[-1] = stack[-1] // @06D8 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0708 label_06DD: // Incoming jump from 0x06C9, if 0x1f < stack[-1] // Inputs[5] // { // @06DE stack[-3] // @06DF stack[-1] // @06E1 stack[-2] // @06E9 memory[0x00:0x20] // @06ED storage[keccak256(memory[0x00:0x20])] // } 06DD 5B JUMPDEST 06DE 82 DUP3 06DF 01 ADD 06E0 91 SWAP2 06E1 90 SWAP1 06E2 60 PUSH1 0x00 06E4 52 MSTORE 06E5 60 PUSH1 0x20 06E7 60 PUSH1 0x00 06E9 20 SHA3 06EA 90 SWAP1 06EB 5B JUMPDEST 06EC 81 DUP2 06ED 54 SLOAD 06EE 81 DUP2 06EF 52 MSTORE 06F0 90 SWAP1 06F1 60 PUSH1 0x01 06F3 01 ADD 06F4 90 SWAP1 06F5 60 PUSH1 0x20 06F7 01 ADD 06F8 80 DUP1 06F9 83 DUP4 06FA 11 GT 06FB 61 PUSH2 0x06eb 06FE 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @06E0 stack[-3] = stack[-3] + stack[-1] // @06E4 memory[0x00:0x20] = stack[-2] // @06EF memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06F4 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06F7 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06eb, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06FF: // Incoming jump from 0x06FE, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x06FE, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @06FF stack[-3] // @0700 stack[-1] // } 06FF 82 DUP3 0700 90 SWAP1 0701 03 SUB 0702 60 PUSH1 0x1f 0704 16 AND 0705 82 DUP3 0706 01 ADD 0707 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0707 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0707 stack[-1] = stack[-3] // } // Block continues label_0708: // Incoming jump from 0x06C1, if !stack[-1] // Incoming jump from 0x0707 // Incoming jump from 0x06DC // Inputs[3] // { // @070E stack[-7] // @070E stack[-6] // @0710 stack[-8] // } 0708 5B JUMPDEST 0709 50 POP 070A 50 POP 070B 50 POP 070C 50 POP 070D 50 POP 070E 90 SWAP1 070F 50 POP 0710 90 SWAP1 0711 56 *JUMP // Stack delta = -7 // Outputs[1] { @0710 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0712: // Incoming jump from 0x025E // Incoming call from 0x133A, returns to 0x133B // Inputs[1] { @0718 stack[-1] } 0712 5B JUMPDEST 0713 60 PUSH1 0x00 0715 61 PUSH2 0x071d 0718 82 DUP3 0719 61 PUSH2 0x121d 071C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0713 stack[0] = 0x00 // @0715 stack[1] = 0x071d // @0718 stack[2] = stack[-1] // } // Block ends with call to 0x121d, returns to 0x071D label_071D: // Incoming return from call to 0x121D at 0x071C // Inputs[1] { @0721 stack[-1] } 071D 5B JUMPDEST 071E 61 PUSH2 0x0753 0721 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0753, if stack[-1] label_0722: // Incoming jump from 0x0721, if not stack[-1] // Inputs[3] // { // @0724 memory[0x40:0x60] // @074D memory[0x40:0x60] // @0752 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0722 60 PUSH1 0x40 0724 51 MLOAD 0725 7F PUSH32 0xcf4700e400000000000000000000000000000000000000000000000000000000 0746 81 DUP2 0747 52 MSTORE 0748 60 PUSH1 0x04 074A 01 ADD 074B 60 PUSH1 0x40 074D 51 MLOAD 074E 80 DUP1 074F 91 SWAP2 0750 03 SUB 0751 90 SWAP1 0752 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0747 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcf4700e400000000000000000000000000000000000000000000000000000000 // @0752 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0753: // Incoming jump from 0x0721, if stack[-1] // Inputs[4] // { // @0757 stack[-2] // @0762 memory[0x00:0x40] // @0763 storage[keccak256(memory[0x00:0x40])] // @076D stack[-3] // } 0753 5B JUMPDEST 0754 50 POP 0755 60 PUSH1 0x00 0757 90 SWAP1 0758 81 DUP2 0759 52 MSTORE 075A 60 PUSH1 0x06 075C 60 PUSH1 0x20 075E 52 MSTORE 075F 60 PUSH1 0x40 0761 90 SWAP1 0762 20 SHA3 0763 54 SLOAD 0764 60 PUSH1 0x01 0766 60 PUSH1 0x01 0768 60 PUSH1 0xa0 076A 1B SHL 076B 03 SUB 076C 16 AND 076D 90 SWAP1 076E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0759 memory[0x00:0x20] = stack[-2] // @075E memory[0x20:0x40] = 0x06 // @076D stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_076F: // Incoming jump from 0x0296 // Inputs[1] { @0775 stack[-1] } 076F 5B JUMPDEST 0770 60 PUSH1 0x00 0772 61 PUSH2 0x077a 0775 82 DUP3 0776 61 PUSH2 0x0bad 0779 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0770 stack[0] = 0x00 // @0772 stack[1] = 0x077a // @0775 stack[2] = stack[-1] // } // Block ends with call to 0x0bad, returns to 0x077A label_077A: // Incoming return from call to 0x0BAD at 0x0779 // Inputs[3] // { // @077B stack[-1] // @077B stack[-2] // @0787 stack[-4] // } 077A 5B JUMPDEST 077B 90 SWAP1 077C 50 POP 077D 80 DUP1 077E 60 PUSH1 0x01 0780 60 PUSH1 0x01 0782 60 PUSH1 0xa0 0784 1B SHL 0785 03 SUB 0786 16 AND 0787 83 DUP4 0788 60 PUSH1 0x01 078A 60 PUSH1 0x01 078C 60 PUSH1 0xa0 078E 1B SHL 078F 03 SUB 0790 16 AND 0791 14 EQ 0792 15 ISZERO 0793 61 PUSH2 0x07c8 0796 57 *JUMPI // Stack delta = -1 // Outputs[1] { @077B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x07c8, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0797: // Incoming jump from 0x0796, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @0799 memory[0x40:0x60] // @07C2 memory[0x40:0x60] // @07C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0797 60 PUSH1 0x40 0799 51 MLOAD 079A 7F PUSH32 0x943f7b8c00000000000000000000000000000000000000000000000000000000 07BB 81 DUP2 07BC 52 MSTORE 07BD 60 PUSH1 0x04 07BF 01 ADD 07C0 60 PUSH1 0x40 07C2 51 MLOAD 07C3 80 DUP1 07C4 91 SWAP2 07C5 03 SUB 07C6 90 SWAP1 07C7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @07BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x943f7b8c00000000000000000000000000000000000000000000000000000000 // @07C7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07C8: // Incoming jump from 0x0796, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @07C9 msg.sender // @07D2 stack[-1] // } 07C8 5B JUMPDEST 07C9 33 CALLER 07CA 60 PUSH1 0x01 07CC 60 PUSH1 0x01 07CE 60 PUSH1 0xa0 07D0 1B SHL 07D1 03 SUB 07D2 82 DUP3 07D3 16 AND 07D4 14 EQ 07D5 80 DUP1 07D6 15 ISZERO 07D7 90 SWAP1 07D8 61 PUSH2 0x07e8 07DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07D7 stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x07e8, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_07DC: // Incoming jump from 0x07DB, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @07E0 stack[-2] // @07E1 msg.sender // } 07DC 50 POP 07DD 61 PUSH2 0x07e6 07E0 81 DUP2 07E1 33 CALLER 07E2 61 PUSH2 0x0562 07E5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07DD stack[-1] = 0x07e6 // @07E0 stack[0] = stack[-2] // @07E1 stack[1] = msg.sender // } // Block ends with call to 0x0562, returns to 0x07E6 label_07E6: // Incoming return from call to 0x0562 at 0x07E5 // Inputs[1] { @07E7 stack[-1] } 07E6 5B JUMPDEST 07E7 15 ISZERO // Stack delta = +0 // Outputs[1] { @07E7 stack[-1] = !stack[-1] } // Block continues label_07E8: // Incoming jump from 0x07E7 // Incoming jump from 0x07DB, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @07E9 stack[-1] } 07E8 5B JUMPDEST 07E9 15 ISZERO 07EA 61 PUSH2 0x081f 07ED 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x081f, if !stack[-1] label_07EE: // Incoming jump from 0x07ED, if not !stack[-1] // Inputs[3] // { // @07F0 memory[0x40:0x60] // @0819 memory[0x40:0x60] // @081E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07EE 60 PUSH1 0x40 07F0 51 MLOAD 07F1 7F PUSH32 0xcfb3b94200000000000000000000000000000000000000000000000000000000 0812 81 DUP2 0813 52 MSTORE 0814 60 PUSH1 0x04 0816 01 ADD 0817 60 PUSH1 0x40 0819 51 MLOAD 081A 80 DUP1 081B 91 SWAP2 081C 03 SUB 081D 90 SWAP1 081E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0813 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcfb3b94200000000000000000000000000000000000000000000000000000000 // @081E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_081F: // Incoming jump from 0x07ED, if !stack[-1] // Inputs[3] // { // @0823 stack[-3] // @0824 stack[-2] // @0825 stack[-1] // } 081F 5B JUMPDEST 0820 61 PUSH2 0x082a 0823 83 DUP4 0824 83 DUP4 0825 83 DUP4 0826 61 PUSH2 0x1248 0829 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0820 stack[0] = 0x082a // @0823 stack[1] = stack[-3] // @0824 stack[2] = stack[-2] // @0825 stack[3] = stack[-1] // } // Block ends with call to 0x1248, returns to 0x082A label_082A: // Incoming return from call to 0x1A2F at 0x1A0A // Incoming return from call to 0x1248 at 0x0829 // Inputs[1] { @082E stack[-4] } 082A 5B JUMPDEST 082B 50 POP 082C 50 POP 082D 50 POP 082E 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_082F: // Incoming jump from 0x02F1 // Incoming jump from 0x0B9C // Inputs[3] // { // @0833 stack[-3] // @0834 stack[-2] // @0835 stack[-1] // } 082F 5B JUMPDEST 0830 61 PUSH2 0x082a 0833 83 DUP4 0834 83 DUP4 0835 83 DUP4 0836 61 PUSH2 0x12b1 0839 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0830 stack[0] = 0x082a // @0833 stack[1] = stack[-3] // @0834 stack[2] = stack[-2] // @0835 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x12b1 label_083A: // Incoming call from 0x0334, returns to 0x0297 // Inputs[2] // { // @083D storage[0x08] // @0847 msg.sender // } 083A 5B JUMPDEST 083B 60 PUSH1 0x08 083D 54 SLOAD 083E 60 PUSH1 0x01 0840 60 PUSH1 0x01 0842 60 PUSH1 0xa0 0844 1B SHL 0845 03 SUB 0846 16 AND 0847 33 CALLER 0848 14 EQ 0849 61 PUSH2 0x0899 084C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0899, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_084D: // Incoming jump from 0x084C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @084F memory[0x40:0x60] } 084D 60 PUSH1 0x40 084F 51 MLOAD 0850 62 PUSH3 0x461bcd 0854 60 PUSH1 0xe5 0856 1B SHL 0857 81 DUP2 0858 52 MSTORE 0859 60 PUSH1 0x20 085B 60 PUSH1 0x04 085D 82 DUP3 085E 01 ADD 085F 81 DUP2 0860 90 SWAP1 0861 52 MSTORE 0862 60 PUSH1 0x24 0864 82 DUP3 0865 01 ADD 0866 52 MSTORE 0867 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0888 60 PUSH1 0x44 088A 82 DUP3 088B 01 ADD 088C 52 MSTORE 088D 60 PUSH1 0x64 088F 01 ADD // Stack delta = +1 // Outputs[5] // { // @0858 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0861 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0866 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @088C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @088F stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0890: // Incoming jump from 0x1E6C // Incoming jump from 0x0AAD // Incoming jump from 0x1D30 // Incoming jump from 0x088F // Incoming jump from 0x1D92 // Incoming jump from 0x0B36 // Incoming jump from 0x0E2D // Incoming jump from 0x0C18 // Incoming jump from 0x09C7 // Incoming jump from 0x0D09 // Incoming jump from 0x1DFF // Incoming jump from 0x0F9C // Incoming jump from 0x0916 // Incoming jump from 0x1018 // Incoming jump from 0x0A3C // Incoming jump from 0x107B // Inputs[3] // { // @0893 memory[0x40:0x60] // @0895 stack[-1] // @0898 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0890 5B JUMPDEST 0891 60 PUSH1 0x40 0893 51 MLOAD 0894 80 DUP1 0895 91 SWAP2 0896 03 SUB 0897 90 SWAP1 0898 FD *REVERT // Stack delta = -1 // Outputs[1] { @0898 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0899: // Incoming jump from 0x084C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @089C storage[0x0b] } 0899 5B JUMPDEST 089A 60 PUSH1 0x0b 089C 54 SLOAD 089D 60 PUSH1 0x01 089F 60 PUSH1 0x01 08A1 60 PUSH1 0xa0 08A3 1B SHL 08A4 03 SUB 08A5 16 AND 08A6 61 PUSH2 0x0917 08A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0917, if (0x01 << 0xa0) - 0x01 & storage[0x0b] label_08AA: // Incoming jump from 0x08A9, if not (0x01 << 0xa0) - 0x01 & storage[0x0b] // Inputs[1] { @08AC memory[0x40:0x60] } 08AA 60 PUSH1 0x40 08AC 51 MLOAD 08AD 62 PUSH3 0x461bcd 08B1 60 PUSH1 0xe5 08B3 1B SHL 08B4 81 DUP2 08B5 52 MSTORE 08B6 60 PUSH1 0x20 08B8 60 PUSH1 0x04 08BA 82 DUP3 08BB 01 ADD 08BC 52 MSTORE 08BD 60 PUSH1 0x23 08BF 60 PUSH1 0x24 08C1 82 DUP3 08C2 01 ADD 08C3 52 MSTORE 08C4 7F PUSH32 0x43616e6e6f742077697468647261772066756e647320746f2030206164647265 08E5 60 PUSH1 0x44 08E7 82 DUP3 08E8 01 ADD 08E9 52 MSTORE 08EA 7F PUSH32 0x73732e0000000000000000000000000000000000000000000000000000000000 090B 60 PUSH1 0x64 090D 82 DUP3 090E 01 ADD 090F 52 MSTORE 0910 60 PUSH1 0x84 0912 01 ADD 0913 61 PUSH2 0x0890 0916 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08BC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08C3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @08E9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f742077697468647261772066756e647320746f2030206164647265 // @090F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73732e0000000000000000000000000000000000000000000000000000000000 // @0912 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0917: // Incoming jump from 0x08A9, if (0x01 << 0xa0) - 0x01 & storage[0x0b] // Inputs[6] // { // @091A storage[0x0b] // @091D memory[0x40:0x60] // @092A address(this).balance // @092A address(this) // @093A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @093A address(storage[0x0b] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 0917 5B JUMPDEST 0918 60 PUSH1 0x0b 091A 54 SLOAD 091B 60 PUSH1 0x40 091D 51 MLOAD 091E 60 PUSH1 0x01 0920 60 PUSH1 0x01 0922 60 PUSH1 0xa0 0924 1B SHL 0925 03 SUB 0926 90 SWAP1 0927 91 SWAP2 0928 16 AND 0929 90 SWAP1 092A 47 SELFBALANCE 092B 80 DUP1 092C 15 ISZERO 092D 61 PUSH2 0x08fc 0930 02 MUL 0931 91 SWAP2 0932 60 PUSH1 0x00 0934 81 DUP2 0935 81 DUP2 0936 81 DUP2 0937 85 DUP6 0938 88 DUP9 0939 88 DUP9 093A F1 CALL 093B 93 SWAP4 093C 50 POP 093D 50 POP 093E 50 POP 093F 50 POP 0940 15 ISZERO 0941 80 DUP1 0942 15 ISZERO 0943 61 PUSH2 0x0950 0946 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @093A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x0b] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0940 stack[0] = !address(storage[0x0b] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0950, if !!address(storage[0x0b] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0947: // Incoming jump from 0x0946, if not !!address(storage[0x0b] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0947 returndata.length // @094B returndata[0x00:0x00 + returndata.length] // @094C returndata.length // @094F memory[0x00:0x00 + returndata.length] // } 0947 3D RETURNDATASIZE 0948 60 PUSH1 0x00 094A 80 DUP1 094B 3E RETURNDATACOPY 094C 3D RETURNDATASIZE 094D 60 PUSH1 0x00 094F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @094B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @094F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0950: // Incoming return from call to 0x09DD at 0x09DC // Incoming jump from 0x0946, if !!address(storage[0x0b] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming return from call to 0x163C at 0x1021 // Incoming jump from 0x210C, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x2056, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1E1A, if !(stack[-1] == stack[-2]) // Inputs[1] { @0952 stack[-2] } 0950 5B JUMPDEST 0951 50 POP 0952 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0953: // Incoming jump from 0x0354 // Inputs[4] // { // @0957 stack[-3] // @0958 stack[-2] // @0959 stack[-1] // @095C memory[0x40:0x60] // } 0953 5B JUMPDEST 0954 61 PUSH2 0x082a 0957 83 DUP4 0958 83 DUP4 0959 83 DUP4 095A 60 PUSH1 0x40 095C 51 MLOAD 095D 80 DUP1 095E 60 PUSH1 0x20 0960 01 ADD 0961 60 PUSH1 0x40 0963 52 MSTORE 0964 80 DUP1 0965 60 PUSH1 0x00 0967 81 DUP2 0968 52 MSTORE 0969 50 POP 096A 61 PUSH2 0x0e8a 096D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0954 stack[0] = 0x082a // @0957 stack[1] = stack[-3] // @0958 stack[2] = stack[-2] // @0959 stack[3] = stack[-1] // @095C stack[4] = memory[0x40:0x60] // @0963 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0968 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0e8a label_096E: // Incoming jump from 0x0374 // Inputs[2] // { // @0971 storage[0x08] // @097B msg.sender // } 096E 5B JUMPDEST 096F 60 PUSH1 0x08 0971 54 SLOAD 0972 60 PUSH1 0x01 0974 60 PUSH1 0x01 0976 60 PUSH1 0xa0 0978 1B SHL 0979 03 SUB 097A 16 AND 097B 33 CALLER 097C 14 EQ 097D 61 PUSH2 0x09c8 0980 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09c8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0981: // Incoming jump from 0x0980, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0983 memory[0x40:0x60] } 0981 60 PUSH1 0x40 0983 51 MLOAD 0984 62 PUSH3 0x461bcd 0988 60 PUSH1 0xe5 098A 1B SHL 098B 81 DUP2 098C 52 MSTORE 098D 60 PUSH1 0x20 098F 60 PUSH1 0x04 0991 82 DUP3 0992 01 ADD 0993 81 DUP2 0994 90 SWAP1 0995 52 MSTORE 0996 60 PUSH1 0x24 0998 82 DUP3 0999 01 ADD 099A 52 MSTORE 099B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 09BC 60 PUSH1 0x44 09BE 82 DUP3 09BF 01 ADD 09C0 52 MSTORE 09C1 60 PUSH1 0x64 09C3 01 ADD 09C4 61 PUSH2 0x0890 09C7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @098C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0995 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @099A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @09C0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @09C3 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_09C8: // Incoming jump from 0x0980, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09D1 storage[0x08] } 09C8 5B JUMPDEST 09C9 61 PUSH2 0x0950 09CC 61 PUSH2 0x09dd 09CF 60 PUSH1 0x08 09D1 54 SLOAD 09D2 60 PUSH1 0x01 09D4 60 PUSH1 0x01 09D6 60 PUSH1 0xa0 09D8 1B SHL 09D9 03 SUB 09DA 16 AND 09DB 90 SWAP1 09DC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09C9 stack[0] = 0x0950 // @09DB stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // } // Block ends with call to 0x09dd, returns to 0x0950 label_09DD: // Incoming call from 0x09DC, returns to 0x0950 // Inputs[1] { @09DE stack[-3] } 09DD 5B JUMPDEST 09DE 82 DUP3 09DF 61 PUSH2 0x14ed 09E2 56 *JUMP // Stack delta = +1 // Outputs[1] { @09DE stack[0] = stack[-3] } // Block ends with unconditional jump to 0x14ed label_09E3: // Incoming jump from 0x0394 // Inputs[2] // { // @09E6 storage[0x08] // @09F0 msg.sender // } 09E3 5B JUMPDEST 09E4 60 PUSH1 0x08 09E6 54 SLOAD 09E7 60 PUSH1 0x01 09E9 60 PUSH1 0x01 09EB 60 PUSH1 0xa0 09ED 1B SHL 09EE 03 SUB 09EF 16 AND 09F0 33 CALLER 09F1 14 EQ 09F2 61 PUSH2 0x0a3d 09F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a3d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_09F6: // Incoming jump from 0x09F5, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09F8 memory[0x40:0x60] } 09F6 60 PUSH1 0x40 09F8 51 MLOAD 09F9 62 PUSH3 0x461bcd 09FD 60 PUSH1 0xe5 09FF 1B SHL 0A00 81 DUP2 0A01 52 MSTORE 0A02 60 PUSH1 0x20 0A04 60 PUSH1 0x04 0A06 82 DUP3 0A07 01 ADD 0A08 81 DUP2 0A09 90 SWAP1 0A0A 52 MSTORE 0A0B 60 PUSH1 0x24 0A0D 82 DUP3 0A0E 01 ADD 0A0F 52 MSTORE 0A10 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0A31 60 PUSH1 0x44 0A33 82 DUP3 0A34 01 ADD 0A35 52 MSTORE 0A36 60 PUSH1 0x64 0A38 01 ADD 0A39 61 PUSH2 0x0890 0A3C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A01 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A0A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A0F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0A35 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0A38 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0A3D: // Incoming jump from 0x09F5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0A3E stack[-1] // @0A3F memory[stack[-1]:stack[-1] + 0x20] // } 0A3D 5B JUMPDEST 0A3E 80 DUP1 0A3F 51 MLOAD 0A40 61 PUSH2 0x0a50 0A43 90 SWAP1 0A44 60 PUSH1 0x09 0A46 90 SWAP1 0A47 60 PUSH1 0x20 0A49 84 DUP5 0A4A 01 ADD 0A4B 90 SWAP1 0A4C 61 PUSH2 0x1fac 0A4F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A43 stack[0] = 0x0a50 // @0A46 stack[1] = 0x09 // @0A4B stack[2] = stack[-1] + 0x20 // @0A4B stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1fac label_0A50: // Incoming return from call to 0x19FE at 0x1506 // Inputs[1] { @0A53 stack[-3] } 0A50 5B JUMPDEST 0A51 50 POP 0A52 50 POP 0A53 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0A54: // Incoming jump from 0x03B4 // Inputs[2] // { // @0A57 storage[0x08] // @0A61 msg.sender // } 0A54 5B JUMPDEST 0A55 60 PUSH1 0x08 0A57 54 SLOAD 0A58 60 PUSH1 0x01 0A5A 60 PUSH1 0x01 0A5C 60 PUSH1 0xa0 0A5E 1B SHL 0A5F 03 SUB 0A60 16 AND 0A61 33 CALLER 0A62 14 EQ 0A63 61 PUSH2 0x0aae 0A66 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aae, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0A67: // Incoming jump from 0x0A66, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0A69 memory[0x40:0x60] } 0A67 60 PUSH1 0x40 0A69 51 MLOAD 0A6A 62 PUSH3 0x461bcd 0A6E 60 PUSH1 0xe5 0A70 1B SHL 0A71 81 DUP2 0A72 52 MSTORE 0A73 60 PUSH1 0x20 0A75 60 PUSH1 0x04 0A77 82 DUP3 0A78 01 ADD 0A79 81 DUP2 0A7A 90 SWAP1 0A7B 52 MSTORE 0A7C 60 PUSH1 0x24 0A7E 82 DUP3 0A7F 01 ADD 0A80 52 MSTORE 0A81 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0AA2 60 PUSH1 0x44 0AA4 82 DUP3 0AA5 01 ADD 0AA6 52 MSTORE 0AA7 60 PUSH1 0x64 0AA9 01 ADD 0AAA 61 PUSH2 0x0890 0AAD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A72 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A7B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A80 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0AA6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0AA9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0AAE: // Incoming jump from 0x0A66, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0AB2 storage[0x0b] // @0AD2 stack[-1] // @0ADC stack[-2] // } 0AAE 5B JUMPDEST 0AAF 60 PUSH1 0x0b 0AB1 80 DUP1 0AB2 54 SLOAD 0AB3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AC8 19 NOT 0AC9 16 AND 0ACA 60 PUSH1 0x01 0ACC 60 PUSH1 0x01 0ACE 60 PUSH1 0xa0 0AD0 1B SHL 0AD1 03 SUB 0AD2 92 SWAP3 0AD3 90 SWAP1 0AD4 92 SWAP3 0AD5 16 AND 0AD6 91 SWAP2 0AD7 90 SWAP1 0AD8 91 SWAP2 0AD9 17 OR 0ADA 90 SWAP1 0ADB 55 SSTORE 0ADC 56 *JUMP // Stack delta = -2 // Outputs[1] { @0ADB storage[0x0b] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b]) } // Block ends with unconditional jump to stack[-2] label_0ADD: // Incoming jump from 0x03D4 // Inputs[2] // { // @0AE0 storage[0x08] // @0AEA msg.sender // } 0ADD 5B JUMPDEST 0ADE 60 PUSH1 0x08 0AE0 54 SLOAD 0AE1 60 PUSH1 0x01 0AE3 60 PUSH1 0x01 0AE5 60 PUSH1 0xa0 0AE7 1B SHL 0AE8 03 SUB 0AE9 16 AND 0AEA 33 CALLER 0AEB 14 EQ 0AEC 61 PUSH2 0x0b37 0AEF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b37, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0AF0: // Incoming jump from 0x0AEF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0AF2 memory[0x40:0x60] } 0AF0 60 PUSH1 0x40 0AF2 51 MLOAD 0AF3 62 PUSH3 0x461bcd 0AF7 60 PUSH1 0xe5 0AF9 1B SHL 0AFA 81 DUP2 0AFB 52 MSTORE 0AFC 60 PUSH1 0x20 0AFE 60 PUSH1 0x04 0B00 82 DUP3 0B01 01 ADD 0B02 81 DUP2 0B03 90 SWAP1 0B04 52 MSTORE 0B05 60 PUSH1 0x24 0B07 82 DUP3 0B08 01 ADD 0B09 52 MSTORE 0B0A 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0B2B 60 PUSH1 0x44 0B2D 82 DUP3 0B2E 01 ADD 0B2F 52 MSTORE 0B30 60 PUSH1 0x64 0B32 01 ADD 0B33 61 PUSH2 0x0890 0B36 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0AFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B04 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B09 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0B2F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0B32 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0B37: // Incoming jump from 0x0AEF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0B38 stack[-3] } 0B37 5B JUMPDEST 0B38 82 DUP3 0B39 60 PUSH1 0x00 0B3B 5B JUMPDEST 0B3C 81 DUP2 0B3D 81 DUP2 0B3E 10 LT 0B3F 15 ISZERO 0B40 61 PUSH2 0x0ba5 0B43 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B38 stack[0] = stack[-3] // @0B39 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0ba5, if !(0x00 < stack[-3]) label_0B44: // Incoming jump from 0x0B43, if not !(0x00 < stack[-3]) // Inputs[1] { @0B4C storage[0x08] } 0B44 61 PUSH2 0x0b9d 0B47 61 PUSH2 0x0b58 0B4A 60 PUSH1 0x08 0B4C 54 SLOAD 0B4D 60 PUSH1 0x01 0B4F 60 PUSH1 0x01 0B51 60 PUSH1 0xa0 0B53 1B SHL 0B54 03 SUB 0B55 16 AND 0B56 90 SWAP1 0B57 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B44 stack[0] = 0x0b9d // @0B56 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // } // Block ends with unconditional jump to 0x0b58 label_0B58: // Incoming jump from 0x0B57 // Inputs[3] // { // @0B59 stack[-8] // @0B5A stack[-7] // @0B5B stack[-3] // } 0B58 5B JUMPDEST 0B59 87 DUP8 0B5A 87 DUP8 0B5B 84 DUP5 0B5C 81 DUP2 0B5D 81 DUP2 0B5E 10 LT 0B5F 61 PUSH2 0x0b6a 0B62 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0B59 stack[0] = stack[-8] // @0B5A stack[1] = stack[-7] // @0B5B stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0b6a, if stack[-3] < stack[-7] label_0B63: // Incoming jump from 0x0B62, if not stack[-3] < stack[-7] 0B63 61 PUSH2 0x0b6a 0B66 61 PUSH2 0x24ee 0B69 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B63 stack[0] = 0x0b6a } // Block ends with unconditional jump to 0x24ee label_0B6A: // Incoming jump from 0x0B62, if stack[-3] < stack[-7] // Inputs[3] // { // @0B6B stack[-2] // @0B6B stack[-1] // @0B70 stack[-3] // } 0B6A 5B JUMPDEST 0B6B 90 SWAP1 0B6C 50 POP 0B6D 60 PUSH1 0x20 0B6F 02 MUL 0B70 01 ADD 0B71 60 PUSH1 0x20 0B73 81 DUP2 0B74 01 ADD 0B75 90 SWAP1 0B76 61 PUSH2 0x0b7f 0B79 91 SWAP2 0B7A 90 SWAP1 0B7B 61 PUSH2 0x2253 0B7E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B79 stack[-3] = 0x0b7f // @0B7A stack[-1] = 0x20 * stack[-1] + stack[-3] // @0B7A stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x2253, returns to 0x0B7F label_0B7F: // Incoming return from call to 0x2253 at 0x0B7E // Inputs[3] // { // @0B80 stack[-7] // @0B81 stack[-6] // @0B82 stack[-4] // } 0B7F 5B JUMPDEST 0B80 86 DUP7 0B81 86 DUP7 0B82 85 DUP6 0B83 81 DUP2 0B84 81 DUP2 0B85 10 LT 0B86 61 PUSH2 0x0b91 0B89 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0B80 stack[0] = stack[-7] // @0B81 stack[1] = stack[-6] // @0B82 stack[2] = stack[-4] // } // Block ends with conditional jump to 0x0b91, if stack[-4] < stack[-6] label_0B8A: // Incoming jump from 0x0B89, if not stack[-4] < stack[-6] 0B8A 61 PUSH2 0x0b91 0B8D 61 PUSH2 0x24ee 0B90 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B8A stack[0] = 0x0b91 } // Block ends with unconditional jump to 0x24ee label_0B91: // Incoming jump from 0x0B89, if stack[-4] < stack[-6] // Inputs[4] // { // @0B92 stack[-2] // @0B92 stack[-1] // @0B97 stack[-3] // @0B98 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 0B91 5B JUMPDEST 0B92 90 SWAP1 0B93 50 POP 0B94 60 PUSH1 0x20 0B96 02 MUL 0B97 01 ADD 0B98 35 CALLDATALOAD 0B99 61 PUSH2 0x082f 0B9C 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B98 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x082f 0B9D 5B JUMPDEST 0B9E 60 PUSH1 0x01 0BA0 01 ADD 0BA1 61 PUSH2 0x0b3b 0BA4 56 *JUMP label_0BA5: // Incoming jump from 0x0E3A, if !(0x00 < stack[-3]) // Incoming jump from 0x19CC, if storage[0x0a] & (0x01 << 0xa0) - 0x01 == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x0B43, if !(0x00 < stack[-3]) // Incoming jump from 0x0E3A, if !(stack[-1] < stack[-2]) // Inputs[1] { @0BAC stack[-7] } 0BA5 5B JUMPDEST 0BA6 50 POP 0BA7 50 POP 0BA8 50 POP 0BA9 50 POP 0BAA 50 POP 0BAB 50 POP 0BAC 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0BAD: // Incoming jump from 0x03F4 // Incoming call from 0x0779, returns to 0x077A // Inputs[1] { @0BB3 stack[-1] } 0BAD 5B JUMPDEST 0BAE 60 PUSH1 0x00 0BB0 61 PUSH2 0x0bb8 0BB3 82 DUP3 0BB4 61 PUSH2 0x1507 0BB7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BAE stack[0] = 0x00 // @0BB0 stack[1] = 0x0bb8 // @0BB3 stack[2] = stack[-1] // } // Block ends with call to 0x1507, returns to 0x0BB8 label_0BB8: // Incoming return from call to 0x1507 at 0x0BB7 // Inputs[4] // { // @0BB9 stack[-1] // @0BB9 memory[stack[-1]:stack[-1] + 0x20] // @0BBA stack[-4] // @0BBB stack[-3] // } 0BB8 5B JUMPDEST 0BB9 51 MLOAD 0BBA 92 SWAP3 0BBB 91 SWAP2 0BBC 50 POP 0BBD 50 POP 0BBE 56 *JUMP // Stack delta = -3 // Outputs[1] { @0BBA stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0BBF: // Incoming jump from 0x0414 // Inputs[2] // { // @0BC2 storage[0x08] // @0BCC msg.sender // } 0BBF 5B JUMPDEST 0BC0 60 PUSH1 0x08 0BC2 54 SLOAD 0BC3 60 PUSH1 0x01 0BC5 60 PUSH1 0x01 0BC7 60 PUSH1 0xa0 0BC9 1B SHL 0BCA 03 SUB 0BCB 16 AND 0BCC 33 CALLER 0BCD 14 EQ 0BCE 61 PUSH2 0x0c19 0BD1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c19, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0BD2: // Incoming jump from 0x0BD1, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0BD4 memory[0x40:0x60] } 0BD2 60 PUSH1 0x40 0BD4 51 MLOAD 0BD5 62 PUSH3 0x461bcd 0BD9 60 PUSH1 0xe5 0BDB 1B SHL 0BDC 81 DUP2 0BDD 52 MSTORE 0BDE 60 PUSH1 0x20 0BE0 60 PUSH1 0x04 0BE2 82 DUP3 0BE3 01 ADD 0BE4 81 DUP2 0BE5 90 SWAP1 0BE6 52 MSTORE 0BE7 60 PUSH1 0x24 0BE9 82 DUP3 0BEA 01 ADD 0BEB 52 MSTORE 0BEC 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0C0D 60 PUSH1 0x44 0C0F 82 DUP3 0C10 01 ADD 0C11 52 MSTORE 0C12 60 PUSH1 0x64 0C14 01 ADD 0C15 61 PUSH2 0x0890 0C18 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BE6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BEB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0C11 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0C14 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0C19: // Incoming jump from 0x0BD1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0C1D storage[0x0a] // @0C3D stack[-1] // @0C47 stack[-2] // } 0C19 5B JUMPDEST 0C1A 60 PUSH1 0x0a 0C1C 80 DUP1 0C1D 54 SLOAD 0C1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C33 19 NOT 0C34 16 AND 0C35 60 PUSH1 0x01 0C37 60 PUSH1 0x01 0C39 60 PUSH1 0xa0 0C3B 1B SHL 0C3C 03 SUB 0C3D 92 SWAP3 0C3E 90 SWAP1 0C3F 92 SWAP3 0C40 16 AND 0C41 91 SWAP2 0C42 90 SWAP1 0C43 91 SWAP2 0C44 17 OR 0C45 90 SWAP1 0C46 55 SSTORE 0C47 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C46 storage[0x0a] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a]) } // Block ends with unconditional jump to stack[-2] label_0C48: // Incoming jump from 0x0434 // Inputs[1] { @0C53 stack[-1] } 0C48 5B JUMPDEST 0C49 60 PUSH1 0x00 0C4B 60 PUSH1 0x01 0C4D 60 PUSH1 0x01 0C4F 60 PUSH1 0xa0 0C51 1B SHL 0C52 03 SUB 0C53 82 DUP3 0C54 16 AND 0C55 61 PUSH2 0x0c8a 0C58 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C49 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c8a, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0C59: // Incoming jump from 0x0C58, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0C5B memory[0x40:0x60] // @0C84 memory[0x40:0x60] // @0C89 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C59 60 PUSH1 0x40 0C5B 51 MLOAD 0C5C 7F PUSH32 0x8f4eb60400000000000000000000000000000000000000000000000000000000 0C7D 81 DUP2 0C7E 52 MSTORE 0C7F 60 PUSH1 0x04 0C81 01 ADD 0C82 60 PUSH1 0x40 0C84 51 MLOAD 0C85 80 DUP1 0C86 91 SWAP2 0C87 03 SUB 0C88 90 SWAP1 0C89 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C7E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000 // @0C89 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C8A: // Incoming jump from 0x0C58, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0C94 stack[-2] // @0CA2 memory[0x00:0x40] // @0CA3 storage[keccak256(memory[0x00:0x40])] // @0CAE stack[-3] // } 0C8A 5B JUMPDEST 0C8B 50 POP 0C8C 60 PUSH1 0x01 0C8E 60 PUSH1 0x01 0C90 60 PUSH1 0xa0 0C92 1B SHL 0C93 03 SUB 0C94 16 AND 0C95 60 PUSH1 0x00 0C97 90 SWAP1 0C98 81 DUP2 0C99 52 MSTORE 0C9A 60 PUSH1 0x05 0C9C 60 PUSH1 0x20 0C9E 52 MSTORE 0C9F 60 PUSH1 0x40 0CA1 90 SWAP1 0CA2 20 SHA3 0CA3 54 SLOAD 0CA4 67 PUSH8 0xffffffffffffffff 0CAD 16 AND 0CAE 90 SWAP1 0CAF 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0C99 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0C9E memory[0x20:0x40] = 0x05 // @0CAE stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0CB0: // Incoming call from 0x0449, returns to 0x0297 // Inputs[2] // { // @0CB3 storage[0x08] // @0CBD msg.sender // } 0CB0 5B JUMPDEST 0CB1 60 PUSH1 0x08 0CB3 54 SLOAD 0CB4 60 PUSH1 0x01 0CB6 60 PUSH1 0x01 0CB8 60 PUSH1 0xa0 0CBA 1B SHL 0CBB 03 SUB 0CBC 16 AND 0CBD 33 CALLER 0CBE 14 EQ 0CBF 61 PUSH2 0x0d0a 0CC2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d0a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0CC3: // Incoming jump from 0x0CC2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0CC5 memory[0x40:0x60] } 0CC3 60 PUSH1 0x40 0CC5 51 MLOAD 0CC6 62 PUSH3 0x461bcd 0CCA 60 PUSH1 0xe5 0CCC 1B SHL 0CCD 81 DUP2 0CCE 52 MSTORE 0CCF 60 PUSH1 0x20 0CD1 60 PUSH1 0x04 0CD3 82 DUP3 0CD4 01 ADD 0CD5 81 DUP2 0CD6 90 SWAP1 0CD7 52 MSTORE 0CD8 60 PUSH1 0x24 0CDA 82 DUP3 0CDB 01 ADD 0CDC 52 MSTORE 0CDD 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0CFE 60 PUSH1 0x44 0D00 82 DUP3 0D01 01 ADD 0D02 52 MSTORE 0D03 60 PUSH1 0x64 0D05 01 ADD 0D06 61 PUSH2 0x0890 0D09 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0CCE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CD7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CDC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0D02 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0D05 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0D0A: // Incoming jump from 0x0CC2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0D0A 5B JUMPDEST 0D0B 61 PUSH2 0x0d14 0D0E 60 PUSH1 0x00 0D10 61 PUSH2 0x163c 0D13 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D0B stack[0] = 0x0d14 // @0D0E stack[1] = 0x00 // } // Block ends with call to 0x163c, returns to 0x0D14 label_0D14: // Incoming return from call to 0x163C at 0x0D13 // Inputs[1] { @0D15 stack[-1] } 0D14 5B JUMPDEST 0D15 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0D16: // Incoming call from 0x047C, returns to 0x0232 // Inputs[1] { @0D1C storage[0x03] } 0D16 5B JUMPDEST 0D17 60 PUSH1 0x60 0D19 60 PUSH1 0x03 0D1B 80 DUP1 0D1C 54 SLOAD 0D1D 61 PUSH2 0x068f 0D20 90 SWAP1 0D21 61 PUSH2 0x24b3 0D24 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D17 stack[0] = 0x60 // @0D19 stack[1] = 0x03 // @0D20 stack[2] = 0x068f // @0D20 stack[3] = storage[0x03] // } // Block ends with call to 0x24b3, returns to 0x068F label_0D25: // Incoming jump from 0x049C // Inputs[2] // { // @0D2E stack[-2] // @0D30 msg.sender // } 0D25 5B JUMPDEST 0D26 60 PUSH1 0x01 0D28 60 PUSH1 0x01 0D2A 60 PUSH1 0xa0 0D2C 1B SHL 0D2D 03 SUB 0D2E 82 DUP3 0D2F 16 AND 0D30 33 CALLER 0D31 14 EQ 0D32 15 ISZERO 0D33 61 PUSH2 0x0d68 0D36 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d68, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_0D37: // Incoming jump from 0x0D36, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @0D39 memory[0x40:0x60] // @0D62 memory[0x40:0x60] // @0D67 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D37 60 PUSH1 0x40 0D39 51 MLOAD 0D3A 7F PUSH32 0xb06307db00000000000000000000000000000000000000000000000000000000 0D5B 81 DUP2 0D5C 52 MSTORE 0D5D 60 PUSH1 0x04 0D5F 01 ADD 0D60 60 PUSH1 0x40 0D62 51 MLOAD 0D63 80 DUP1 0D64 91 SWAP2 0D65 03 SUB 0D66 90 SWAP1 0D67 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db00000000000000000000000000000000000000000000000000000000 // @0D67 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D68: // Incoming jump from 0x0D36, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @0D69 msg.sender // @0D7A memory[0x00:0x40] // @0D83 stack[-2] // @0D8E memory[0x00:0x40] // @0D90 storage[keccak256(memory[0x00:0x40])] // @0D95 stack[-1] // @0D9F memory[0x40:0x60] // @0DCB memory[0x40:0x60] // @0DD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0DD3 stack[-3] // } 0D68 5B JUMPDEST 0D69 33 CALLER 0D6A 60 PUSH1 0x00 0D6C 81 DUP2 0D6D 81 DUP2 0D6E 52 MSTORE 0D6F 60 PUSH1 0x07 0D71 60 PUSH1 0x20 0D73 90 SWAP1 0D74 81 DUP2 0D75 52 MSTORE 0D76 60 PUSH1 0x40 0D78 80 DUP1 0D79 83 DUP4 0D7A 20 SHA3 0D7B 60 PUSH1 0x01 0D7D 60 PUSH1 0x01 0D7F 60 PUSH1 0xa0 0D81 1B SHL 0D82 03 SUB 0D83 87 DUP8 0D84 16 AND 0D85 80 DUP1 0D86 85 DUP6 0D87 52 MSTORE 0D88 90 SWAP1 0D89 83 DUP4 0D8A 52 MSTORE 0D8B 92 SWAP3 0D8C 81 DUP2 0D8D 90 SWAP1 0D8E 20 SHA3 0D8F 80 DUP1 0D90 54 SLOAD 0D91 60 PUSH1 0xff 0D93 19 NOT 0D94 16 AND 0D95 86 DUP7 0D96 15 ISZERO 0D97 15 ISZERO 0D98 90 SWAP1 0D99 81 DUP2 0D9A 17 OR 0D9B 90 SWAP1 0D9C 91 SWAP2 0D9D 55 SSTORE 0D9E 90 SWAP1 0D9F 51 MLOAD 0DA0 90 SWAP1 0DA1 81 DUP2 0DA2 52 MSTORE 0DA3 91 SWAP2 0DA4 92 SWAP3 0DA5 91 SWAP2 0DA6 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0DC7 91 SWAP2 0DC8 01 ADD 0DC9 60 PUSH1 0x40 0DCB 51 MLOAD 0DCC 80 DUP1 0DCD 91 SWAP2 0DCE 03 SUB 0DCF 90 SWAP1 0DD0 A3 LOG3 0DD1 50 POP 0DD2 50 POP 0DD3 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0D6E memory[0x00:0x20] = msg.sender // @0D75 memory[0x20:0x40] = 0x07 // @0D87 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0D8A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D9D storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0DA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0DD0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_0DD4: // Incoming jump from 0x04D1 // Inputs[2] // { // @0DD7 storage[0x08] // @0DE1 msg.sender // } 0DD4 5B JUMPDEST 0DD5 60 PUSH1 0x08 0DD7 54 SLOAD 0DD8 60 PUSH1 0x01 0DDA 60 PUSH1 0x01 0DDC 60 PUSH1 0xa0 0DDE 1B SHL 0DDF 03 SUB 0DE0 16 AND 0DE1 33 CALLER 0DE2 14 EQ 0DE3 61 PUSH2 0x0e2e 0DE6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e2e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0DE7: // Incoming jump from 0x0DE6, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0DE9 memory[0x40:0x60] } 0DE7 60 PUSH1 0x40 0DE9 51 MLOAD 0DEA 62 PUSH3 0x461bcd 0DEE 60 PUSH1 0xe5 0DF0 1B SHL 0DF1 81 DUP2 0DF2 52 MSTORE 0DF3 60 PUSH1 0x20 0DF5 60 PUSH1 0x04 0DF7 82 DUP3 0DF8 01 ADD 0DF9 81 DUP2 0DFA 90 SWAP1 0DFB 52 MSTORE 0DFC 60 PUSH1 0x24 0DFE 82 DUP3 0DFF 01 ADD 0E00 52 MSTORE 0E01 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0E22 60 PUSH1 0x44 0E24 82 DUP3 0E25 01 ADD 0E26 52 MSTORE 0E27 60 PUSH1 0x64 0E29 01 ADD 0E2A 61 PUSH2 0x0890 0E2D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0DF2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DFB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E00 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E26 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0E29 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0E2E: // Incoming jump from 0x0DE6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0E2F stack[-3] } 0E2E 5B JUMPDEST 0E2F 82 DUP3 0E30 60 PUSH1 0x00 0E32 5B JUMPDEST 0E33 81 DUP2 0E34 81 DUP2 0E35 10 LT 0E36 15 ISZERO 0E37 61 PUSH2 0x0ba5 0E3A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E2F stack[0] = stack[-3] // @0E30 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0ba5, if !(0x00 < stack[-3]) label_0E3B: // Incoming jump from 0x0E3A, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x0E3A, if not !(0x00 < stack[-3]) // Inputs[3] // { // @0E3E stack[-6] // @0E3F stack[-5] // @0E40 stack[-1] // } 0E3B 61 PUSH2 0x0e82 0E3E 86 DUP7 0E3F 86 DUP7 0E40 83 DUP4 0E41 81 DUP2 0E42 81 DUP2 0E43 10 LT 0E44 61 PUSH2 0x0e4f 0E47 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0E3B stack[0] = 0x0e82 // @0E3E stack[1] = stack[-6] // @0E3F stack[2] = stack[-5] // @0E40 stack[3] = stack[-1] // } // Block ends with conditional call to 0x0e4f, returns to 0x0E82, if stack[-1] < stack[-5] label_0E48: // Incoming jump from 0x0E47, if not stack[-1] < stack[-5] 0E48 61 PUSH2 0x0e4f 0E4B 61 PUSH2 0x24ee 0E4E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E48 stack[0] = 0x0e4f } // Block ends with unconditional jump to 0x24ee label_0E4F: // Incoming call from 0x0E47, returns to 0x0E82, if stack[-1] < stack[-5] // Inputs[3] // { // @0E50 stack[-2] // @0E50 stack[-1] // @0E55 stack[-3] // } 0E4F 5B JUMPDEST 0E50 90 SWAP1 0E51 50 POP 0E52 60 PUSH1 0x20 0E54 02 MUL 0E55 01 ADD 0E56 60 PUSH1 0x20 0E58 81 DUP2 0E59 01 ADD 0E5A 90 SWAP1 0E5B 61 PUSH2 0x0e64 0E5E 91 SWAP2 0E5F 90 SWAP1 0E60 61 PUSH2 0x2253 0E63 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E5E stack[-3] = 0x0e64 // @0E5F stack[-1] = 0x20 * stack[-1] + stack[-3] // @0E5F stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x2253, returns to 0x0E64 label_0E64: // Incoming return from call to 0x2253 at 0x0E63 // Inputs[3] // { // @0E65 stack[-6] // @0E66 stack[-5] // @0E67 stack[-3] // } 0E64 5B JUMPDEST 0E65 85 DUP6 0E66 85 DUP6 0E67 84 DUP5 0E68 81 DUP2 0E69 81 DUP2 0E6A 10 LT 0E6B 61 PUSH2 0x0e76 0E6E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E65 stack[0] = stack[-6] // @0E66 stack[1] = stack[-5] // @0E67 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0e76, if stack[-3] < stack[-5] label_0E6F: // Incoming jump from 0x0E6E, if not stack[-3] < stack[-5] 0E6F 61 PUSH2 0x0e76 0E72 61 PUSH2 0x24ee 0E75 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E6F stack[0] = 0x0e76 } // Block ends with unconditional jump to 0x24ee label_0E76: // Incoming jump from 0x0E6E, if stack[-3] < stack[-5] // Inputs[4] // { // @0E77 stack[-1] // @0E77 stack[-2] // @0E7C stack[-3] // @0E7D msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 0E76 5B JUMPDEST 0E77 90 SWAP1 0E78 50 POP 0E79 60 PUSH1 0x20 0E7B 02 MUL 0E7C 01 ADD 0E7D 35 CALLDATALOAD 0E7E 61 PUSH2 0x14ed 0E81 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E7D stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x14ed label_0E82: // Incoming return from call to 0x0E4F at 0x0E47 // Inputs[1] { @0E85 stack[-1] } 0E82 5B JUMPDEST 0E83 60 PUSH1 0x01 0E85 01 ADD 0E86 61 PUSH2 0x0e32 0E89 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E85 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x0e32 label_0E8A: // Incoming jump from 0x0506 // Incoming jump from 0x096D // Inputs[3] // { // @0E8E stack[-4] // @0E8F stack[-3] // @0E90 stack[-2] // } 0E8A 5B JUMPDEST 0E8B 61 PUSH2 0x0e95 0E8E 84 DUP5 0E8F 84 DUP5 0E90 84 DUP5 0E91 61 PUSH2 0x12b1 0E94 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E8B stack[0] = 0x0e95 // @0E8E stack[1] = stack[-4] // @0E8F stack[2] = stack[-3] // @0E90 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x12b1 0E95 5B JUMPDEST 0E96 60 PUSH1 0x01 0E98 60 PUSH1 0x01 0E9A 60 PUSH1 0xa0 0E9C 1B SHL 0E9D 03 SUB 0E9E 83 DUP4 0E9F 16 AND 0EA0 3B EXTCODESIZE 0EA1 15 ISZERO 0EA2 15 ISZERO 0EA3 80 DUP1 0EA4 15 ISZERO 0EA5 61 PUSH2 0x0eb7 0EA8 57 *JUMPI 0EA9 50 POP 0EAA 61 PUSH2 0x0eb5 0EAD 84 DUP5 0EAE 84 DUP5 0EAF 84 DUP5 0EB0 84 DUP5 0EB1 61 PUSH2 0x169b 0EB4 56 *JUMP 0EB5 5B JUMPDEST 0EB6 15 ISZERO 0EB7 5B JUMPDEST 0EB8 15 ISZERO 0EB9 61 PUSH2 0x0ed5 0EBC 57 *JUMPI 0EBD 60 PUSH1 0x40 0EBF 51 MLOAD 0EC0 63 PUSH4 0x68d2bf6b 0EC5 60 PUSH1 0xe1 0EC7 1B SHL 0EC8 81 DUP2 0EC9 52 MSTORE 0ECA 60 PUSH1 0x04 0ECC 01 ADD 0ECD 60 PUSH1 0x40 0ECF 51 MLOAD 0ED0 80 DUP1 0ED1 91 SWAP2 0ED2 03 SUB 0ED3 90 SWAP1 0ED4 FD *REVERT label_0ED5: // Incoming jump from 0x209B, if !(stack[-1] > stack[-4]) // Inputs[1] { @0EDA stack[-5] } 0ED5 5B JUMPDEST 0ED6 50 POP 0ED7 50 POP 0ED8 50 POP 0ED9 50 POP 0EDA 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0EDB: // Incoming jump from 0x0526 // Inputs[1] { @0EE3 stack[-1] } 0EDB 5B JUMPDEST 0EDC 60 PUSH1 0x60 0EDE 60 PUSH1 0x09 0EE0 61 PUSH2 0x0ee8 0EE3 83 DUP4 0EE4 61 PUSH2 0x1793 0EE7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EDC stack[0] = 0x60 // @0EDE stack[1] = 0x09 // @0EE0 stack[2] = 0x0ee8 // @0EE3 stack[3] = stack[-1] // } // Block ends with call to 0x1793, returns to 0x0EE8 label_0EE8: // Incoming return from call to 0x1793 at 0x0EE7 // Inputs[3] // { // @0EEB memory[0x40:0x60] // @0EF2 stack[-2] // @0EF3 stack[-1] // } 0EE8 5B JUMPDEST 0EE9 60 PUSH1 0x40 0EEB 51 MLOAD 0EEC 60 PUSH1 0x20 0EEE 01 ADD 0EEF 61 PUSH2 0x0ef9 0EF2 92 SWAP3 0EF3 91 SWAP2 0EF4 90 SWAP1 0EF5 61 PUSH2 0x2520 0EF8 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0EF2 stack[-2] = 0x0ef9 // @0EF3 stack[-1] = stack[-2] // @0EF4 stack[1] = 0x20 + memory[0x40:0x60] // @0EF4 stack[0] = stack[-1] // } // Block ends with call to 0x2520, returns to 0x0EF9 label_0EF9: // Incoming return from call to 0x2520 at 0x0EF8 // Inputs[5] // { // @0EFC memory[0x40:0x60] // @0F00 stack[-1] // @0F09 stack[-2] // @0F0B stack[-4] // @0F0C stack[-3] // } 0EF9 5B JUMPDEST 0EFA 60 PUSH1 0x40 0EFC 51 MLOAD 0EFD 60 PUSH1 0x20 0EFF 81 DUP2 0F00 83 DUP4 0F01 03 SUB 0F02 03 SUB 0F03 81 DUP2 0F04 52 MSTORE 0F05 90 SWAP1 0F06 60 PUSH1 0x40 0F08 52 MSTORE 0F09 90 SWAP1 0F0A 50 POP 0F0B 91 SWAP2 0F0C 90 SWAP1 0F0D 50 POP 0F0E 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0F04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0F08 memory[0x40:0x60] = stack[-1] // @0F0B stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_0F0F: // Incoming jump from 0x0546 // Inputs[3] // { // @0F18 stack[-1] // @0F27 memory[0x00:0x40] // @0F28 storage[keccak256(memory[0x00:0x40])] // } 0F0F 5B JUMPDEST 0F10 60 PUSH1 0x01 0F12 60 PUSH1 0x01 0F14 60 PUSH1 0xa0 0F16 1B SHL 0F17 03 SUB 0F18 81 DUP2 0F19 16 AND 0F1A 60 PUSH1 0x00 0F1C 90 SWAP1 0F1D 81 DUP2 0F1E 52 MSTORE 0F1F 60 PUSH1 0x05 0F21 60 PUSH1 0x20 0F23 52 MSTORE 0F24 60 PUSH1 0x40 0F26 81 DUP2 0F27 20 SHA3 0F28 54 SLOAD 0F29 68 PUSH9 0x010000000000000000 0F33 90 SWAP1 0F34 04 DIV 0F35 67 PUSH8 0xffffffffffffffff 0F3E 16 AND 0F3F 61 PUSH2 0x067a 0F42 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0F1C stack[0] = 0x00 // @0F1E memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0F23 memory[0x20:0x40] = 0x05 // @0F3E stack[1] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x010000000000000000 // } // Block ends with unconditional jump to 0x067a label_0F43: // Incoming jump from 0x05AF // Inputs[2] // { // @0F46 storage[0x08] // @0F50 msg.sender // } 0F43 5B JUMPDEST 0F44 60 PUSH1 0x08 0F46 54 SLOAD 0F47 60 PUSH1 0x01 0F49 60 PUSH1 0x01 0F4B 60 PUSH1 0xa0 0F4D 1B SHL 0F4E 03 SUB 0F4F 16 AND 0F50 33 CALLER 0F51 14 EQ 0F52 61 PUSH2 0x0f9d 0F55 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f9d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0F56: // Incoming jump from 0x0F55, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0F58 memory[0x40:0x60] } 0F56 60 PUSH1 0x40 0F58 51 MLOAD 0F59 62 PUSH3 0x461bcd 0F5D 60 PUSH1 0xe5 0F5F 1B SHL 0F60 81 DUP2 0F61 52 MSTORE 0F62 60 PUSH1 0x20 0F64 60 PUSH1 0x04 0F66 82 DUP3 0F67 01 ADD 0F68 81 DUP2 0F69 90 SWAP1 0F6A 52 MSTORE 0F6B 60 PUSH1 0x24 0F6D 82 DUP3 0F6E 01 ADD 0F6F 52 MSTORE 0F70 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0F91 60 PUSH1 0x44 0F93 82 DUP3 0F94 01 ADD 0F95 52 MSTORE 0F96 60 PUSH1 0x64 0F98 01 ADD 0F99 61 PUSH2 0x0890 0F9C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F6A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F6F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0F95 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0F98 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_0F9D: // Incoming jump from 0x0F55, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0FA6 stack[-1] } 0F9D 5B JUMPDEST 0F9E 60 PUSH1 0x01 0FA0 60 PUSH1 0x01 0FA2 60 PUSH1 0xa0 0FA4 1B SHL 0FA5 03 SUB 0FA6 81 DUP2 0FA7 16 AND 0FA8 61 PUSH2 0x1019 0FAB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1019, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0FAC: // Incoming jump from 0x0FAB, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0FAE memory[0x40:0x60] } 0FAC 60 PUSH1 0x40 0FAE 51 MLOAD 0FAF 62 PUSH3 0x461bcd 0FB3 60 PUSH1 0xe5 0FB5 1B SHL 0FB6 81 DUP2 0FB7 52 MSTORE 0FB8 60 PUSH1 0x20 0FBA 60 PUSH1 0x04 0FBC 82 DUP3 0FBD 01 ADD 0FBE 52 MSTORE 0FBF 60 PUSH1 0x26 0FC1 60 PUSH1 0x24 0FC3 82 DUP3 0FC4 01 ADD 0FC5 52 MSTORE 0FC6 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0FE7 60 PUSH1 0x44 0FE9 82 DUP3 0FEA 01 ADD 0FEB 52 MSTORE 0FEC 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 100D 60 PUSH1 0x64 100F 82 DUP3 1010 01 ADD 1011 52 MSTORE 1012 60 PUSH1 0x84 1014 01 ADD 1015 61 PUSH2 0x0890 1018 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0FB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FBE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FC5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0FEB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1011 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1014 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_1019: // Incoming jump from 0x0FAB, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @101D stack[-1] } 1019 5B JUMPDEST 101A 61 PUSH2 0x0950 101D 81 DUP2 101E 61 PUSH2 0x163c 1021 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @101A stack[0] = 0x0950 // @101D stack[1] = stack[-1] // } // Block ends with call to 0x163c, returns to 0x0950 label_1022: // Incoming jump from 0x05CF // Inputs[2] // { // @1025 storage[0x08] // @102F msg.sender // } 1022 5B JUMPDEST 1023 60 PUSH1 0x08 1025 54 SLOAD 1026 60 PUSH1 0x01 1028 60 PUSH1 0x01 102A 60 PUSH1 0xa0 102C 1B SHL 102D 03 SUB 102E 16 AND 102F 33 CALLER 1030 14 EQ 1031 61 PUSH2 0x107c 1034 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x107c, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1035: // Incoming jump from 0x1034, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1037 memory[0x40:0x60] } 1035 60 PUSH1 0x40 1037 51 MLOAD 1038 62 PUSH3 0x461bcd 103C 60 PUSH1 0xe5 103E 1B SHL 103F 81 DUP2 1040 52 MSTORE 1041 60 PUSH1 0x20 1043 60 PUSH1 0x04 1045 82 DUP3 1046 01 ADD 1047 81 DUP2 1048 90 SWAP1 1049 52 MSTORE 104A 60 PUSH1 0x24 104C 82 DUP3 104D 01 ADD 104E 52 MSTORE 104F 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1070 60 PUSH1 0x44 1072 82 DUP3 1073 01 ADD 1074 52 MSTORE 1075 60 PUSH1 0x64 1077 01 ADD 1078 61 PUSH2 0x0890 107B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1040 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1049 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @104E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1074 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1077 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_107C: // Incoming jump from 0x1034, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @1080 storage[0x08] // @1081 stack[-1] // @10B4 stack[-2] // } 107C 5B JUMPDEST 107D 60 PUSH1 0x08 107F 80 DUP1 1080 54 SLOAD 1081 91 SWAP2 1082 15 ISZERO 1083 15 ISZERO 1084 60 PUSH1 0x01 1086 60 PUSH1 0xa0 1088 1B SHL 1089 02 MUL 108A 7F PUSH32 0xffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff 10AB 90 SWAP1 10AC 92 SWAP3 10AD 16 AND 10AE 91 SWAP2 10AF 90 SWAP1 10B0 91 SWAP2 10B1 17 OR 10B2 90 SWAP1 10B3 55 SSTORE 10B4 56 *JUMP // Stack delta = -2 // Outputs[1] { @10B3 storage[0x08] = (storage[0x08] & 0xffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff) | (0x01 << 0xa0) * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_10B5: // Incoming jump from 0x05E2 // Inputs[1] { @10B8 storage[0x08] } 10B5 5B JUMPDEST 10B6 60 PUSH1 0x08 10B8 54 SLOAD 10B9 60 PUSH1 0x01 10BB 60 PUSH1 0xa0 10BD 1B SHL 10BE 90 SWAP1 10BF 04 DIV 10C0 60 PUSH1 0xff 10C2 16 AND 10C3 61 PUSH2 0x10f8 10C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10f8, if 0xff & storage[0x08] / (0x01 << 0xa0) label_10C7: // Incoming jump from 0x10C6, if not 0xff & storage[0x08] / (0x01 << 0xa0) // Inputs[3] // { // @10C9 memory[0x40:0x60] // @10F2 memory[0x40:0x60] // @10F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10C7 60 PUSH1 0x40 10C9 51 MLOAD 10CA 7F PUSH32 0x447691f700000000000000000000000000000000000000000000000000000000 10EB 81 DUP2 10EC 52 MSTORE 10ED 60 PUSH1 0x04 10EF 01 ADD 10F0 60 PUSH1 0x40 10F2 51 MLOAD 10F3 80 DUP1 10F4 91 SWAP2 10F5 03 SUB 10F6 90 SWAP1 10F7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x447691f700000000000000000000000000000000000000000000000000000000 // @10F7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_10F8: // Incoming jump from 0x10C6, if 0xff & storage[0x08] / (0x01 << 0xa0) // Inputs[4] // { // @10F9 msg.sender // @1107 memory[0x00:0x40] // @1108 storage[keccak256(memory[0x00:0x40])] // @1120 stack[-2] // } 10F8 5B JUMPDEST 10F9 33 CALLER 10FA 60 PUSH1 0x00 10FC 90 SWAP1 10FD 81 DUP2 10FE 52 MSTORE 10FF 60 PUSH1 0x05 1101 60 PUSH1 0x20 1103 52 MSTORE 1104 60 PUSH1 0x40 1106 81 DUP2 1107 20 SHA3 1108 54 SLOAD 1109 68 PUSH9 0x010000000000000000 1113 90 SWAP1 1114 04 DIV 1115 67 PUSH8 0xffffffffffffffff 111E 16 AND 111F 90 SWAP1 1120 83 DUP4 1121 61 PUSH2 0x112b 1124 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @10FE memory[0x00:0x20] = msg.sender // @1103 memory[0x20:0x40] = 0x05 // @111F stack[0] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x010000000000000000 // @111F stack[1] = 0x00 // } // Block ends with conditional jump to 0x112b, if stack[-2] label_1125: // Incoming jump from 0x1124, if not stack[-2] 1125 60 PUSH1 0x03 1127 61 PUSH2 0x112e 112A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1125 stack[0] = 0x03 } // Block ends with unconditional jump to 0x112e label_112B: // Incoming jump from 0x1124, if stack[-2] // Inputs[3] // { // @112F stack[-1] // @1132 stack[-6] // @1133 stack[-2] // } 112B 5B JUMPDEST 112C 60 PUSH1 0x04 112E 5B JUMPDEST 112F 90 SWAP1 1130 50 POP 1131 80 DUP1 1132 86 DUP7 1133 83 DUP4 1134 01 ADD 1135 11 GT 1136 15 ISZERO 1137 61 PUSH2 0x116c 113A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @112F stack[-1] = 0x04 } // Block ends with conditional jump to 0x116c, if !(stack[-2] + stack[-6] > 0x04) label_113B: // Incoming jump from 0x113A, if not !(stack[-3] + stack[-7] > stack[-1]) // Incoming jump from 0x113A, if not !(stack[-2] + stack[-6] > 0x04) // Inputs[3] // { // @113D memory[0x40:0x60] // @1166 memory[0x40:0x60] // @116B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 113B 60 PUSH1 0x40 113D 51 MLOAD 113E 7F PUSH32 0xc9352da500000000000000000000000000000000000000000000000000000000 115F 81 DUP2 1160 52 MSTORE 1161 60 PUSH1 0x04 1163 01 ADD 1164 60 PUSH1 0x40 1166 51 MLOAD 1167 80 DUP1 1168 91 SWAP2 1169 03 SUB 116A 90 SWAP1 116B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1160 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc9352da500000000000000000000000000000000000000000000000000000000 // @116B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_116C: // Incoming jump from 0x113A, if !(stack[-3] + stack[-7] > stack[-1]) // Incoming jump from 0x113A, if !(stack[-2] + stack[-6] > 0x04) // Inputs[3] // { // @1170 stack[-6] // @1176 storage[0x01] // @1179 storage[0x00] // } 116C 5B JUMPDEST 116D 61 PUSH2 0x3a98 1170 86 DUP7 1171 61 PUSH2 0x117d 1174 60 PUSH1 0x01 1176 54 SLOAD 1177 60 PUSH1 0x00 1179 54 SLOAD 117A 03 SUB 117B 90 SWAP1 117C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @116D stack[0] = 0x3a98 // @1170 stack[1] = stack[-6] // @117B stack[2] = storage[0x00] - storage[0x01] // } // Block ends with unconditional jump to 0x117d label_117D: // Incoming jump from 0x117C // Inputs[3] // { // @117E stack[-1] // @117E stack[-2] // @117F stack[-3] // } 117D 5B JUMPDEST 117E 01 ADD 117F 11 GT 1180 15 ISZERO 1181 61 PUSH2 0x11b6 1184 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x11b6, if !(stack[-1] + stack[-2] > stack[-3]) label_1185: // Incoming jump from 0x1184, if not !(stack[-1] + stack[-2] > stack[-3]) // Inputs[3] // { // @1187 memory[0x40:0x60] // @11B0 memory[0x40:0x60] // @11B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1185 60 PUSH1 0x40 1187 51 MLOAD 1188 7F PUSH32 0x8e645fda00000000000000000000000000000000000000000000000000000000 11A9 81 DUP2 11AA 52 MSTORE 11AB 60 PUSH1 0x04 11AD 01 ADD 11AE 60 PUSH1 0x40 11B0 51 MLOAD 11B1 80 DUP1 11B2 91 SWAP2 11B3 03 SUB 11B4 90 SWAP1 11B5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8e645fda00000000000000000000000000000000000000000000000000000000 // @11B5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_11B6: // Incoming jump from 0x1184, if !(stack[-1] + stack[-2] > stack[-3]) // Inputs[3] // { // @11BC stack[-3] // @11BD stack[-2] // @11BE stack[-6] // } 11B6 5B JUMPDEST 11B7 60 PUSH1 0x00 11B9 61 PUSH2 0x11c3 11BC 84 DUP5 11BD 84 DUP5 11BE 89 DUP10 11BF 61 PUSH2 0x18c5 11C2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @11B7 stack[0] = 0x00 // @11B9 stack[1] = 0x11c3 // @11BC stack[2] = stack[-3] // @11BD stack[3] = stack[-2] // @11BE stack[4] = stack[-6] // } // Block ends with call to 0x18c5, returns to 0x11C3 label_11C3: // Incoming return from call to 0x18C5 at 0x11C2 // Inputs[3] // { // @11C4 stack[-1] // @11C4 stack[-2] // @11C7 msg.value // } 11C3 5B JUMPDEST 11C4 90 SWAP1 11C5 50 POP 11C6 80 DUP1 11C7 34 CALLVALUE 11C8 10 LT 11C9 15 ISZERO 11CA 61 PUSH2 0x11ff 11CD 57 *JUMPI // Stack delta = -1 // Outputs[1] { @11C4 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x11ff, if !(msg.value < stack[-1]) label_11CE: // Incoming jump from 0x11CD, if not !(msg.value < stack[-1]) // Inputs[3] // { // @11D0 memory[0x40:0x60] // @11F9 memory[0x40:0x60] // @11FE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 11CE 60 PUSH1 0x40 11D0 51 MLOAD 11D1 7F PUSH32 0x356680b700000000000000000000000000000000000000000000000000000000 11F2 81 DUP2 11F3 52 MSTORE 11F4 60 PUSH1 0x04 11F6 01 ADD 11F7 60 PUSH1 0x40 11F9 51 MLOAD 11FA 80 DUP1 11FB 91 SWAP2 11FC 03 SUB 11FD 90 SWAP1 11FE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x356680b700000000000000000000000000000000000000000000000000000000 // @11FE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_11FF: // Incoming jump from 0x11CD, if !(msg.value < stack[-1]) // Inputs[3] // { // @1203 stack[-5] // @1204 stack[-4] // @1205 stack[-6] // } 11FF 5B JUMPDEST 1200 61 PUSH2 0x120a 1203 85 DUP6 1204 85 DUP6 1205 88 DUP9 1206 61 PUSH2 0x1916 1209 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1200 stack[0] = 0x120a // @1203 stack[1] = stack[-5] // @1204 stack[2] = stack[-4] // @1205 stack[3] = stack[-6] // } // Block ends with call to 0x1916, returns to 0x120A label_120A: // Incoming return from call to 0x1916 at 0x1209 // Inputs[2] // { // @120E msg.sender // @120F stack[-7] // } 120A 5B JUMPDEST 120B 61 PUSH2 0x1214 120E 33 CALLER 120F 88 DUP9 1210 61 PUSH2 0x14ed 1213 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @120B stack[0] = 0x1214 // @120E stack[1] = msg.sender // @120F stack[2] = stack[-7] // } // Block ends with call to 0x14ed, returns to 0x1214 label_1214: // Incoming return from call to 0x14ED at 0x1213 // Inputs[1] { @121C stack[-8] } 1214 5B JUMPDEST 1215 50 POP 1216 50 POP 1217 50 POP 1218 50 POP 1219 50 POP 121A 50 POP 121B 50 POP 121C 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_121D: // Incoming call from 0x071C, returns to 0x071D // Inputs[2] // { // @1221 storage[0x00] // @1222 stack[-1] // } 121D 5B JUMPDEST 121E 60 PUSH1 0x00 1220 80 DUP1 1221 54 SLOAD 1222 82 DUP3 1223 10 LT 1224 80 DUP1 1225 15 ISZERO 1226 61 PUSH2 0x067a 1229 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @121E stack[0] = 0x00 // @1223 stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x067a, if !(stack[-1] < storage[0x00]) label_122A: // Incoming jump from 0x1229, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @122E stack[-3] // @1239 memory[0x00:0x40] // @123A storage[keccak256(memory[0x00:0x40])] // @1246 stack[-4] // } 122A 50 POP 122B 50 POP 122C 60 PUSH1 0x00 122E 90 SWAP1 122F 81 DUP2 1230 52 MSTORE 1231 60 PUSH1 0x04 1233 60 PUSH1 0x20 1235 52 MSTORE 1236 60 PUSH1 0x40 1238 90 SWAP1 1239 20 SHA3 123A 54 SLOAD 123B 60 PUSH1 0x01 123D 60 PUSH1 0xe0 123F 1B SHL 1240 90 SWAP1 1241 04 DIV 1242 60 PUSH1 0xff 1244 16 AND 1245 15 ISZERO 1246 90 SWAP1 1247 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1230 memory[0x00:0x20] = stack[-3] // @1235 memory[0x20:0x40] = 0x04 // @1246 stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_1248: // Incoming call from 0x0829, returns to 0x082A // Incoming call from 0x13CA, returns to 0x13CB // Inputs[8] // { // @124B stack[-2] // @1257 memory[0x00:0x40] // @1259 storage[keccak256(memory[0x00:0x40])] // @1279 stack[-3] // @1283 memory[0x40:0x60] // @1287 stack[-1] // @12AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @12B0 stack[-4] // } 1248 5B JUMPDEST 1249 60 PUSH1 0x00 124B 82 DUP3 124C 81 DUP2 124D 52 MSTORE 124E 60 PUSH1 0x06 1250 60 PUSH1 0x20 1252 52 MSTORE 1253 60 PUSH1 0x40 1255 80 DUP1 1256 82 DUP3 1257 20 SHA3 1258 80 DUP1 1259 54 SLOAD 125A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 126F 19 NOT 1270 16 AND 1271 60 PUSH1 0x01 1273 60 PUSH1 0x01 1275 60 PUSH1 0xa0 1277 1B SHL 1278 03 SUB 1279 87 DUP8 127A 81 DUP2 127B 16 AND 127C 91 SWAP2 127D 82 DUP3 127E 17 OR 127F 90 SWAP1 1280 92 SWAP3 1281 55 SSTORE 1282 91 SWAP2 1283 51 MLOAD 1284 85 DUP6 1285 93 SWAP4 1286 91 SWAP2 1287 85 DUP6 1288 16 AND 1289 91 SWAP2 128A 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 12AB 91 SWAP2 12AC A4 LOG4 12AD 50 POP 12AE 50 POP 12AF 50 POP 12B0 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @124D memory[0x00:0x20] = stack[-2] // @1252 memory[0x20:0x40] = 0x06 // @1281 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @12AC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_12B1: // Incoming jump from 0x0E94 // Incoming jump from 0x0839 // Inputs[1] { @12B7 stack[-1] } 12B1 5B JUMPDEST 12B2 60 PUSH1 0x00 12B4 61 PUSH2 0x12bc 12B7 82 DUP3 12B8 61 PUSH2 0x1507 12BB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12B2 stack[0] = 0x00 // @12B4 stack[1] = 0x12bc // @12B7 stack[2] = stack[-1] // } // Block ends with call to 0x1507, returns to 0x12BC label_12BC: // Incoming return from call to 0x1507 at 0x12BB // Inputs[4] // { // @12BD stack[-1] // @12BD stack[-2] // @12BF stack[-5] // @12CD memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 12BC 5B JUMPDEST 12BD 90 SWAP1 12BE 50 POP 12BF 83 DUP4 12C0 60 PUSH1 0x01 12C2 60 PUSH1 0x01 12C4 60 PUSH1 0xa0 12C6 1B SHL 12C7 03 SUB 12C8 16 AND 12C9 81 DUP2 12CA 60 PUSH1 0x00 12CC 01 ADD 12CD 51 MLOAD 12CE 60 PUSH1 0x01 12D0 60 PUSH1 0x01 12D2 60 PUSH1 0xa0 12D4 1B SHL 12D5 03 SUB 12D6 16 AND 12D7 14 EQ 12D8 61 PUSH2 0x130d 12DB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @12BD stack[-2] = stack[-1] } // Block ends with conditional jump to 0x130d, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_12DC: // Incoming jump from 0x12DB, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @12DE memory[0x40:0x60] // @1307 memory[0x40:0x60] // @130C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12DC 60 PUSH1 0x40 12DE 51 MLOAD 12DF 7F PUSH32 0xa114810000000000000000000000000000000000000000000000000000000000 1300 81 DUP2 1301 52 MSTORE 1302 60 PUSH1 0x04 1304 01 ADD 1305 60 PUSH1 0x40 1307 51 MLOAD 1308 80 DUP1 1309 91 SWAP2 130A 03 SUB 130B 90 SWAP1 130C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1301 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa114810000000000000000000000000000000000000000000000000000000000 // @130C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_130D: // Incoming jump from 0x12DB, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @1310 msg.sender // @1319 stack[-4] // } 130D 5B JUMPDEST 130E 60 PUSH1 0x00 1310 33 CALLER 1311 60 PUSH1 0x01 1313 60 PUSH1 0x01 1315 60 PUSH1 0xa0 1317 1B SHL 1318 03 SUB 1319 86 DUP7 131A 16 AND 131B 14 EQ 131C 80 DUP1 131D 61 PUSH2 0x132b 1320 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @130E stack[0] = 0x00 // @131B stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x132b, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_1321: // Incoming jump from 0x1320, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @1325 stack[-6] // @1326 msg.sender // } 1321 50 POP 1322 61 PUSH2 0x132b 1325 85 DUP6 1326 33 CALLER 1327 61 PUSH2 0x0562 132A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1322 stack[-1] = 0x132b // @1325 stack[0] = stack[-6] // @1326 stack[1] = msg.sender // } // Block ends with call to 0x0562, returns to 0x132B label_132B: // Incoming jump from 0x1320, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x0562 at 0x132A // Inputs[1] { @132C stack[-1] } 132B 5B JUMPDEST 132C 80 DUP1 132D 61 PUSH2 0x1346 1330 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1346, if stack[-1] label_1331: // Incoming jump from 0x1330, if not stack[-1] // Inputs[2] // { // @1332 msg.sender // @1336 stack[-4] // } 1331 50 POP 1332 33 CALLER 1333 61 PUSH2 0x133b 1336 84 DUP5 1337 61 PUSH2 0x0712 133A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1332 stack[-1] = msg.sender // @1333 stack[0] = 0x133b // @1336 stack[1] = stack[-4] // } // Block ends with call to 0x0712, returns to 0x133B label_133B: // Incoming return from call to 0x0712 at 0x133A // Inputs[2] // { // @1344 stack[-1] // @1345 stack[-2] // } 133B 5B JUMPDEST 133C 60 PUSH1 0x01 133E 60 PUSH1 0x01 1340 60 PUSH1 0xa0 1342 1B SHL 1343 03 SUB 1344 16 AND 1345 14 EQ // Stack delta = -1 // Outputs[1] { @1345 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1346: // Incoming jump from 0x1330, if stack[-1] // Incoming jump from 0x1345 // Inputs[2] // { // @1347 stack[-1] // @1347 stack[-2] // } 1346 5B JUMPDEST 1347 90 SWAP1 1348 50 POP 1349 80 DUP1 134A 61 PUSH2 0x137f 134D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1347 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x137f, if stack[-1] label_134E: // Incoming jump from 0x134D, if not stack[-1] // Inputs[3] // { // @1350 memory[0x40:0x60] // @1379 memory[0x40:0x60] // @137E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 134E 60 PUSH1 0x40 1350 51 MLOAD 1351 7F PUSH32 0x59c896be00000000000000000000000000000000000000000000000000000000 1372 81 DUP2 1373 52 MSTORE 1374 60 PUSH1 0x04 1376 01 ADD 1377 60 PUSH1 0x40 1379 51 MLOAD 137A 80 DUP1 137B 91 SWAP2 137C 03 SUB 137D 90 SWAP1 137E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1373 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000 // @137E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_137F: // Incoming jump from 0x134D, if stack[-1] // Inputs[1] { @1388 stack[-4] } 137F 5B JUMPDEST 1380 60 PUSH1 0x01 1382 60 PUSH1 0x01 1384 60 PUSH1 0xa0 1386 1B SHL 1387 03 SUB 1388 84 DUP5 1389 16 AND 138A 61 PUSH2 0x13bf 138D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13bf, if stack[-4] & (0x01 << 0xa0) - 0x01 label_138E: // Incoming jump from 0x138D, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1390 memory[0x40:0x60] // @13B9 memory[0x40:0x60] // @13BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 138E 60 PUSH1 0x40 1390 51 MLOAD 1391 7F PUSH32 0xea553b3400000000000000000000000000000000000000000000000000000000 13B2 81 DUP2 13B3 52 MSTORE 13B4 60 PUSH1 0x04 13B6 01 ADD 13B7 60 PUSH1 0x40 13B9 51 MLOAD 13BA 80 DUP1 13BB 91 SWAP2 13BC 03 SUB 13BD 90 SWAP1 13BE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @13B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000 // @13BE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_13BF: // Incoming jump from 0x138D, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @13C5 stack[-3] // @13C6 stack[-5] // } 13BF 5B JUMPDEST 13C0 61 PUSH2 0x13cb 13C3 60 PUSH1 0x00 13C5 84 DUP5 13C6 87 DUP8 13C7 61 PUSH2 0x1248 13CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13C0 stack[0] = 0x13cb // @13C3 stack[1] = 0x00 // @13C5 stack[2] = stack[-3] // @13C6 stack[3] = stack[-5] // } // Block ends with call to 0x1248, returns to 0x13CB label_13CB: // Incoming return from call to 0x1248 at 0x13CA // Inputs[12] // { // @13D4 stack[-5] // @13E7 memory[0x00:0x40] // @13E9 storage[keccak256(memory[0x00:0x40])] // @140D stack[-4] // @1415 memory[0x00:0x40] // @1417 storage[keccak256(memory[0x00:0x40])] // @142B stack[-3] // @1435 memory[0x00:0x40] // @1437 storage[keccak256(memory[0x00:0x40])] // @144A block.timestamp // @145B memory[0x00:0x40] // @145D storage[keccak256(memory[0x00:0x40])] // } 13CB 5B JUMPDEST 13CC 60 PUSH1 0x01 13CE 60 PUSH1 0x01 13D0 60 PUSH1 0xa0 13D2 1B SHL 13D3 03 SUB 13D4 85 DUP6 13D5 81 DUP2 13D6 16 AND 13D7 60 PUSH1 0x00 13D9 90 SWAP1 13DA 81 DUP2 13DB 52 MSTORE 13DC 60 PUSH1 0x05 13DE 60 PUSH1 0x20 13E0 90 SWAP1 13E1 81 DUP2 13E2 52 MSTORE 13E3 60 PUSH1 0x40 13E5 80 DUP1 13E6 83 DUP4 13E7 20 SHA3 13E8 80 DUP1 13E9 54 SLOAD 13EA 67 PUSH8 0xffffffffffffffff 13F3 19 NOT 13F4 80 DUP1 13F5 82 DUP3 13F6 16 AND 13F7 67 PUSH8 0xffffffffffffffff 1400 92 SWAP3 1401 83 DUP4 1402 16 AND 1403 60 PUSH1 0x00 1405 19 NOT 1406 01 ADD 1407 83 DUP4 1408 16 AND 1409 17 OR 140A 90 SWAP1 140B 92 SWAP3 140C 55 SSTORE 140D 89 DUP10 140E 86 DUP7 140F 16 AND 1410 80 DUP1 1411 86 DUP7 1412 52 MSTORE 1413 83 DUP4 1414 86 DUP7 1415 20 SHA3 1416 80 DUP1 1417 54 SLOAD 1418 93 SWAP4 1419 84 DUP5 141A 16 AND 141B 93 SWAP4 141C 83 DUP4 141D 16 AND 141E 60 PUSH1 0x01 1420 90 SWAP1 1421 81 DUP2 1422 01 ADD 1423 84 DUP5 1424 16 AND 1425 94 SWAP5 1426 90 SWAP1 1427 94 SWAP5 1428 17 OR 1429 90 SWAP1 142A 55 SSTORE 142B 89 DUP10 142C 86 DUP7 142D 52 MSTORE 142E 60 PUSH1 0x04 1430 90 SWAP1 1431 94 SWAP5 1432 52 MSTORE 1433 82 DUP3 1434 85 DUP6 1435 20 SHA3 1436 80 DUP1 1437 54 SLOAD 1438 60 PUSH1 0x01 143A 60 PUSH1 0x01 143C 60 PUSH1 0xe0 143E 1B SHL 143F 03 SUB 1440 19 NOT 1441 16 AND 1442 90 SWAP1 1443 94 SWAP5 1444 17 OR 1445 60 PUSH1 0x01 1447 60 PUSH1 0xa0 1449 1B SHL 144A 42 TIMESTAMP 144B 90 SWAP1 144C 92 SWAP3 144D 16 AND 144E 91 SWAP2 144F 90 SWAP1 1450 91 SWAP2 1451 02 MUL 1452 17 OR 1453 83 DUP4 1454 55 SSTORE 1455 87 DUP8 1456 01 ADD 1457 80 DUP1 1458 84 DUP5 1459 52 MSTORE 145A 92 SWAP3 145B 20 SHA3 145C 80 DUP1 145D 54 SLOAD 145E 91 SWAP2 145F 93 SWAP4 1460 90 SWAP1 1461 91 SWAP2 1462 16 AND 1463 61 PUSH2 0x14a1 1466 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @13DB memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @13E2 memory[0x20:0x40] = 0x05 // @140C storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & ~0x00 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @1412 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @142A storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @142D memory[0x00:0x20] = stack[-3] // @1432 memory[0x20:0x40] = 0x04 // @1454 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1459 memory[0x00:0x20] = stack[-3] + 0x01 // @145A stack[1] = stack[-3] + 0x01 // @145F stack[0] = keccak256(memory[0x00:0x40]) // @1461 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x14a1, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_1467: // Incoming jump from 0x1466, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1469 storage[0x00] // @146A stack[-2] // } 1467 60 PUSH1 0x00 1469 54 SLOAD 146A 82 DUP3 146B 14 EQ 146C 61 PUSH2 0x14a1 146F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14a1, if stack[-2] == storage[0x00] label_1470: // Incoming jump from 0x146F, if not stack[-2] == storage[0x00] // Inputs[5] // { // @1470 stack[-1] // @1471 storage[stack[-1]] // @1474 stack[-5] // @1476 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @149B stack[-8] // } 1470 80 DUP1 1471 54 SLOAD 1472 60 PUSH1 0x20 1474 86 DUP7 1475 01 ADD 1476 51 MLOAD 1477 67 PUSH8 0xffffffffffffffff 1480 16 AND 1481 60 PUSH1 0x01 1483 60 PUSH1 0xa0 1485 1B SHL 1486 02 MUL 1487 60 PUSH1 0x01 1489 60 PUSH1 0x01 148B 60 PUSH1 0xe0 148D 1B SHL 148E 03 SUB 148F 19 NOT 1490 90 SWAP1 1491 91 SWAP2 1492 16 AND 1493 60 PUSH1 0x01 1495 60 PUSH1 0x01 1497 60 PUSH1 0xa0 1499 1B SHL 149A 03 SUB 149B 8A DUP11 149C 16 AND 149D 17 OR 149E 17 OR 149F 81 DUP2 14A0 55 SSTORE // Stack delta = +0 // Outputs[1] { @14A0 storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_14A1: // Incoming jump from 0x14A0 // Incoming jump from 0x146F, if stack[-2] == storage[0x00] // Incoming jump from 0x1466, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @14A5 stack[-6] // @14A6 stack[-7] // @14B0 stack[-8] // @14DD memory[0x40:0x60] // @14E0 memory[0x40:0x60] // @14E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 14A1 5B JUMPDEST 14A2 50 POP 14A3 50 POP 14A4 50 POP 14A5 82 DUP3 14A6 84 DUP5 14A7 60 PUSH1 0x01 14A9 60 PUSH1 0x01 14AB 60 PUSH1 0xa0 14AD 1B SHL 14AE 03 SUB 14AF 16 AND 14B0 86 DUP7 14B1 60 PUSH1 0x01 14B3 60 PUSH1 0x01 14B5 60 PUSH1 0xa0 14B7 1B SHL 14B8 03 SUB 14B9 16 AND 14BA 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 14DB 60 PUSH1 0x40 14DD 51 MLOAD 14DE 60 PUSH1 0x40 14E0 51 MLOAD 14E1 80 DUP1 14E2 91 SWAP2 14E3 03 SUB 14E4 90 SWAP1 14E5 A4 LOG4 // Stack delta = -3 // Outputs[1] { @14E5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block continues label_14E6: // Incoming jump from 0x14E5 // Incoming jump from 0x1C41 // Inputs[1] { @14EC stack[-6] } 14E6 5B JUMPDEST 14E7 50 POP 14E8 50 POP 14E9 50 POP 14EA 50 POP 14EB 50 POP 14EC 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_14ED: // Incoming jump from 0x09E2 // Incoming jump from 0x0E81 // Incoming call from 0x1213, returns to 0x1214 // Inputs[3] // { // @14F1 stack[-2] // @14F2 stack[-1] // @14F5 memory[0x40:0x60] // } 14ED 5B JUMPDEST 14EE 61 PUSH2 0x0a50 14F1 82 DUP3 14F2 82 DUP3 14F3 60 PUSH1 0x40 14F5 51 MLOAD 14F6 80 DUP1 14F7 60 PUSH1 0x20 14F9 01 ADD 14FA 60 PUSH1 0x40 14FC 52 MSTORE 14FD 80 DUP1 14FE 60 PUSH1 0x00 1500 81 DUP2 1501 52 MSTORE 1502 50 POP 1503 61 PUSH2 0x19fe 1506 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @14EE stack[0] = 0x0a50 // @14F1 stack[1] = stack[-2] // @14F2 stack[2] = stack[-1] // @14F5 stack[3] = memory[0x40:0x60] // @14FC memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1501 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x19fe, returns to 0x0A50 label_1507: // Incoming call from 0x0BB7, returns to 0x0BB8 // Incoming call from 0x12BB, returns to 0x12BC // Inputs[3] // { // @150B memory[0x40:0x60] // @1525 stack[-1] // @1528 storage[0x00] // } 1507 5B JUMPDEST 1508 60 PUSH1 0x40 150A 80 DUP1 150B 51 MLOAD 150C 60 PUSH1 0x60 150E 81 DUP2 150F 01 ADD 1510 82 DUP3 1511 52 MSTORE 1512 60 PUSH1 0x00 1514 80 DUP1 1515 82 DUP3 1516 52 MSTORE 1517 60 PUSH1 0x20 1519 82 DUP3 151A 01 ADD 151B 81 DUP2 151C 90 SWAP1 151D 52 MSTORE 151E 91 SWAP2 151F 81 DUP2 1520 01 ADD 1521 91 SWAP2 1522 90 SWAP1 1523 91 SWAP2 1524 52 MSTORE 1525 81 DUP2 1526 60 PUSH1 0x00 1528 54 SLOAD 1529 81 DUP2 152A 10 LT 152B 15 ISZERO 152C 61 PUSH2 0x160a 152F 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1511 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1516 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @151D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1523 stack[0] = memory[0x40:0x60] // @1524 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1525 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x160a, if !(stack[-1] < storage[0x00]) label_1530: // Incoming jump from 0x152F, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @1532 stack[-1] // @1541 memory[0x00:0x40] // @1543 memory[0x40:0x60] // @154B storage[keccak256(memory[0x00:0x40])] // } 1530 60 PUSH1 0x00 1532 81 DUP2 1533 81 DUP2 1534 52 MSTORE 1535 60 PUSH1 0x04 1537 60 PUSH1 0x20 1539 90 SWAP1 153A 81 DUP2 153B 52 MSTORE 153C 60 PUSH1 0x40 153E 91 SWAP2 153F 82 DUP3 1540 90 SWAP1 1541 20 SHA3 1542 82 DUP3 1543 51 MLOAD 1544 60 PUSH1 0x60 1546 81 DUP2 1547 01 ADD 1548 84 DUP5 1549 52 MSTORE 154A 90 SWAP1 154B 54 SLOAD 154C 60 PUSH1 0x01 154E 60 PUSH1 0x01 1550 60 PUSH1 0xa0 1552 1B SHL 1553 03 SUB 1554 81 DUP2 1555 16 AND 1556 82 DUP3 1557 52 MSTORE 1558 60 PUSH1 0x01 155A 60 PUSH1 0xa0 155C 1B SHL 155D 81 DUP2 155E 04 DIV 155F 67 PUSH8 0xffffffffffffffff 1568 16 AND 1569 92 SWAP3 156A 82 DUP3 156B 01 ADD 156C 92 SWAP3 156D 90 SWAP1 156E 92 SWAP3 156F 52 MSTORE 1570 60 PUSH1 0x01 1572 60 PUSH1 0xe0 1574 1B SHL 1575 90 SWAP1 1576 91 SWAP2 1577 04 DIV 1578 60 PUSH1 0xff 157A 16 AND 157B 15 ISZERO 157C 15 ISZERO 157D 91 SWAP2 157E 81 DUP2 157F 01 ADD 1580 82 DUP3 1581 90 SWAP1 1582 52 MSTORE 1583 90 SWAP1 1584 61 PUSH2 0x1608 1587 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @1534 memory[0x00:0x20] = stack[-1] // @153B memory[0x20:0x40] = 0x04 // @1549 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1557 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @156F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1582 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @1583 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1608, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_1588: // Incoming jump from 0x1587, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @1588 stack[-1] // @1589 memory[stack[-1]:stack[-1] + 0x20] // } 1588 80 DUP1 1589 51 MLOAD 158A 60 PUSH1 0x01 158C 60 PUSH1 0x01 158E 60 PUSH1 0xa0 1590 1B SHL 1591 03 SUB 1592 16 AND 1593 15 ISZERO 1594 61 PUSH2 0x159e 1597 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x159e, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_1598: // Incoming jump from 0x1597, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1598 stack[-1] // @1598 stack[-5] // @1599 stack[-4] // } 1598 93 SWAP4 1599 92 SWAP3 159A 50 POP 159B 50 POP 159C 50 POP 159D 56 *JUMP // Stack delta = -4 // Outputs[1] { @1598 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_159E: // Incoming jump from 0x1597, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1607 // Inputs[4] // { // @15A3 stack[-2] // @15B5 memory[0x00:0x40] // @15B7 memory[0x40:0x60] // @15BF storage[keccak256(memory[0x00:0x40])] // } 159E 5B JUMPDEST 159F 50 POP 15A0 60 PUSH1 0x00 15A2 19 NOT 15A3 01 ADD 15A4 60 PUSH1 0x00 15A6 81 DUP2 15A7 81 DUP2 15A8 52 MSTORE 15A9 60 PUSH1 0x04 15AB 60 PUSH1 0x20 15AD 90 SWAP1 15AE 81 DUP2 15AF 52 MSTORE 15B0 60 PUSH1 0x40 15B2 91 SWAP2 15B3 82 DUP3 15B4 90 SWAP1 15B5 20 SHA3 15B6 82 DUP3 15B7 51 MLOAD 15B8 60 PUSH1 0x60 15BA 81 DUP2 15BB 01 ADD 15BC 84 DUP5 15BD 52 MSTORE 15BE 90 SWAP1 15BF 54 SLOAD 15C0 60 PUSH1 0x01 15C2 60 PUSH1 0x01 15C4 60 PUSH1 0xa0 15C6 1B SHL 15C7 03 SUB 15C8 81 DUP2 15C9 16 AND 15CA 80 DUP1 15CB 83 DUP4 15CC 52 MSTORE 15CD 60 PUSH1 0x01 15CF 60 PUSH1 0xa0 15D1 1B SHL 15D2 82 DUP3 15D3 04 DIV 15D4 67 PUSH8 0xffffffffffffffff 15DD 16 AND 15DE 93 SWAP4 15DF 83 DUP4 15E0 01 ADD 15E1 93 SWAP4 15E2 90 SWAP1 15E3 93 SWAP4 15E4 52 MSTORE 15E5 60 PUSH1 0x01 15E7 60 PUSH1 0xe0 15E9 1B SHL 15EA 90 SWAP1 15EB 04 DIV 15EC 60 PUSH1 0xff 15EE 16 AND 15EF 15 ISZERO 15F0 15 ISZERO 15F1 92 SWAP3 15F2 81 DUP2 15F3 01 ADD 15F4 92 SWAP3 15F5 90 SWAP1 15F6 92 SWAP3 15F7 52 MSTORE 15F8 15 ISZERO 15F9 61 PUSH2 0x1603 15FC 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @15A3 stack[-2] = ~0x00 + stack[-2] // @15A8 memory[0x00:0x20] = ~0x00 + stack[-2] // @15AF memory[0x20:0x40] = 0x04 // @15BD memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @15CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @15E4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @15F6 stack[-1] = memory[0x40:0x60] // @15F7 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x1603, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_15FD: // Incoming jump from 0x15FC, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @15FD stack[-1] // @15FD stack[-5] // @15FE stack[-4] // } 15FD 93 SWAP4 15FE 92 SWAP3 15FF 50 POP 1600 50 POP 1601 50 POP 1602 56 *JUMP // Stack delta = -4 // Outputs[1] { @15FD stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1603: // Incoming jump from 0x15FC, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 1603 5B JUMPDEST 1604 61 PUSH2 0x159e 1607 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x159e label_1608: // Incoming jump from 0x1587, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 1608 5B JUMPDEST 1609 50 POP // Stack delta = -1 // Block continues label_160A: // Incoming jump from 0x152F, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1609 // Inputs[3] // { // @160D memory[0x40:0x60] // @1636 memory[0x40:0x60] // @163B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 160A 5B JUMPDEST 160B 60 PUSH1 0x40 160D 51 MLOAD 160E 7F PUSH32 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 162F 81 DUP2 1630 52 MSTORE 1631 60 PUSH1 0x04 1633 01 ADD 1634 60 PUSH1 0x40 1636 51 MLOAD 1637 80 DUP1 1638 91 SWAP2 1639 03 SUB 163A 90 SWAP1 163B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1630 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 // @163B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_163C: // Incoming call from 0x1021, returns to 0x0950 // Incoming call from 0x0D13, returns to 0x0D14 // Inputs[5] // { // @1640 storage[0x08] // @1649 stack[-1] // @166B memory[0x40:0x60] // @1697 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @169A stack[-2] // } 163C 5B JUMPDEST 163D 60 PUSH1 0x08 163F 80 DUP1 1640 54 SLOAD 1641 60 PUSH1 0x01 1643 60 PUSH1 0x01 1645 60 PUSH1 0xa0 1647 1B SHL 1648 03 SUB 1649 83 DUP4 164A 81 DUP2 164B 16 AND 164C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1661 19 NOT 1662 83 DUP4 1663 16 AND 1664 81 DUP2 1665 17 OR 1666 90 SWAP1 1667 93 SWAP4 1668 55 SSTORE 1669 60 PUSH1 0x40 166B 51 MLOAD 166C 91 SWAP2 166D 16 AND 166E 91 SWAP2 166F 90 SWAP1 1670 82 DUP3 1671 90 SWAP1 1672 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1693 90 SWAP1 1694 60 PUSH1 0x00 1696 90 SWAP1 1697 A3 LOG3 1698 50 POP 1699 50 POP 169A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1668 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~0xffffffffffffffffffffffffffffffffffffffff) // @1697 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_169B: // Incoming jump from 0x1BBA // Inputs[6] // { // @169E memory[0x40:0x60] // @16B4 stack[-3] // @16C1 msg.sender // @16C3 stack[-4] // @16C5 stack[-2] // @16C7 stack[-1] // } 169B 5B JUMPDEST 169C 60 PUSH1 0x40 169E 51 MLOAD 169F 63 PUSH4 0x0a85bd01 16A4 60 PUSH1 0xe1 16A6 1B SHL 16A7 81 DUP2 16A8 52 MSTORE 16A9 60 PUSH1 0x00 16AB 90 SWAP1 16AC 60 PUSH1 0x01 16AE 60 PUSH1 0x01 16B0 60 PUSH1 0xa0 16B2 1B SHL 16B3 03 SUB 16B4 85 DUP6 16B5 16 AND 16B6 90 SWAP1 16B7 63 PUSH4 0x150b7a02 16BC 90 SWAP1 16BD 61 PUSH2 0x16d0 16C0 90 SWAP1 16C1 33 CALLER 16C2 90 SWAP1 16C3 89 DUP10 16C4 90 SWAP1 16C5 88 DUP9 16C6 90 SWAP1 16C7 88 DUP9 16C8 90 SWAP1 16C9 60 PUSH1 0x04 16CB 01 ADD 16CC 61 PUSH2 0x25c7 16CF 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @16A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @16AB stack[0] = 0x00 // @16B6 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @16BC stack[2] = 0x150b7a02 // @16C0 stack[3] = 0x16d0 // @16C2 stack[4] = msg.sender // @16C4 stack[5] = stack[-4] // @16C6 stack[6] = stack[-2] // @16C8 stack[7] = stack[-1] // @16CB stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25c7, returns to 0x16D0 label_16D0: // Incoming return from call to 0x25C7 at 0x16CF // Inputs[4] // { // @16D5 memory[0x40:0x60] // @16D7 stack[-1] // @16DC stack[-3] // @16DE address(stack[-3]).code.length // } 16D0 5B JUMPDEST 16D1 60 PUSH1 0x20 16D3 60 PUSH1 0x40 16D5 51 MLOAD 16D6 80 DUP1 16D7 83 DUP4 16D8 03 SUB 16D9 81 DUP2 16DA 60 PUSH1 0x00 16DC 87 DUP8 16DD 80 DUP1 16DE 3B EXTCODESIZE 16DF 15 ISZERO 16E0 80 DUP1 16E1 15 ISZERO 16E2 61 PUSH2 0x16ea 16E5 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @16D1 stack[0] = 0x20 // @16D5 stack[1] = memory[0x40:0x60] // @16D8 stack[2] = stack[-1] - memory[0x40:0x60] // @16D9 stack[3] = memory[0x40:0x60] // @16DA stack[4] = 0x00 // @16DC stack[5] = stack[-3] // @16DF stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x16ea, if !!address(stack[-3]).code.length label_16E6: // Incoming jump from 0x16E5, if not !!address(stack[-3]).code.length // Inputs[1] { @16E9 memory[0x00:0x00] } 16E6 60 PUSH1 0x00 16E8 80 DUP1 16E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @16E9 revert(memory[0x00:0x00]); } // Block terminates label_16EA: // Incoming jump from 0x16E5, if !!address(stack[-3]).code.length // Inputs[10] // { // @16EC msg.gas // @16ED memory[stack[-4]:stack[-4] + stack[-5]] // @16ED stack[-5] // @16ED stack[-2] // @16ED stack[-3] // @16ED stack[-4] // @16ED stack[-6] // @16ED address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @16ED stack[-7] // @16EE stack[-10] // } 16EA 5B JUMPDEST 16EB 50 POP 16EC 5A GAS 16ED F1 CALL 16EE 92 SWAP3 16EF 50 POP 16F0 50 POP 16F1 50 POP 16F2 80 DUP1 16F3 15 ISZERO 16F4 61 PUSH2 0x171a 16F7 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @16ED memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @16EE stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x171a, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_16F8: // Incoming jump from 0x16F7, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @16FC memory[0x40:0x60] // @16FF returndata.length // } 16F8 50 POP 16F9 60 PUSH1 0x40 16FB 80 DUP1 16FC 51 MLOAD 16FD 60 PUSH1 0x1f 16FF 3D RETURNDATASIZE 1700 90 SWAP1 1701 81 DUP2 1702 01 ADD 1703 60 PUSH1 0x1f 1705 19 NOT 1706 16 AND 1707 82 DUP3 1708 01 ADD 1709 90 SWAP1 170A 92 SWAP3 170B 52 MSTORE 170C 61 PUSH2 0x1717 170F 91 SWAP2 1710 81 DUP2 1711 01 ADD 1712 90 SWAP1 1713 61 PUSH2 0x2603 1716 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @170B memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @170F stack[-1] = 0x1717 // @1712 stack[1] = memory[0x40:0x60] // @1712 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2603, returns to 0x1717 label_1717: // Incoming return from call to 0x2603 at 0x1716 1717 5B JUMPDEST 1718 60 PUSH1 0x01 // Stack delta = +1 // Outputs[1] { @1718 stack[0] = 0x01 } // Block continues label_171A: // Incoming jump from 0x1718 // Incoming jump from 0x16F7, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @171E stack[-1] } 171A 5B JUMPDEST 171B 61 PUSH2 0x1775 171E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1775, if stack[-1] label_171F: // Incoming jump from 0x171E, if not stack[-1] // Inputs[1] { @171F returndata.length } 171F 3D RETURNDATASIZE 1720 80 DUP1 1721 80 DUP1 1722 15 ISZERO 1723 61 PUSH2 0x1748 1726 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @171F stack[0] = returndata.length // @1720 stack[1] = returndata.length // } // Block ends with conditional jump to 0x1748, if !returndata.length label_1727: // Incoming jump from 0x1726, if not !returndata.length // Inputs[6] // { // @1729 memory[0x40:0x60] // @172A stack[-2] // @1731 returndata.length // @1739 returndata.length // @173C returndata.length // @1743 returndata[0x00:0x00 + returndata.length] // } 1727 60 PUSH1 0x40 1729 51 MLOAD 172A 91 SWAP2 172B 50 POP 172C 60 PUSH1 0x1f 172E 19 NOT 172F 60 PUSH1 0x3f 1731 3D RETURNDATASIZE 1732 01 ADD 1733 16 AND 1734 82 DUP3 1735 01 ADD 1736 60 PUSH1 0x40 1738 52 MSTORE 1739 3D RETURNDATASIZE 173A 82 DUP3 173B 52 MSTORE 173C 3D RETURNDATASIZE 173D 60 PUSH1 0x00 173F 60 PUSH1 0x20 1741 84 DUP5 1742 01 ADD 1743 3E RETURNDATACOPY 1744 61 PUSH2 0x174d 1747 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @172A stack[-2] = memory[0x40:0x60] // @1738 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @173B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1743 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x174d label_1748: // Incoming jump from 0x1726, if !returndata.length // Inputs[2] // { // @174B stack[-2] // @1750 memory[0x60:0x80] // } 1748 5B JUMPDEST 1749 60 PUSH1 0x60 174B 91 SWAP2 174C 50 POP 174D 5B JUMPDEST 174E 50 POP 174F 80 DUP1 1750 51 MLOAD 1751 61 PUSH2 0x176d 1754 57 *JUMPI // Stack delta = -1 // Outputs[1] { @174B stack[-2] = 0x60 } // Block ends with conditional jump to 0x176d, if memory[0x60:0x80] label_1755: // Incoming jump from 0x1754, if not memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1754, if not memory[0x60:0x80] // Inputs[3] // { // @1757 memory[0x40:0x60] // @1767 memory[0x40:0x60] // @176C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1755 60 PUSH1 0x40 1757 51 MLOAD 1758 63 PUSH4 0x68d2bf6b 175D 60 PUSH1 0xe1 175F 1B SHL 1760 81 DUP2 1761 52 MSTORE 1762 60 PUSH1 0x04 1764 01 ADD 1765 60 PUSH1 0x40 1767 51 MLOAD 1768 80 DUP1 1769 91 SWAP2 176A 03 SUB 176B 90 SWAP1 176C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1761 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @176C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_176D: // Incoming jump from 0x1754, if memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1754, if memory[0x60:0x80] // Inputs[3] // { // @176E stack[-1] // @176F memory[stack[-1]:stack[-1] + 0x20] // @1774 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 176D 5B JUMPDEST 176E 80 DUP1 176F 51 MLOAD 1770 81 DUP2 1771 60 PUSH1 0x20 1773 01 ADD 1774 FD *REVERT // Stack delta = +0 // Outputs[1] { @1774 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1775: // Incoming jump from 0x171E, if stack[-1] // Inputs[2] // { // @177F stack[-1] // @1789 stack[-2] // } 1775 5B JUMPDEST 1776 60 PUSH1 0x01 1778 60 PUSH1 0x01 177A 60 PUSH1 0xe0 177C 1B SHL 177D 03 SUB 177E 19 NOT 177F 16 AND 1780 63 PUSH4 0x0a85bd01 1785 60 PUSH1 0xe1 1787 1B SHL 1788 14 EQ 1789 90 SWAP1 178A 50 POP // Stack delta = -1 // Outputs[1] { @1789 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_178B: // Incoming return from call to 0x2194 at 0x2252 // Incoming jump from 0x184C, if !stack[-7] // Incoming jump from 0x184C, if !stack[-5] // Incoming jump from 0x178A // Incoming jump from 0x184C, if !stack[-7] // Inputs[3] // { // @178C stack[-1] // @178C stack[-6] // @178D stack[-5] // } 178B 5B JUMPDEST 178C 94 SWAP5 178D 93 SWAP4 178E 50 POP 178F 50 POP 1790 50 POP 1791 50 POP 1792 56 *JUMP // Stack delta = -5 // Outputs[1] { @178C stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1793: // Incoming call from 0x0EE7, returns to 0x0EE8 // Inputs[1] { @1796 stack[-1] } 1793 5B JUMPDEST 1794 60 PUSH1 0x60 1796 81 DUP2 1797 61 PUSH2 0x17d3 179A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1794 stack[0] = 0x60 } // Block ends with conditional jump to 0x17d3, if stack[-1] label_179B: // Incoming jump from 0x179A, if not stack[-1] // Inputs[2] // { // @17A0 memory[0x40:0x60] // @17D1 stack[-3] // } 179B 50 POP 179C 50 POP 179D 60 PUSH1 0x40 179F 80 DUP1 17A0 51 MLOAD 17A1 80 DUP1 17A2 82 DUP3 17A3 01 ADD 17A4 90 SWAP1 17A5 91 SWAP2 17A6 52 MSTORE 17A7 60 PUSH1 0x01 17A9 81 DUP2 17AA 52 MSTORE 17AB 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 17CC 60 PUSH1 0x20 17CE 82 DUP3 17CF 01 ADD 17D0 52 MSTORE 17D1 90 SWAP1 17D2 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @17A6 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @17AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @17D0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @17D1 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_17D3: // Incoming jump from 0x179A, if stack[-1] // Inputs[1] { @17D4 stack[-2] } 17D3 5B JUMPDEST 17D4 81 DUP2 17D5 60 PUSH1 0x00 17D7 5B JUMPDEST 17D8 81 DUP2 17D9 15 ISZERO 17DA 61 PUSH2 0x17fd 17DD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @17D4 stack[0] = stack[-2] // @17D5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x17fd, if !stack[-2] label_17DE: // Incoming jump from 0x17DD, if not !stack[-2] // Incoming jump from 0x17DD, if not !stack[-2] // Inputs[1] { @17DE stack[-1] } 17DE 80 DUP1 17DF 61 PUSH2 0x17e7 17E2 81 DUP2 17E3 61 PUSH2 0x2636 17E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17DE stack[0] = stack[-1] // @17DF stack[1] = 0x17e7 // @17E2 stack[2] = stack[-1] // } // Block ends with call to 0x2636, returns to 0x17E7 label_17E7: // Incoming return from call to 0x2636 at 0x17E6 // Inputs[4] // { // @17E8 stack[-3] // @17E8 stack[-1] // @17ED stack[-2] // @17F1 stack[-4] // } 17E7 5B JUMPDEST 17E8 91 SWAP2 17E9 50 POP 17EA 61 PUSH2 0x17f6 17ED 90 SWAP1 17EE 50 POP 17EF 60 PUSH1 0x0a 17F1 83 DUP4 17F2 61 PUSH2 0x2667 17F5 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @17E8 stack[-3] = stack[-1] // @17ED stack[-2] = 0x17f6 // @17EF stack[-1] = 0x0a // @17F1 stack[0] = stack[-4] // } // Block ends with call to 0x2667, returns to 0x17F6 label_17F6: // Incoming return from call to 0x2667 at 0x17F5 // Inputs[2] // { // @17F7 stack[-1] // @17F7 stack[-3] // } 17F6 5B JUMPDEST 17F7 91 SWAP2 17F8 50 POP 17F9 61 PUSH2 0x17d7 17FC 56 *JUMP // Stack delta = -1 // Outputs[1] { @17F7 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x17d7 label_17FD: // Incoming jump from 0x17DD, if !stack[-2] // Incoming jump from 0x17DD, if !stack[-2] // Inputs[1] { @1800 stack[-1] } 17FD 5B JUMPDEST 17FE 60 PUSH1 0x00 1800 81 DUP2 1801 67 PUSH8 0xffffffffffffffff 180A 81 DUP2 180B 11 GT 180C 15 ISZERO 180D 61 PUSH2 0x1818 1810 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @17FE stack[0] = 0x00 // @1800 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1818, if !(stack[-1] > 0xffffffffffffffff) label_1811: // Incoming jump from 0x1810, if not !(stack[-1] > 0xffffffffffffffff) 1811 61 PUSH2 0x1818 1814 61 PUSH2 0x217e 1817 56 *JUMP // Stack delta = +1 // Outputs[1] { @1811 stack[0] = 0x1818 } // Block ends with unconditional jump to 0x217e label_1818: // Incoming jump from 0x1810, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @181B memory[0x40:0x60] // @181C stack[-1] // } 1818 5B JUMPDEST 1819 60 PUSH1 0x40 181B 51 MLOAD 181C 90 SWAP1 181D 80 DUP1 181E 82 DUP3 181F 52 MSTORE 1820 80 DUP1 1821 60 PUSH1 0x1f 1823 01 ADD 1824 60 PUSH1 0x1f 1826 19 NOT 1827 16 AND 1828 60 PUSH1 0x20 182A 01 ADD 182B 82 DUP3 182C 01 ADD 182D 60 PUSH1 0x40 182F 52 MSTORE 1830 80 DUP1 1831 15 ISZERO 1832 61 PUSH2 0x1842 1835 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @181C stack[-1] = memory[0x40:0x60] // @181C stack[0] = stack[-1] // @181F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @182F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1842, if !stack[-1] label_1836: // Incoming jump from 0x1835, if not !stack[-1] // Inputs[6] // { // @1838 stack[-2] // @183A stack[-1] // @183C msg.data.length // @183E msg.data[msg.data.length:msg.data.length + stack[-1]] // @1844 stack[-3] // @1847 stack[-7] // } 1836 60 PUSH1 0x20 1838 82 DUP3 1839 01 ADD 183A 81 DUP2 183B 80 DUP1 183C 36 CALLDATASIZE 183D 83 DUP4 183E 37 CALLDATACOPY 183F 01 ADD 1840 90 SWAP1 1841 50 POP 1842 5B JUMPDEST 1843 50 POP 1844 90 SWAP1 1845 50 POP 1846 5B JUMPDEST 1847 84 DUP5 1848 15 ISZERO 1849 61 PUSH2 0x178b 184C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @183E memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1844 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x178b, if !stack[-7] label_184D: // Incoming jump from 0x184C, if not !stack[-7] // Incoming jump from 0x184C, if not !stack[-5] // Incoming jump from 0x184C, if not !stack[-7] // Inputs[1] { @1852 stack[-2] } 184D 61 PUSH2 0x1857 1850 60 PUSH1 0x01 1852 83 DUP4 1853 61 PUSH2 0x267b 1856 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @184D stack[0] = 0x1857 // @1850 stack[1] = 0x01 // @1852 stack[2] = stack[-2] // } // Block ends with call to 0x267b, returns to 0x1857 label_1857: // Incoming return from call to 0x267B at 0x1856 // Inputs[3] // { // @1858 stack[-3] // @1858 stack[-1] // @185F stack[-6] // } 1857 5B JUMPDEST 1858 91 SWAP2 1859 50 POP 185A 61 PUSH2 0x1864 185D 60 PUSH1 0x0a 185F 86 DUP7 1860 61 PUSH2 0x2692 1863 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1858 stack[-3] = stack[-1] // @185A stack[-1] = 0x1864 // @185D stack[0] = 0x0a // @185F stack[1] = stack[-6] // } // Block ends with call to 0x2692, returns to 0x1864 label_1864: // Incoming return from call to 0x2692 at 0x1863 // Inputs[1] { @1868 stack[-1] } 1864 5B JUMPDEST 1865 61 PUSH2 0x186f 1868 90 SWAP1 1869 60 PUSH1 0x30 186B 61 PUSH2 0x26a6 186E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1868 stack[0] = stack[-1] // @1868 stack[-1] = 0x186f // @1869 stack[1] = 0x30 // } // Block ends with call to 0x26a6, returns to 0x186F label_186F: // Incoming return from call to 0x26A6 at 0x186E // Inputs[4] // { // @1872 stack[-1] // @1873 stack[-2] // @1874 stack[-3] // @1876 memory[stack[-2]:stack[-2] + 0x20] // } 186F 5B JUMPDEST 1870 60 PUSH1 0xf8 1872 1B SHL 1873 81 DUP2 1874 83 DUP4 1875 81 DUP2 1876 51 MLOAD 1877 81 DUP2 1878 10 LT 1879 61 PUSH2 0x1884 187C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1872 stack[-1] = stack[-1] << 0xf8 // @1873 stack[0] = stack[-2] // @1874 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1884, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_187D: // Incoming jump from 0x187C, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 187D 61 PUSH2 0x1884 1880 61 PUSH2 0x24ee 1883 56 *JUMP // Stack delta = +1 // Outputs[1] { @187D stack[0] = 0x1884 } // Block ends with unconditional jump to 0x24ee label_1884: // Incoming jump from 0x187C, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1887 stack[-1] // @1888 stack[-2] // @1889 stack[-3] // @18B9 stack[-8] // } 1884 5B JUMPDEST 1885 60 PUSH1 0x20 1887 01 ADD 1888 01 ADD 1889 90 SWAP1 188A 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 18AA 19 NOT 18AB 16 AND 18AC 90 SWAP1 18AD 81 DUP2 18AE 60 PUSH1 0x00 18B0 1A BYTE 18B1 90 SWAP1 18B2 53 MSTORE8 18B3 50 POP 18B4 61 PUSH2 0x18be 18B7 60 PUSH1 0x0a 18B9 86 DUP7 18BA 61 PUSH2 0x2667 18BD 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @18B2 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @18B4 stack[-3] = 0x18be // @18B7 stack[-2] = 0x0a // @18B9 stack[-1] = stack[-8] // } // Block ends with call to 0x2667, returns to 0x18BE label_18BE: // Incoming return from call to 0x2667 at 0x18BD // Inputs[2] // { // @18BF stack[-6] // @18BF stack[-1] // } 18BE 5B JUMPDEST 18BF 94 SWAP5 18C0 50 POP 18C1 61 PUSH2 0x1846 18C4 56 *JUMP // Stack delta = -1 // Outputs[1] { @18BF stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1846 label_18C5: // Incoming call from 0x11C2, returns to 0x11C3 // Inputs[1] { @18C8 stack[-2] } 18C5 5B JUMPDEST 18C6 60 PUSH1 0x00 18C8 82 DUP3 18C9 15 ISZERO 18CA 80 DUP1 18CB 15 ISZERO 18CC 61 PUSH2 0x18d2 18CF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18C6 stack[0] = 0x00 // @18C9 stack[1] = !stack[-2] // } // Block ends with conditional jump to 0x18d2, if !!stack[-2] label_18D0: // Incoming jump from 0x18CF, if not !!stack[-2] // Inputs[1] { @18D1 stack[-5] } 18D0 50 POP 18D1 83 DUP4 18D2 5B JUMPDEST 18D3 15 ISZERO 18D4 61 PUSH2 0x18fb 18D7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18fb, if !stack[-5] label_18D8: // Incoming jump from 0x18D7, if not !stack[-1] // Incoming jump from 0x18D7, if not !stack[-5] // Inputs[1] { @18E5 stack[-2] } 18D8 66 PUSH7 0xd529ae9e860000 18E0 61 PUSH2 0x18ea 18E3 60 PUSH1 0x01 18E5 84 DUP5 18E6 61 PUSH2 0x267b 18E9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18D8 stack[0] = 0xd529ae9e860000 // @18E0 stack[1] = 0x18ea // @18E3 stack[2] = 0x01 // @18E5 stack[3] = stack[-2] // } // Block ends with call to 0x267b, returns to 0x18EA label_18EA: // Incoming return from call to 0x267B at 0x18E9 // Inputs[2] // { // @18EE stack[-2] // @18EF stack[-1] // } 18EA 5B JUMPDEST 18EB 61 PUSH2 0x18f4 18EE 91 SWAP2 18EF 90 SWAP1 18F0 61 PUSH2 0x26be 18F3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @18EE stack[-2] = 0x18f4 // @18EF stack[-1] = stack[-2] // @18EF stack[0] = stack[-1] // } // Block ends with call to 0x26be, returns to 0x18F4 label_18F4: // Incoming return from call to 0x26BE at 0x18F3 // Inputs[2] // { // @18F5 stack[-1] // @18F5 stack[-2] // } 18F4 5B JUMPDEST 18F5 90 SWAP1 18F6 50 POP 18F7 61 PUSH2 0x190f 18FA 56 *JUMP // Stack delta = -1 // Outputs[1] { @18F5 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x190f label_18FB: // Incoming jump from 0x18D7, if !stack[-1] // Incoming jump from 0x18D7, if !stack[-5] // Inputs[1] { @1907 stack[-2] } 18FB 5B JUMPDEST 18FC 61 PUSH2 0x190c 18FF 66 PUSH7 0xd529ae9e860000 1907 83 DUP4 1908 61 PUSH2 0x26be 190B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18FC stack[0] = 0x190c // @18FF stack[1] = 0xd529ae9e860000 // @1907 stack[2] = stack[-2] // } // Block ends with call to 0x26be, returns to 0x190C label_190C: // Incoming return from call to 0x26BE at 0x190B // Inputs[2] // { // @190D stack[-1] // @190D stack[-2] // } 190C 5B JUMPDEST 190D 90 SWAP1 190E 50 POP // Stack delta = -1 // Outputs[1] { @190D stack[-2] = stack[-1] } // Block continues label_190F: // Incoming return from call to 0x2045 at 0x2077 // Incoming jump from 0x18FA // Incoming return from call to 0x2321 at 0x244A // Incoming return from call to 0x20FC at 0x226F // Incoming return from call to 0x20A4 at 0x20E2 // Incoming return from call to 0x2045 at 0x261F // Incoming return from call to 0x2194 at 0x238A // Incoming jump from 0x190E // Inputs[3] // { // @1910 stack[-5] // @1910 stack[-1] // @1911 stack[-4] // } 190F 5B JUMPDEST 1910 93 SWAP4 1911 92 SWAP3 1912 50 POP 1913 50 POP 1914 50 POP 1915 56 *JUMP // Stack delta = -4 // Outputs[1] { @1910 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1916: // Incoming call from 0x1209, returns to 0x120A // Inputs[11] // { // @191A memory[0x40:0x60] // @1929 msg.sender // @1937 stack[-3] // @1944 stack[-2] // @194F memory[0x40:0x60] // @195F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1963 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1993 memory[0x40:0x60] // @19A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @19A8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @19AF stack[-1] // } 1916 5B JUMPDEST 1917 60 PUSH1 0x40 1919 80 DUP1 191A 51 MLOAD 191B 6B PUSH12 0xffffffffffffffffffffffff 1928 19 NOT 1929 33 CALLER 192A 60 PUSH1 0x60 192C 1B SHL 192D 16 AND 192E 60 PUSH1 0x20 1930 80 DUP1 1931 83 DUP4 1932 01 ADD 1933 91 SWAP2 1934 90 SWAP1 1935 91 SWAP2 1936 52 MSTORE 1937 85 DUP6 1938 15 ISZERO 1939 15 ISZERO 193A 60 PUSH1 0xf8 193C 90 SWAP1 193D 81 DUP2 193E 1B SHL 193F 60 PUSH1 0x34 1941 84 DUP5 1942 01 ADD 1943 52 MSTORE 1944 85 DUP6 1945 15 ISZERO 1946 15 ISZERO 1947 90 SWAP1 1948 1B SHL 1949 60 PUSH1 0x35 194B 83 DUP4 194C 01 ADD 194D 52 MSTORE 194E 82 DUP3 194F 51 MLOAD 1950 80 DUP1 1951 83 DUP4 1952 03 SUB 1953 60 PUSH1 0x16 1955 01 ADD 1956 81 DUP2 1957 52 MSTORE 1958 60 PUSH1 0x36 195A 83 DUP4 195B 01 ADD 195C 84 DUP5 195D 52 MSTORE 195E 80 DUP1 195F 51 MLOAD 1960 90 SWAP1 1961 82 DUP3 1962 01 ADD 1963 20 SHA3 1964 7F PUSH32 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 1985 60 PUSH1 0x56 1987 84 DUP5 1988 01 ADD 1989 52 MSTORE 198A 60 PUSH1 0x72 198C 80 DUP1 198D 84 DUP5 198E 01 ADD 198F 82 DUP3 1990 90 SWAP1 1991 52 MSTORE 1992 84 DUP5 1993 51 MLOAD 1994 80 DUP1 1995 85 DUP6 1996 03 SUB 1997 90 SWAP1 1998 91 SWAP2 1999 01 ADD 199A 81 DUP2 199B 52 MSTORE 199C 60 PUSH1 0x92 199E 90 SWAP1 199F 93 SWAP4 19A0 01 ADD 19A1 90 SWAP1 19A2 93 SWAP4 19A3 52 MSTORE 19A4 81 DUP2 19A5 51 MLOAD 19A6 91 SWAP2 19A7 01 ADD 19A8 20 SHA3 19A9 60 PUSH1 0x00 19AB 61 PUSH2 0x19b4 19AE 82 DUP3 19AF 85 DUP6 19B0 61 PUSH2 0x1a0b 19B3 56 *JUMP // Stack delta = +6 // Outputs[15] // { // @1936 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @1943 memory[memory[0x40:0x60] + 0x34:memory[0x40:0x60] + 0x34 + 0x20] = !!stack[-3] << 0xf8 // @194D memory[memory[0x40:0x60] + 0x35:memory[0x40:0x60] + 0x35 + 0x20] = !!stack[-2] << 0xf8 // @1957 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x16 + (memory[0x40:0x60] - memory[0x40:0x60]) // @195D memory[0x40:0x60] = memory[0x40:0x60] + 0x36 // @1989 memory[memory[0x40:0x60] + 0x56:memory[0x40:0x60] + 0x56 + 0x20] = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 // @1991 memory[memory[0x40:0x60] + 0x72:memory[0x40:0x60] + 0x72 + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @199B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x72 + (memory[0x40:0x60] - memory[0x40:0x60]) // @19A2 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @19A3 memory[0x40:0x60] = memory[0x40:0x60] + 0x92 // @19A8 stack[1] = keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @19A9 stack[2] = 0x00 // @19AB stack[3] = 0x19b4 // @19AE stack[4] = keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @19AF stack[5] = stack[-1] // } // Block ends with call to 0x1a0b, returns to 0x19B4 label_19B4: // Incoming return from call to 0x1A0B at 0x19B3 // Inputs[3] // { // @19B7 storage[0x0a] // @19B8 stack[-1] // @19B9 stack[-2] // } 19B4 5B JUMPDEST 19B5 60 PUSH1 0x0a 19B7 54 SLOAD 19B8 90 SWAP1 19B9 91 SWAP2 19BA 50 POP 19BB 60 PUSH1 0x01 19BD 60 PUSH1 0x01 19BF 60 PUSH1 0xa0 19C1 1B SHL 19C2 03 SUB 19C3 80 DUP1 19C4 83 DUP4 19C5 16 AND 19C6 91 SWAP2 19C7 16 AND 19C8 14 EQ 19C9 61 PUSH2 0x0ba5 19CC 57 *JUMPI // Stack delta = -1 // Outputs[1] { @19B9 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0ba5, if storage[0x0a] & (0x01 << 0xa0) - 0x01 == stack[-1] & (0x01 << 0xa0) - 0x01 label_19CD: // Incoming jump from 0x19CC, if not storage[0x0a] & (0x01 << 0xa0) - 0x01 == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @19CF memory[0x40:0x60] // @19F8 memory[0x40:0x60] // @19FD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19CD 60 PUSH1 0x40 19CF 51 MLOAD 19D0 7F PUSH32 0x1f3e0de800000000000000000000000000000000000000000000000000000000 19F1 81 DUP2 19F2 52 MSTORE 19F3 60 PUSH1 0x04 19F5 01 ADD 19F6 60 PUSH1 0x40 19F8 51 MLOAD 19F9 80 DUP1 19FA 91 SWAP2 19FB 03 SUB 19FC 90 SWAP1 19FD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1f3e0de800000000000000000000000000000000000000000000000000000000 // @19FD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19FE: // Incoming call from 0x1506, returns to 0x0A50 // Inputs[3] // { // @1A02 stack[-3] // @1A03 stack[-2] // @1A04 stack[-1] // } 19FE 5B JUMPDEST 19FF 61 PUSH2 0x082a 1A02 83 DUP4 1A03 83 DUP4 1A04 83 DUP4 1A05 60 PUSH1 0x01 1A07 61 PUSH2 0x1a2f 1A0A 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @19FF stack[0] = 0x082a // @1A02 stack[1] = stack[-3] // @1A03 stack[2] = stack[-2] // @1A04 stack[3] = stack[-1] // @1A05 stack[4] = 0x01 // } // Block ends with call to 0x1a2f, returns to 0x082A label_1A0B: // Incoming call from 0x19B3, returns to 0x19B4 // Inputs[2] // { // @1A14 stack[-2] // @1A15 stack[-1] // } 1A0B 5B JUMPDEST 1A0C 60 PUSH1 0x00 1A0E 80 DUP1 1A0F 60 PUSH1 0x00 1A11 61 PUSH2 0x1a1a 1A14 85 DUP6 1A15 85 DUP6 1A16 61 PUSH2 0x1c42 1A19 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1A0C stack[0] = 0x00 // @1A0E stack[1] = 0x00 // @1A0F stack[2] = 0x00 // @1A11 stack[3] = 0x1a1a // @1A14 stack[4] = stack[-2] // @1A15 stack[5] = stack[-1] // } // Block ends with call to 0x1c42, returns to 0x1A1A label_1A1A: // Incoming return from call to 0x1C42 at 0x1A19 // Inputs[4] // { // @1A1B stack[-1] // @1A1B stack[-3] // @1A1D stack[-2] // @1A1D stack[-4] // } 1A1A 5B JUMPDEST 1A1B 91 SWAP2 1A1C 50 POP 1A1D 91 SWAP2 1A1E 50 POP 1A1F 61 PUSH2 0x1a27 1A22 81 DUP2 1A23 61 PUSH2 0x1cb2 1A26 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1A1B stack[-3] = stack[-1] // @1A1D stack[-4] = stack[-2] // @1A1F stack[-2] = 0x1a27 // @1A22 stack[-1] = stack[-1] // } // Block ends with call to 0x1cb2, returns to 0x1A27 label_1A27: // Incoming return from call to 0x1CB2 at 0x1A26 // Inputs[3] // { // @1A29 stack[-6] // @1A29 stack[-2] // @1A2A stack[-5] // } 1A27 5B JUMPDEST 1A28 50 POP 1A29 93 SWAP4 1A2A 92 SWAP3 1A2B 50 POP 1A2C 50 POP 1A2D 50 POP 1A2E 56 *JUMP // Stack delta = -5 // Outputs[1] { @1A29 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1A2F: // Incoming call from 0x1A0A, returns to 0x082A // Inputs[2] // { // @1A32 storage[0x00] // @1A3B stack[-4] // } 1A2F 5B JUMPDEST 1A30 60 PUSH1 0x00 1A32 54 SLOAD 1A33 60 PUSH1 0x01 1A35 60 PUSH1 0x01 1A37 60 PUSH1 0xa0 1A39 1B SHL 1A3A 03 SUB 1A3B 85 DUP6 1A3C 16 AND 1A3D 61 PUSH2 0x1a72 1A40 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A32 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1a72, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1A41: // Incoming jump from 0x1A40, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1A43 memory[0x40:0x60] // @1A6C memory[0x40:0x60] // @1A71 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A41 60 PUSH1 0x40 1A43 51 MLOAD 1A44 7F PUSH32 0x2e07630000000000000000000000000000000000000000000000000000000000 1A65 81 DUP2 1A66 52 MSTORE 1A67 60 PUSH1 0x04 1A69 01 ADD 1A6A 60 PUSH1 0x40 1A6C 51 MLOAD 1A6D 80 DUP1 1A6E 91 SWAP2 1A6F 03 SUB 1A70 90 SWAP1 1A71 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A66 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000 // @1A71 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A72: // Incoming jump from 0x1A40, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A73 stack[-4] } 1A72 5B JUMPDEST 1A73 83 DUP4 1A74 61 PUSH2 0x1aa9 1A77 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1aa9, if stack[-4] label_1A78: // Incoming jump from 0x1A77, if not stack[-4] // Inputs[3] // { // @1A7A memory[0x40:0x60] // @1AA3 memory[0x40:0x60] // @1AA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A78 60 PUSH1 0x40 1A7A 51 MLOAD 1A7B 7F PUSH32 0xb562e8dd00000000000000000000000000000000000000000000000000000000 1A9C 81 DUP2 1A9D 52 MSTORE 1A9E 60 PUSH1 0x04 1AA0 01 ADD 1AA1 60 PUSH1 0x40 1AA3 51 MLOAD 1AA4 80 DUP1 1AA5 91 SWAP2 1AA6 03 SUB 1AA7 90 SWAP1 1AA8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000 // @1AA8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AA9: // Incoming jump from 0x1A77, if stack[-4] // Inputs[9] // { // @1AB2 stack[-5] // @1AC4 memory[0x00:0x40] // @1AC6 storage[keccak256(memory[0x00:0x40])] // @1AF6 stack[-4] // @1B27 stack[-1] // @1B31 memory[0x00:0x40] // @1B33 storage[keccak256(memory[0x00:0x40])] // @1B46 block.timestamp // @1B55 stack[-2] // } 1AA9 5B JUMPDEST 1AAA 60 PUSH1 0x01 1AAC 60 PUSH1 0x01 1AAE 60 PUSH1 0xa0 1AB0 1B SHL 1AB1 03 SUB 1AB2 85 DUP6 1AB3 16 AND 1AB4 60 PUSH1 0x00 1AB6 81 DUP2 1AB7 81 DUP2 1AB8 52 MSTORE 1AB9 60 PUSH1 0x05 1ABB 60 PUSH1 0x20 1ABD 90 SWAP1 1ABE 81 DUP2 1ABF 52 MSTORE 1AC0 60 PUSH1 0x40 1AC2 80 DUP1 1AC3 83 DUP4 1AC4 20 SHA3 1AC5 80 DUP1 1AC6 54 SLOAD 1AC7 7F PUSH32 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 1AE8 81 DUP2 1AE9 16 AND 1AEA 67 PUSH8 0xffffffffffffffff 1AF3 80 DUP1 1AF4 83 DUP4 1AF5 16 AND 1AF6 8C DUP13 1AF7 01 ADD 1AF8 81 DUP2 1AF9 16 AND 1AFA 91 SWAP2 1AFB 82 DUP3 1AFC 17 OR 1AFD 68 PUSH9 0x010000000000000000 1B07 67 PUSH8 0xffffffffffffffff 1B10 19 NOT 1B11 90 SWAP1 1B12 94 SWAP5 1B13 16 AND 1B14 90 SWAP1 1B15 92 SWAP3 1B16 17 OR 1B17 83 DUP4 1B18 90 SWAP1 1B19 04 DIV 1B1A 81 DUP2 1B1B 16 AND 1B1C 8C DUP13 1B1D 01 ADD 1B1E 81 DUP2 1B1F 16 AND 1B20 90 SWAP1 1B21 92 SWAP3 1B22 02 MUL 1B23 17 OR 1B24 90 SWAP1 1B25 91 SWAP2 1B26 55 SSTORE 1B27 85 DUP6 1B28 84 DUP5 1B29 52 MSTORE 1B2A 60 PUSH1 0x04 1B2C 90 SWAP1 1B2D 92 SWAP3 1B2E 52 MSTORE 1B2F 90 SWAP1 1B30 91 SWAP2 1B31 20 SHA3 1B32 80 DUP1 1B33 54 SLOAD 1B34 60 PUSH1 0x01 1B36 60 PUSH1 0x01 1B38 60 PUSH1 0xe0 1B3A 1B SHL 1B3B 03 SUB 1B3C 19 NOT 1B3D 16 AND 1B3E 90 SWAP1 1B3F 92 SWAP3 1B40 17 OR 1B41 60 PUSH1 0x01 1B43 60 PUSH1 0xa0 1B45 1B SHL 1B46 42 TIMESTAMP 1B47 90 SWAP1 1B48 92 SWAP3 1B49 16 AND 1B4A 91 SWAP2 1B4B 90 SWAP1 1B4C 91 SWAP2 1B4D 02 MUL 1B4E 17 OR 1B4F 90 SWAP1 1B50 55 SSTORE 1B51 80 DUP1 1B52 80 DUP1 1B53 85 DUP6 1B54 01 ADD 1B55 83 DUP4 1B56 80 DUP1 1B57 15 ISZERO 1B58 61 PUSH2 0x1b6a 1B5B 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1AB8 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1ABF memory[0x20:0x40] = 0x05 // @1B26 storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * (0xffffffffffffffff & stack[-4] + (0xffffffffffffffff & ((0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | (0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000) // @1B29 memory[0x00:0x20] = stack[-1] // @1B2E memory[0x20:0x40] = 0x04 // @1B50 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1B51 stack[0] = stack[-1] // @1B54 stack[1] = stack[-4] + stack[-1] // @1B55 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1b6a, if !stack[-2] label_1B5C: // Incoming jump from 0x1B5B, if not !stack[-2] // Inputs[2] // { // @1B65 stack[-8] // @1B67 address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1B5C 50 POP 1B5D 60 PUSH1 0x01 1B5F 60 PUSH1 0x01 1B61 60 PUSH1 0xa0 1B63 1B SHL 1B64 03 SUB 1B65 87 DUP8 1B66 16 AND 1B67 3B EXTCODESIZE 1B68 15 ISZERO 1B69 15 ISZERO 1B6A 5B JUMPDEST 1B6B 15 ISZERO 1B6C 61 PUSH2 0x1bf3 1B6F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1bf3, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1B70: // Incoming jump from 0x1B6F, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1B6F, if not !stack[-1] // Inputs[5] // { // @1B73 memory[0x40:0x60] // @1B74 stack[-2] // @1B7E stack[-7] // @1BA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1BB6 stack[-5] // } 1B70 5B JUMPDEST 1B71 60 PUSH1 0x40 1B73 51 MLOAD 1B74 82 DUP3 1B75 90 SWAP1 1B76 60 PUSH1 0x01 1B78 60 PUSH1 0x01 1B7A 60 PUSH1 0xa0 1B7C 1B SHL 1B7D 03 SUB 1B7E 89 DUP10 1B7F 16 AND 1B80 90 SWAP1 1B81 60 PUSH1 0x00 1B83 90 SWAP1 1B84 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1BA5 90 SWAP1 1BA6 82 DUP3 1BA7 90 SWAP1 1BA8 A4 LOG4 1BA9 61 PUSH2 0x1bbb 1BAC 60 PUSH1 0x00 1BAE 88 DUP9 1BAF 84 DUP5 1BB0 80 DUP1 1BB1 60 PUSH1 0x01 1BB3 01 ADD 1BB4 95 SWAP6 1BB5 50 POP 1BB6 88 DUP9 1BB7 61 PUSH2 0x169b 1BBA 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1BA8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1BA9 stack[0] = 0x1bbb // @1BAC stack[1] = 0x00 // @1BAE stack[2] = stack[-7] // @1BAF stack[3] = stack[-2] // @1BB4 stack[-2] = 0x01 + stack[-2] // @1BB6 stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x169b 1BBB 5B JUMPDEST 1BBC 61 PUSH2 0x1bd8 1BBF 57 *JUMPI 1BC0 60 PUSH1 0x40 1BC2 51 MLOAD 1BC3 63 PUSH4 0x68d2bf6b 1BC8 60 PUSH1 0xe1 1BCA 1B SHL 1BCB 81 DUP2 1BCC 52 MSTORE 1BCD 60 PUSH1 0x04 1BCF 01 ADD 1BD0 60 PUSH1 0x40 1BD2 51 MLOAD 1BD3 80 DUP1 1BD4 91 SWAP2 1BD5 03 SUB 1BD6 90 SWAP1 1BD7 FD *REVERT 1BD8 5B JUMPDEST 1BD9 80 DUP1 1BDA 82 DUP3 1BDB 14 EQ 1BDC 15 ISZERO 1BDD 61 PUSH2 0x1b70 1BE0 57 *JUMPI 1BE1 82 DUP3 1BE2 60 PUSH1 0x00 1BE4 54 SLOAD 1BE5 14 EQ 1BE6 61 PUSH2 0x1bee 1BE9 57 *JUMPI 1BEA 60 PUSH1 0x00 1BEC 80 DUP1 1BED FD *REVERT 1BEE 5B JUMPDEST 1BEF 61 PUSH2 0x1c39 1BF2 56 *JUMP label_1BF3: // Incoming jump from 0x1B6F, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1B6F, if !stack[-1] // Inputs[5] // { // @1BF7 memory[0x40:0x60] // @1BFA stack[-2] // @1C06 stack[-7] // @1C30 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1C31 stack[-1] // } 1BF3 5B JUMPDEST 1BF4 5B JUMPDEST 1BF5 60 PUSH1 0x40 1BF7 51 MLOAD 1BF8 60 PUSH1 0x01 1BFA 83 DUP4 1BFB 01 ADD 1BFC 92 SWAP3 1BFD 90 SWAP1 1BFE 60 PUSH1 0x01 1C00 60 PUSH1 0x01 1C02 60 PUSH1 0xa0 1C04 1B SHL 1C05 03 SUB 1C06 89 DUP10 1C07 16 AND 1C08 90 SWAP1 1C09 60 PUSH1 0x00 1C0B 90 SWAP1 1C0C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1C2D 90 SWAP1 1C2E 82 DUP3 1C2F 90 SWAP1 1C30 A4 LOG4 1C31 80 DUP1 1C32 82 DUP3 1C33 14 EQ 1C34 15 ISZERO 1C35 61 PUSH2 0x1bf4 1C38 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BFC stack[-2] = stack[-2] + 0x01 // @1C30 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1bf4, if !(stack[-2] + 0x01 == stack[-1]) label_1C39: // Incoming jump from 0x1C38, if not !(stack[-2] + 0x01 == stack[-1]) // Incoming jump from 0x1C38, if not !(stack[-2] + 0x01 == stack[-1]) // Inputs[1] { @1C3D stack[-2] } 1C39 5B JUMPDEST 1C3A 50 POP 1C3B 60 PUSH1 0x00 1C3D 55 SSTORE 1C3E 61 PUSH2 0x14e6 1C41 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C3D storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x14e6 label_1C42: // Incoming call from 0x1A19, returns to 0x1A1A // Inputs[2] // { // @1C46 stack[-1] // @1C47 memory[stack[-1]:stack[-1] + 0x20] // } 1C42 5B JUMPDEST 1C43 60 PUSH1 0x00 1C45 80 DUP1 1C46 82 DUP3 1C47 51 MLOAD 1C48 60 PUSH1 0x41 1C4A 14 EQ 1C4B 15 ISZERO 1C4C 61 PUSH2 0x1c79 1C4F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C43 stack[0] = 0x00 // @1C45 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c79, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) label_1C50: // Incoming jump from 0x1C4F, if not !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @1C52 stack[-3] // @1C54 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1C59 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @1C5E memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @1C65 stack[-4] // } 1C50 60 PUSH1 0x20 1C52 83 DUP4 1C53 01 ADD 1C54 51 MLOAD 1C55 60 PUSH1 0x40 1C57 84 DUP5 1C58 01 ADD 1C59 51 MLOAD 1C5A 60 PUSH1 0x60 1C5C 85 DUP6 1C5D 01 ADD 1C5E 51 MLOAD 1C5F 60 PUSH1 0x00 1C61 1A BYTE 1C62 61 PUSH2 0x1c6d 1C65 87 DUP8 1C66 82 DUP3 1C67 85 DUP6 1C68 85 DUP6 1C69 61 PUSH2 0x1e6d 1C6C 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @1C54 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1C59 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @1C61 stack[2] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @1C62 stack[3] = 0x1c6d // @1C65 stack[4] = stack[-4] // @1C66 stack[5] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @1C67 stack[6] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1C68 stack[7] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x1e6d, returns to 0x1C6D label_1C6D: // Incoming return from call to 0x1E6D at 0x1C6C // Inputs[4] // { // @1C6E stack[-1] // @1C6E stack[-6] // @1C70 stack[-2] // @1C70 stack[-7] // } 1C6D 5B JUMPDEST 1C6E 94 SWAP5 1C6F 50 POP 1C70 94 SWAP5 1C71 50 POP 1C72 50 POP 1C73 50 POP 1C74 50 POP 1C75 61 PUSH2 0x1cab 1C78 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1C6E stack[-6] = stack[-1] // @1C70 stack[-7] = stack[-2] // } // Block ends with unconditional jump to 0x1cab label_1C79: // Incoming jump from 0x1C4F, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @1C7A stack[-3] // @1C7B memory[stack[-3]:stack[-3] + 0x20] // } 1C79 5B JUMPDEST 1C7A 82 DUP3 1C7B 51 MLOAD 1C7C 60 PUSH1 0x40 1C7E 14 EQ 1C7F 15 ISZERO 1C80 61 PUSH2 0x1ca3 1C83 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ca3, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) label_1C84: // Incoming jump from 0x1C83, if not !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @1C86 stack[-3] // @1C88 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1C8D memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @1C91 stack[-4] // } 1C84 60 PUSH1 0x20 1C86 83 DUP4 1C87 01 ADD 1C88 51 MLOAD 1C89 60 PUSH1 0x40 1C8B 84 DUP5 1C8C 01 ADD 1C8D 51 MLOAD 1C8E 61 PUSH2 0x1c98 1C91 86 DUP7 1C92 83 DUP4 1C93 83 DUP4 1C94 61 PUSH2 0x1f5a 1C97 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1C88 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1C8D stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @1C8E stack[2] = 0x1c98 // @1C91 stack[3] = stack[-4] // @1C92 stack[4] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1C93 stack[5] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x1f5a, returns to 0x1C98 label_1C98: // Incoming return from call to 0x1F5A at 0x1C97 // Inputs[4] // { // @1C99 stack[-5] // @1C99 stack[-1] // @1C9B stack[-6] // @1C9B stack[-2] // } 1C98 5B JUMPDEST 1C99 93 SWAP4 1C9A 50 POP 1C9B 93 SWAP4 1C9C 50 POP 1C9D 50 POP 1C9E 50 POP 1C9F 61 PUSH2 0x1cab 1CA2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1C99 stack[-5] = stack[-1] // @1C9B stack[-6] = stack[-2] // } // Block ends with unconditional jump to 0x1cab label_1CA3: // Incoming jump from 0x1C83, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[1] { @1CA7 stack[-2] } 1CA3 5B JUMPDEST 1CA4 50 POP 1CA5 60 PUSH1 0x00 1CA7 90 SWAP1 1CA8 50 POP 1CA9 60 PUSH1 0x02 // Stack delta = +0 // Outputs[2] // { // @1CA7 stack[-2] = 0x00 // @1CA9 stack[-1] = 0x02 // } // Block continues label_1CAB: // Incoming jump from 0x1CA2 // Incoming jump from 0x22B0, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Incoming jump from 0x1C78 // Incoming jump from 0x1CA9 // Inputs[5] // { // @1CAC stack[-4] // @1CAC stack[-1] // @1CAE stack[-2] // @1CAE stack[-5] // @1CAF stack[-3] // } 1CAB 5B JUMPDEST 1CAC 92 SWAP3 1CAD 50 POP 1CAE 92 SWAP3 1CAF 90 SWAP1 1CB0 50 POP 1CB1 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1CAC stack[-4] = stack[-1] // @1CAE stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_1CB2: // Incoming call from 0x1A26, returns to 0x1A27 // Inputs[1] { @1CB5 stack[-1] } 1CB2 5B JUMPDEST 1CB3 60 PUSH1 0x00 1CB5 81 DUP2 1CB6 60 PUSH1 0x04 1CB8 81 DUP2 1CB9 11 GT 1CBA 15 ISZERO 1CBB 61 PUSH2 0x1cc6 1CBE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CB3 stack[0] = 0x00 // @1CB5 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1cc6, if !(stack[-1] > 0x04) label_1CBF: // Incoming jump from 0x1CBE, if not !(stack[-1] > 0x04) 1CBF 61 PUSH2 0x1cc6 1CC2 61 PUSH2 0x26dd 1CC5 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CBF stack[0] = 0x1cc6 } // Block ends with unconditional jump to 0x26dd label_1CC6: // Incoming jump from 0x1CBE, if !(stack[-1] > 0x04) // Inputs[2] // { // @1CC7 stack[-1] // @1CC7 stack[-2] // } 1CC6 5B JUMPDEST 1CC7 14 EQ 1CC8 15 ISZERO 1CC9 61 PUSH2 0x1ccf 1CCC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1ccf, if !(stack[-1] == stack[-2]) label_1CCD: // Incoming jump from 0x1CCC, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1CCE stack[-2] } 1CCD 50 POP 1CCE 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1CCF: // Incoming jump from 0x1CCC, if !(stack[-1] == stack[-2]) // Inputs[1] { @1CD2 stack[-1] } 1CCF 5B JUMPDEST 1CD0 60 PUSH1 0x01 1CD2 81 DUP2 1CD3 60 PUSH1 0x04 1CD5 81 DUP2 1CD6 11 GT 1CD7 15 ISZERO 1CD8 61 PUSH2 0x1ce3 1CDB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CD0 stack[0] = 0x01 // @1CD2 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1ce3, if !(stack[-1] > 0x04) label_1CDC: // Incoming jump from 0x1CDB, if not !(stack[-1] > 0x04) 1CDC 61 PUSH2 0x1ce3 1CDF 61 PUSH2 0x26dd 1CE2 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CDC stack[0] = 0x1ce3 } // Block ends with unconditional jump to 0x26dd label_1CE3: // Incoming jump from 0x1CDB, if !(stack[-1] > 0x04) // Inputs[2] // { // @1CE4 stack[-2] // @1CE4 stack[-1] // } 1CE3 5B JUMPDEST 1CE4 14 EQ 1CE5 15 ISZERO 1CE6 61 PUSH2 0x1d31 1CE9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1d31, if !(stack[-1] == stack[-2]) label_1CEA: // Incoming jump from 0x1CE9, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1CEC memory[0x40:0x60] } 1CEA 60 PUSH1 0x40 1CEC 51 MLOAD 1CED 62 PUSH3 0x461bcd 1CF1 60 PUSH1 0xe5 1CF3 1B SHL 1CF4 81 DUP2 1CF5 52 MSTORE 1CF6 60 PUSH1 0x20 1CF8 60 PUSH1 0x04 1CFA 82 DUP3 1CFB 01 ADD 1CFC 52 MSTORE 1CFD 60 PUSH1 0x18 1CFF 60 PUSH1 0x24 1D01 82 DUP3 1D02 01 ADD 1D03 52 MSTORE 1D04 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 1D25 60 PUSH1 0x44 1D27 82 DUP3 1D28 01 ADD 1D29 52 MSTORE 1D2A 60 PUSH1 0x64 1D2C 01 ADD 1D2D 61 PUSH2 0x0890 1D30 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1CF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1CFC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D03 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @1D29 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 // @1D2C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_1D31: // Incoming jump from 0x1CE9, if !(stack[-1] == stack[-2]) // Inputs[1] { @1D34 stack[-1] } 1D31 5B JUMPDEST 1D32 60 PUSH1 0x02 1D34 81 DUP2 1D35 60 PUSH1 0x04 1D37 81 DUP2 1D38 11 GT 1D39 15 ISZERO 1D3A 61 PUSH2 0x1d45 1D3D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D32 stack[0] = 0x02 // @1D34 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1d45, if !(stack[-1] > 0x04) label_1D3E: // Incoming jump from 0x1D3D, if not !(stack[-1] > 0x04) 1D3E 61 PUSH2 0x1d45 1D41 61 PUSH2 0x26dd 1D44 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D3E stack[0] = 0x1d45 } // Block ends with unconditional jump to 0x26dd label_1D45: // Incoming jump from 0x1D3D, if !(stack[-1] > 0x04) // Inputs[2] // { // @1D46 stack[-2] // @1D46 stack[-1] // } 1D45 5B JUMPDEST 1D46 14 EQ 1D47 15 ISZERO 1D48 61 PUSH2 0x1d93 1D4B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1d93, if !(stack[-1] == stack[-2]) label_1D4C: // Incoming jump from 0x1D4B, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1D4E memory[0x40:0x60] } 1D4C 60 PUSH1 0x40 1D4E 51 MLOAD 1D4F 62 PUSH3 0x461bcd 1D53 60 PUSH1 0xe5 1D55 1B SHL 1D56 81 DUP2 1D57 52 MSTORE 1D58 60 PUSH1 0x20 1D5A 60 PUSH1 0x04 1D5C 82 DUP3 1D5D 01 ADD 1D5E 52 MSTORE 1D5F 60 PUSH1 0x1f 1D61 60 PUSH1 0x24 1D63 82 DUP3 1D64 01 ADD 1D65 52 MSTORE 1D66 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 1D87 60 PUSH1 0x44 1D89 82 DUP3 1D8A 01 ADD 1D8B 52 MSTORE 1D8C 60 PUSH1 0x64 1D8E 01 ADD 1D8F 61 PUSH2 0x0890 1D92 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1D57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D5E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D65 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @1D8B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 // @1D8E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_1D93: // Incoming jump from 0x1D4B, if !(stack[-1] == stack[-2]) // Inputs[1] { @1D96 stack[-1] } 1D93 5B JUMPDEST 1D94 60 PUSH1 0x03 1D96 81 DUP2 1D97 60 PUSH1 0x04 1D99 81 DUP2 1D9A 11 GT 1D9B 15 ISZERO 1D9C 61 PUSH2 0x1da7 1D9F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D94 stack[0] = 0x03 // @1D96 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1da7, if !(stack[-1] > 0x04) label_1DA0: // Incoming jump from 0x1D9F, if not !(stack[-1] > 0x04) 1DA0 61 PUSH2 0x1da7 1DA3 61 PUSH2 0x26dd 1DA6 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DA0 stack[0] = 0x1da7 } // Block ends with unconditional jump to 0x26dd label_1DA7: // Incoming jump from 0x1D9F, if !(stack[-1] > 0x04) // Inputs[2] // { // @1DA8 stack[-2] // @1DA8 stack[-1] // } 1DA7 5B JUMPDEST 1DA8 14 EQ 1DA9 15 ISZERO 1DAA 61 PUSH2 0x1e00 1DAD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1e00, if !(stack[-1] == stack[-2]) label_1DAE: // Incoming jump from 0x1DAD, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1DB0 memory[0x40:0x60] } 1DAE 60 PUSH1 0x40 1DB0 51 MLOAD 1DB1 62 PUSH3 0x461bcd 1DB5 60 PUSH1 0xe5 1DB7 1B SHL 1DB8 81 DUP2 1DB9 52 MSTORE 1DBA 60 PUSH1 0x20 1DBC 60 PUSH1 0x04 1DBE 82 DUP3 1DBF 01 ADD 1DC0 52 MSTORE 1DC1 60 PUSH1 0x22 1DC3 60 PUSH1 0x24 1DC5 82 DUP3 1DC6 01 ADD 1DC7 52 MSTORE 1DC8 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 1DE9 60 PUSH1 0x44 1DEB 82 DUP3 1DEC 01 ADD 1DED 52 MSTORE 1DEE 61 PUSH2 0x7565 1DF1 60 PUSH1 0xf0 1DF3 1B SHL 1DF4 60 PUSH1 0x64 1DF6 82 DUP3 1DF7 01 ADD 1DF8 52 MSTORE 1DF9 60 PUSH1 0x84 1DFB 01 ADD 1DFC 61 PUSH2 0x0890 1DFF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1DB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DC0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1DC7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @1DED memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c // @1DF8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @1DFB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_1E00: // Incoming jump from 0x1DAD, if !(stack[-1] == stack[-2]) // Inputs[1] { @1E03 stack[-1] } 1E00 5B JUMPDEST 1E01 60 PUSH1 0x04 1E03 81 DUP2 1E04 60 PUSH1 0x04 1E06 81 DUP2 1E07 11 GT 1E08 15 ISZERO 1E09 61 PUSH2 0x1e14 1E0C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E01 stack[0] = 0x04 // @1E03 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1e14, if !(stack[-1] > 0x04) label_1E0D: // Incoming jump from 0x1E0C, if not !(stack[-1] > 0x04) 1E0D 61 PUSH2 0x1e14 1E10 61 PUSH2 0x26dd 1E13 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E0D stack[0] = 0x1e14 } // Block ends with unconditional jump to 0x26dd label_1E14: // Incoming jump from 0x1E0C, if !(stack[-1] > 0x04) // Inputs[2] // { // @1E15 stack[-2] // @1E15 stack[-1] // } 1E14 5B JUMPDEST 1E15 14 EQ 1E16 15 ISZERO 1E17 61 PUSH2 0x0950 1E1A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0950, if !(stack[-1] == stack[-2]) label_1E1B: // Incoming jump from 0x1E1A, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1E1D memory[0x40:0x60] } 1E1B 60 PUSH1 0x40 1E1D 51 MLOAD 1E1E 62 PUSH3 0x461bcd 1E22 60 PUSH1 0xe5 1E24 1B SHL 1E25 81 DUP2 1E26 52 MSTORE 1E27 60 PUSH1 0x20 1E29 60 PUSH1 0x04 1E2B 82 DUP3 1E2C 01 ADD 1E2D 52 MSTORE 1E2E 60 PUSH1 0x22 1E30 60 PUSH1 0x24 1E32 82 DUP3 1E33 01 ADD 1E34 52 MSTORE 1E35 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 1E56 60 PUSH1 0x44 1E58 82 DUP3 1E59 01 ADD 1E5A 52 MSTORE 1E5B 61 PUSH2 0x7565 1E5E 60 PUSH1 0xf0 1E60 1B SHL 1E61 60 PUSH1 0x64 1E63 82 DUP3 1E64 01 ADD 1E65 52 MSTORE 1E66 60 PUSH1 0x84 1E68 01 ADD 1E69 61 PUSH2 0x0890 1E6C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1E26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E2D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E34 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @1E5A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c // @1E65 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @1E68 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0890 label_1E6D: // Incoming call from 0x1F9D, returns to 0x1F9E // Incoming call from 0x1C6C, returns to 0x1C6D // Inputs[1] { @1E92 stack[-1] } 1E6D 5B JUMPDEST 1E6E 60 PUSH1 0x00 1E70 80 DUP1 1E71 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 1E92 83 DUP4 1E93 11 GT 1E94 15 ISZERO 1E95 61 PUSH2 0x1ea4 1E98 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E6E stack[0] = 0x00 // @1E70 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ea4, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) label_1E99: // Incoming jump from 0x1E98, if not !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @1E9C stack[-2] } 1E99 50 POP 1E9A 60 PUSH1 0x00 1E9C 90 SWAP1 1E9D 50 POP 1E9E 60 PUSH1 0x03 1EA0 61 PUSH2 0x1f51 1EA3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1E9C stack[-2] = 0x00 // @1E9E stack[-1] = 0x03 // } // Block ends with unconditional jump to 0x1f51 label_1EA4: // Incoming jump from 0x1E98, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @1EA5 stack[-5] } 1EA4 5B JUMPDEST 1EA5 84 DUP5 1EA6 60 PUSH1 0xff 1EA8 16 AND 1EA9 60 PUSH1 0x1b 1EAB 14 EQ 1EAC 15 ISZERO 1EAD 80 DUP1 1EAE 15 ISZERO 1EAF 61 PUSH2 0x1ebc 1EB2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EAC stack[0] = !(0x1b == 0xff & stack[-5]) } // Block ends with conditional jump to 0x1ebc, if !!(0x1b == 0xff & stack[-5]) label_1EB3: // Incoming jump from 0x1EB2, if not !!(0x1b == 0xff & stack[-5]) // Inputs[1] { @1EB4 stack[-6] } 1EB3 50 POP 1EB4 84 DUP5 1EB5 60 PUSH1 0xff 1EB7 16 AND 1EB8 60 PUSH1 0x1c 1EBA 14 EQ 1EBB 15 ISZERO 1EBC 5B JUMPDEST 1EBD 15 ISZERO 1EBE 61 PUSH2 0x1ecd 1EC1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ecd, if !!(0x1c == 0xff & stack[-6]) label_1EC2: // Incoming jump from 0x1EC1, if not !!(0x1c == 0xff & stack[-6]) // Incoming jump from 0x1EC1, if not !stack[-1] // Inputs[1] { @1EC5 stack[-2] } 1EC2 50 POP 1EC3 60 PUSH1 0x00 1EC5 90 SWAP1 1EC6 50 POP 1EC7 60 PUSH1 0x04 1EC9 61 PUSH2 0x1f51 1ECC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1EC5 stack[-2] = 0x00 // @1EC7 stack[-1] = 0x04 // } // Block ends with unconditional jump to 0x1f51 label_1ECD: // Incoming jump from 0x1EC1, if !!(0x1c == 0xff & stack[-6]) // Incoming jump from 0x1EC1, if !stack[-1] // Inputs[9] // { // @1ED1 memory[0x40:0x60] // @1EDE stack[-6] // @1EE3 stack[-5] // @1EF0 stack[-4] // @1EF7 stack[-3] // @1F04 memory[0x40:0x60] // @1F0F msg.gas // @1F10 address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1F10 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1ECD 5B JUMPDEST 1ECE 60 PUSH1 0x40 1ED0 80 DUP1 1ED1 51 MLOAD 1ED2 60 PUSH1 0x00 1ED4 80 DUP1 1ED5 82 DUP3 1ED6 52 MSTORE 1ED7 60 PUSH1 0x20 1ED9 82 DUP3 1EDA 01 ADD 1EDB 80 DUP1 1EDC 84 DUP5 1EDD 52 MSTORE 1EDE 89 DUP10 1EDF 90 SWAP1 1EE0 52 MSTORE 1EE1 60 PUSH1 0xff 1EE3 88 DUP9 1EE4 16 AND 1EE5 92 SWAP3 1EE6 82 DUP3 1EE7 01 ADD 1EE8 92 SWAP3 1EE9 90 SWAP1 1EEA 92 SWAP3 1EEB 52 MSTORE 1EEC 60 PUSH1 0x60 1EEE 81 DUP2 1EEF 01 ADD 1EF0 86 DUP7 1EF1 90 SWAP1 1EF2 52 MSTORE 1EF3 60 PUSH1 0x80 1EF5 81 DUP2 1EF6 01 ADD 1EF7 85 DUP6 1EF8 90 SWAP1 1EF9 52 MSTORE 1EFA 60 PUSH1 0x01 1EFC 90 SWAP1 1EFD 60 PUSH1 0xa0 1EFF 01 ADD 1F00 60 PUSH1 0x20 1F02 60 PUSH1 0x40 1F04 51 MLOAD 1F05 60 PUSH1 0x20 1F07 81 DUP2 1F08 03 SUB 1F09 90 SWAP1 1F0A 80 DUP1 1F0B 84 DUP5 1F0C 03 SUB 1F0D 90 SWAP1 1F0E 85 DUP6 1F0F 5A GAS 1F10 FA STATICCALL 1F11 15 ISZERO 1F12 80 DUP1 1F13 15 ISZERO 1F14 61 PUSH2 0x1f21 1F17 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @1ED6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1EDD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1EE0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] // @1EEA stack[0] = 0x00 // @1EEB memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-5] & 0xff // @1EF2 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-4] // @1EF9 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-3] // @1EFC stack[1] = 0x01 // @1EFF stack[2] = 0xa0 + memory[0x40:0x60] // @1F10 memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1F11 stack[3] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1f21, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_1F18: // Incoming jump from 0x1F17, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1F18 returndata.length // @1F1C returndata[0x00:0x00 + returndata.length] // @1F1D returndata.length // @1F20 memory[0x00:0x00 + returndata.length] // } 1F18 3D RETURNDATASIZE 1F19 60 PUSH1 0x00 1F1B 80 DUP1 1F1C 3E RETURNDATACOPY 1F1D 3D RETURNDATASIZE 1F1E 60 PUSH1 0x00 1F20 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1F1C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1F20 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1F21: // Incoming jump from 0x1F17, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[3] // { // @1F26 memory[0x40:0x60] // @1F2B memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @1F2C stack[-4] // } 1F21 5B JUMPDEST 1F22 50 POP 1F23 50 POP 1F24 60 PUSH1 0x40 1F26 51 MLOAD 1F27 60 PUSH1 0x1f 1F29 19 NOT 1F2A 01 ADD 1F2B 51 MLOAD 1F2C 91 SWAP2 1F2D 50 POP 1F2E 50 POP 1F2F 60 PUSH1 0x01 1F31 60 PUSH1 0x01 1F33 60 PUSH1 0xa0 1F35 1B SHL 1F36 03 SUB 1F37 81 DUP2 1F38 16 AND 1F39 61 PUSH2 0x1f4a 1F3C 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1F2C stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x1f4a, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_1F3D: // Incoming jump from 0x1F3C, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1F41 stack[-2] // @1F43 stack[-3] // } 1F3D 60 PUSH1 0x00 1F3F 60 PUSH1 0x01 1F41 92 SWAP3 1F42 50 POP 1F43 92 SWAP3 1F44 50 POP 1F45 50 POP 1F46 61 PUSH2 0x1f51 1F49 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1F41 stack[-2] = 0x01 // @1F43 stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x1f51 label_1F4A: // Incoming jump from 0x1F3C, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1F4B stack[-3] // @1F4B stack[-1] // @1F4F stack[-2] // } 1F4A 5B JUMPDEST 1F4B 91 SWAP2 1F4C 50 POP 1F4D 60 PUSH1 0x00 1F4F 90 SWAP1 1F50 50 POP // Stack delta = -1 // Outputs[2] // { // @1F4B stack[-3] = stack[-1] // @1F4F stack[-2] = 0x00 // } // Block continues label_1F51: // Incoming jump from 0x1EA3 // Incoming jump from 0x1F49 // Incoming jump from 0x1ECC // Incoming jump from 0x1F50 // Inputs[5] // { // @1F52 stack[-1] // @1F52 stack[-6] // @1F54 stack[-2] // @1F54 stack[-7] // @1F55 stack[-5] // } 1F51 5B JUMPDEST 1F52 94 SWAP5 1F53 50 POP 1F54 94 SWAP5 1F55 92 SWAP3 1F56 50 POP 1F57 50 POP 1F58 50 POP 1F59 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1F52 stack[-6] = stack[-1] // @1F54 stack[-7] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_1F5A: // Incoming call from 0x1C97, returns to 0x1C98 // Inputs[1] { @1F7F stack[-1] } 1F5A 5B JUMPDEST 1F5B 60 PUSH1 0x00 1F5D 80 DUP1 1F5E 7F PUSH32 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1F7F 83 DUP4 1F80 16 AND 1F81 81 DUP2 1F82 61 PUSH2 0x1f90 1F85 60 PUSH1 0xff 1F87 86 DUP7 1F88 90 SWAP1 1F89 1C SHR 1F8A 60 PUSH1 0x1b 1F8C 61 PUSH2 0x26a6 1F8F 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1F5B stack[0] = 0x00 // @1F5D stack[1] = 0x00 // @1F80 stack[2] = stack[-1] & 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @1F81 stack[3] = 0x00 // @1F82 stack[4] = 0x1f90 // @1F89 stack[5] = stack[-1] >> 0xff // @1F8A stack[6] = 0x1b // } // Block ends with call to 0x26a6, returns to 0x1F90 label_1F90: // Incoming return from call to 0x26A6 at 0x1F8F // Inputs[5] // { // @1F91 stack[-1] // @1F91 stack[-2] // @1F96 stack[-8] // @1F98 stack[-7] // @1F99 stack[-3] // } 1F90 5B JUMPDEST 1F91 90 SWAP1 1F92 50 POP 1F93 61 PUSH2 0x1f9e 1F96 87 DUP8 1F97 82 DUP3 1F98 88 DUP9 1F99 85 DUP6 1F9A 61 PUSH2 0x1e6d 1F9D 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1F91 stack[-2] = stack[-1] // @1F93 stack[-1] = 0x1f9e // @1F96 stack[0] = stack[-8] // @1F97 stack[1] = stack[-1] // @1F98 stack[2] = stack[-7] // @1F99 stack[3] = stack[-3] // } // Block ends with call to 0x1e6d, returns to 0x1F9E label_1F9E: // Incoming return from call to 0x1E6D at 0x1F9D // Inputs[7] // { // @1F9F stack[-5] // @1F9F stack[-1] // @1FA1 stack[-2] // @1FA1 stack[-6] // @1FA5 stack[-9] // @1FA7 stack[-10] // @1FA8 stack[-8] // } 1F9E 5B JUMPDEST 1F9F 93 SWAP4 1FA0 50 POP 1FA1 93 SWAP4 1FA2 50 POP 1FA3 50 POP 1FA4 50 POP 1FA5 93 SWAP4 1FA6 50 POP 1FA7 93 SWAP4 1FA8 91 SWAP2 1FA9 50 POP 1FAA 50 POP 1FAB 56 *JUMP // Stack delta = -8 // Outputs[2] // { // @1FA5 stack[-9] = stack[-1] // @1FA7 stack[-10] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_1FAC: // Incoming jump from 0x0A4F // Inputs[2] // { // @1FAD stack[-3] // @1FAF storage[stack[-3]] // } 1FAC 5B JUMPDEST 1FAD 82 DUP3 1FAE 80 DUP1 1FAF 54 SLOAD 1FB0 61 PUSH2 0x1fb8 1FB3 90 SWAP1 1FB4 61 PUSH2 0x24b3 1FB7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FAD stack[0] = stack[-3] // @1FB3 stack[1] = 0x1fb8 // @1FB3 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x24b3, returns to 0x1FB8 label_1FB8: // Incoming return from call to 0x24B3 at 0x1FB7 // Inputs[5] // { // @1FB9 stack[-2] // @1FB9 stack[-1] // @1FC1 memory[0x00:0x20] // @1FCC stack[-4] // @1FCD stack[-3] // } 1FB8 5B JUMPDEST 1FB9 90 SWAP1 1FBA 60 PUSH1 0x00 1FBC 52 MSTORE 1FBD 60 PUSH1 0x20 1FBF 60 PUSH1 0x00 1FC1 20 SHA3 1FC2 90 SWAP1 1FC3 60 PUSH1 0x1f 1FC5 01 ADD 1FC6 60 PUSH1 0x20 1FC8 90 SWAP1 1FC9 04 DIV 1FCA 81 DUP2 1FCB 01 ADD 1FCC 92 SWAP3 1FCD 82 DUP3 1FCE 61 PUSH2 0x1fda 1FD1 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1FBC memory[0x00:0x20] = stack[-2] // @1FC2 stack[-2] = keccak256(memory[0x00:0x20]) // @1FCC stack[-1] = stack[-4] // @1FCC stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1fda, if stack[-3] label_1FD2: // Incoming jump from 0x1FD1, if not stack[-3] // Inputs[1] { @1FD4 stack[-5] } 1FD2 60 PUSH1 0x00 1FD4 85 DUP6 1FD5 55 SSTORE 1FD6 61 PUSH2 0x2020 1FD9 56 *JUMP // Stack delta = +0 // Outputs[1] { @1FD5 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x2020 label_1FDA: // Incoming jump from 0x1FD1, if stack[-3] // Inputs[1] { @1FDB stack[-3] } 1FDA 5B JUMPDEST 1FDB 82 DUP3 1FDC 60 PUSH1 0x1f 1FDE 10 LT 1FDF 61 PUSH2 0x1ff3 1FE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ff3, if 0x1f < stack[-3] label_1FE3: // Incoming jump from 0x1FE2, if not 0x1f < stack[-3] // Inputs[4] // { // @1FE3 stack[-1] // @1FE4 memory[stack[-1]:stack[-1] + 0x20] // @1FE9 stack[-3] // @1FED stack[-5] // } 1FE3 80 DUP1 1FE4 51 MLOAD 1FE5 60 PUSH1 0xff 1FE7 19 NOT 1FE8 16 AND 1FE9 83 DUP4 1FEA 80 DUP1 1FEB 01 ADD 1FEC 17 OR 1FED 85 DUP6 1FEE 55 SSTORE 1FEF 61 PUSH2 0x2020 1FF2 56 *JUMP // Stack delta = +0 // Outputs[1] { @1FEE storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2020 label_1FF3: // Incoming jump from 0x1FE2, if 0x1f < stack[-3] // Inputs[2] // { // @1FF4 stack[-3] // @1FFA stack[-5] // } 1FF3 5B JUMPDEST 1FF4 82 DUP3 1FF5 80 DUP1 1FF6 01 ADD 1FF7 60 PUSH1 0x01 1FF9 01 ADD 1FFA 85 DUP6 1FFB 55 SSTORE 1FFC 82 DUP3 1FFD 15 ISZERO 1FFE 61 PUSH2 0x2020 2001 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1FFB storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2020, if !stack[-3] label_2002: // Incoming jump from 0x2001, if not !stack[-3] // Inputs[2] // { // @2002 stack[-1] // @2002 stack[-3] // } 2002 91 SWAP2 2003 82 DUP3 2004 01 ADD 2005 5B JUMPDEST 2006 82 DUP3 2007 81 DUP2 2008 11 GT 2009 15 ISZERO 200A 61 PUSH2 0x2020 200D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2002 stack[-3] = stack[-1] // @2004 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2020, if !(stack[-1] + stack[-3] > stack[-1]) label_200E: // Incoming jump from 0x200D, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x200D, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @200E stack[-3] // @200F memory[stack[-3]:stack[-3] + 0x20] // @2010 stack[-2] // @2012 stack[-1] // } 200E 82 DUP3 200F 51 MLOAD 2010 82 DUP3 2011 55 SSTORE 2012 91 SWAP2 2013 60 PUSH1 0x20 2015 01 ADD 2016 91 SWAP2 2017 90 SWAP1 2018 60 PUSH1 0x01 201A 01 ADD 201B 90 SWAP1 201C 61 PUSH2 0x2005 201F 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2011 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @2016 stack[-3] = 0x20 + stack[-3] // @201B stack[-2] = 0x01 + stack[-2] // @201B stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2005 label_2020: // Incoming jump from 0x200D, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1FD9 // Incoming jump from 0x200D, if !(stack[-1] > stack[-3]) // Incoming jump from 0x2001, if !stack[-3] // Incoming jump from 0x1FF2 // Inputs[2] // { // @2025 stack[-4] // @2026 stack[-3] // } 2020 5B JUMPDEST 2021 50 POP 2022 61 PUSH2 0x202c 2025 92 SWAP3 2026 91 SWAP2 2027 50 POP 2028 61 PUSH2 0x2030 202B 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2025 stack[-4] = 0x202c // @2026 stack[-3] = stack[-4] // } // Block ends with call to 0x2030, returns to 0x202C label_202C: // Incoming jump from 0x2039, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2030 at 0x202B // Incoming jump from 0x2039, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @202E stack[-2] // @202E stack[-3] // } 202C 5B JUMPDEST 202D 50 POP 202E 90 SWAP1 202F 56 *JUMP // Stack delta = -2 // Outputs[1] { @202E stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2030: // Incoming call from 0x202B, returns to 0x202C // Inputs[2] // { // @2032 stack[-1] // @2033 stack[-2] // } 2030 5B JUMPDEST 2031 5B JUMPDEST 2032 80 DUP1 2033 82 DUP3 2034 11 GT 2035 15 ISZERO 2036 61 PUSH2 0x202c 2039 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x202c, if !(stack[-2] > stack[-1]) label_203A: // Incoming jump from 0x2039, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x2039, if not !(stack[-2] > stack[-1]) // Inputs[1] { @203C stack[-1] } 203A 60 PUSH1 0x00 203C 81 DUP2 203D 55 SSTORE 203E 60 PUSH1 0x01 2040 01 ADD 2041 61 PUSH2 0x2031 2044 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @203D storage[stack[-1]] = 0x00 // @2040 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2031 label_2045: // Incoming call from 0x2077, returns to 0x190F // Incoming call from 0x261F, returns to 0x190F // Inputs[1] { @204F stack[-1] } 2045 5B JUMPDEST 2046 60 PUSH1 0x01 2048 60 PUSH1 0x01 204A 60 PUSH1 0xe0 204C 1B SHL 204D 03 SUB 204E 19 NOT 204F 81 DUP2 2050 16 AND 2051 81 DUP2 2052 14 EQ 2053 61 PUSH2 0x0950 2056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0950, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2057: // Incoming jump from 0x2056, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @205A memory[0x00:0x00] } 2057 60 PUSH1 0x00 2059 80 DUP1 205A FD *REVERT // Stack delta = +0 // Outputs[1] { @205A revert(memory[0x00:0x00]); } // Block terminates label_205B: // Incoming call from 0x0202, returns to 0x0203 // Inputs[2] // { // @2060 stack[-1] // @2061 stack[-2] // } 205B 5B JUMPDEST 205C 60 PUSH1 0x00 205E 60 PUSH1 0x20 2060 82 DUP3 2061 84 DUP5 2062 03 SUB 2063 12 SLT 2064 15 ISZERO 2065 61 PUSH2 0x206d 2068 57 *JUMPI // Stack delta = +1 // Outputs[1] { @205C stack[0] = 0x00 } // Block ends with conditional jump to 0x206d, if !(stack[-2] - stack[-1] i< 0x20) label_2069: // Incoming jump from 0x2068, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @206C memory[0x00:0x00] } 2069 60 PUSH1 0x00 206B 80 DUP1 206C FD *REVERT // Stack delta = +0 // Outputs[1] { @206C revert(memory[0x00:0x00]); } // Block terminates label_206D: // Incoming jump from 0x2068, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @206E stack[-2] // @206F msg.data[stack[-2]:stack[-2] + 0x20] // } 206D 5B JUMPDEST 206E 81 DUP2 206F 35 CALLDATALOAD 2070 61 PUSH2 0x190f 2073 81 DUP2 2074 61 PUSH2 0x2045 2077 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @206F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2070 stack[1] = 0x190f // @2073 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2045, returns to 0x190F label_2078: // Incoming call from 0x2515, returns to 0x2516 // Incoming call from 0x20BB, returns to 0x20BC // Inputs[1] { @207C stack[-3] } 2078 5B JUMPDEST 2079 60 PUSH1 0x00 207B 5B JUMPDEST 207C 83 DUP4 207D 81 DUP2 207E 10 LT 207F 15 ISZERO 2080 61 PUSH2 0x2093 2083 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2079 stack[0] = 0x00 } // Block ends with conditional jump to 0x2093, if !(0x00 < stack[-3]) label_2084: // Incoming jump from 0x2083, if not !(0x00 < stack[-3]) // Incoming jump from 0x2083, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2084 stack[-2] // @2085 stack[-1] // @2087 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2088 stack[-3] // } 2084 81 DUP2 2085 81 DUP2 2086 01 ADD 2087 51 MLOAD 2088 83 DUP4 2089 82 DUP3 208A 01 ADD 208B 52 MSTORE 208C 60 PUSH1 0x20 208E 01 ADD 208F 61 PUSH2 0x207b 2092 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @208B memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @208E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x207b label_2093: // Incoming jump from 0x2083, if !(0x00 < stack[-3]) // Incoming jump from 0x2083, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2094 stack[-4] // @2095 stack[-1] // } 2093 5B JUMPDEST 2094 83 DUP4 2095 81 DUP2 2096 11 GT 2097 15 ISZERO 2098 61 PUSH2 0x0ed5 209B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ed5, if !(stack[-1] > stack[-4]) label_209C: // Incoming jump from 0x209B, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @20A0 stack[-4] // @20A1 stack[-3] // @20A3 stack[-5] // } 209C 50 POP 209D 50 POP 209E 60 PUSH1 0x00 20A0 91 SWAP2 20A1 01 ADD 20A2 52 MSTORE 20A3 56 *JUMP // Stack delta = -5 // Outputs[1] { @20A2 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_20A4: // Incoming call from 0x20E2, returns to 0x190F // Incoming call from 0x25F8, returns to 0x25F9 // Inputs[3] // { // @20A7 stack[-1] // @20A8 memory[stack[-1]:stack[-1] + 0x20] // @20AA stack[-2] // } 20A4 5B JUMPDEST 20A5 60 PUSH1 0x00 20A7 81 DUP2 20A8 51 MLOAD 20A9 80 DUP1 20AA 84 DUP5 20AB 52 MSTORE 20AC 61 PUSH2 0x20bc 20AF 81 DUP2 20B0 60 PUSH1 0x20 20B2 86 DUP7 20B3 01 ADD 20B4 60 PUSH1 0x20 20B6 86 DUP7 20B7 01 ADD 20B8 61 PUSH2 0x2078 20BB 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @20A5 stack[0] = 0x00 // @20A8 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @20AB memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @20AC stack[2] = 0x20bc // @20AF stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @20B3 stack[4] = stack[-2] + 0x20 // @20B7 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2078, returns to 0x20BC label_20BC: // Incoming return from call to 0x2078 at 0x20BB // Inputs[4] // { // @20BF stack[-1] // @20C4 stack[-4] // @20C5 stack[-2] // @20CB stack[-5] // } 20BC 5B JUMPDEST 20BD 60 PUSH1 0x1f 20BF 01 ADD 20C0 60 PUSH1 0x1f 20C2 19 NOT 20C3 16 AND 20C4 92 SWAP3 20C5 90 SWAP1 20C6 92 SWAP3 20C7 01 ADD 20C8 60 PUSH1 0x20 20CA 01 ADD 20CB 92 SWAP3 20CC 91 SWAP2 20CD 50 POP 20CE 50 POP 20CF 56 *JUMP // Stack delta = -4 // Outputs[1] { @20CB stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_20D0: // Incoming call from 0x023E, returns to 0x0214 // Inputs[2] // { // @20D3 stack[-1] // @20DE stack[-2] // } 20D0 5B JUMPDEST 20D1 60 PUSH1 0x20 20D3 81 DUP2 20D4 52 MSTORE 20D5 60 PUSH1 0x00 20D7 61 PUSH2 0x190f 20DA 60 PUSH1 0x20 20DC 83 DUP4 20DD 01 ADD 20DE 84 DUP5 20DF 61 PUSH2 0x20a4 20E2 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @20D4 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @20D5 stack[0] = 0x00 // @20D7 stack[1] = 0x190f // @20DD stack[2] = stack[-1] + 0x20 // @20DE stack[3] = stack[-2] // } // Block ends with call to 0x20a4, returns to 0x190F label_20E3: // Incoming call from 0x036F, returns to 0x0370 // Incoming call from 0x0521, returns to 0x0522 // Incoming call from 0x03EF, returns to 0x03F0 // Incoming call from 0x0259, returns to 0x025A // Inputs[2] // { // @20E8 stack[-1] // @20E9 stack[-2] // } 20E3 5B JUMPDEST 20E4 60 PUSH1 0x00 20E6 60 PUSH1 0x20 20E8 82 DUP3 20E9 84 DUP5 20EA 03 SUB 20EB 12 SLT 20EC 15 ISZERO 20ED 61 PUSH2 0x20f5 20F0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20E4 stack[0] = 0x00 } // Block ends with conditional jump to 0x20f5, if !(stack[-2] - stack[-1] i< 0x20) label_20F1: // Incoming jump from 0x20F0, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20F4 memory[0x00:0x00] } 20F1 60 PUSH1 0x00 20F3 80 DUP1 20F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F4 revert(memory[0x00:0x00]); } // Block terminates label_20F5: // Incoming jump from 0x20F0, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @20F7 stack[-2] // @20F7 msg.data[stack[-2]:stack[-2] + 0x20] // @20F8 stack[-4] // @20F9 stack[-3] // } 20F5 5B JUMPDEST 20F6 50 POP 20F7 35 CALLDATALOAD 20F8 91 SWAP2 20F9 90 SWAP1 20FA 50 POP 20FB 56 *JUMP // Stack delta = -3 // Outputs[1] { @20F8 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_20FC: // Incoming call from 0x2353, returns to 0x2354 // Incoming call from 0x226F, returns to 0x190F // Incoming call from 0x2414, returns to 0x2415 // Incoming call from 0x215C, returns to 0x215D // Incoming call from 0x23AB, returns to 0x23AC // Incoming call from 0x216C, returns to 0x216D // Incoming call from 0x2424, returns to 0x2425 // Incoming call from 0x212E, returns to 0x212F // Incoming call from 0x23BB, returns to 0x23BC // Inputs[1] { @2105 stack[-1] } 20FC 5B JUMPDEST 20FD 60 PUSH1 0x01 20FF 60 PUSH1 0x01 2101 60 PUSH1 0xa0 2103 1B SHL 2104 03 SUB 2105 81 DUP2 2106 16 AND 2107 81 DUP2 2108 14 EQ 2109 61 PUSH2 0x0950 210C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0950, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_210D: // Incoming jump from 0x210C, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2110 memory[0x00:0x00] } 210D 60 PUSH1 0x00 210F 80 DUP1 2110 FD *REVERT // Stack delta = +0 // Outputs[1] { @2110 revert(memory[0x00:0x00]); } // Block terminates label_2111: // Incoming call from 0x0291, returns to 0x0292 // Inputs[2] // { // @2117 stack[-1] // @2118 stack[-2] // } 2111 5B JUMPDEST 2112 60 PUSH1 0x00 2114 80 DUP1 2115 60 PUSH1 0x40 2117 83 DUP4 2118 85 DUP6 2119 03 SUB 211A 12 SLT 211B 15 ISZERO 211C 61 PUSH2 0x2124 211F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2112 stack[0] = 0x00 // @2114 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2124, if !(stack[-2] - stack[-1] i< 0x40) label_2120: // Incoming jump from 0x211F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2123 memory[0x00:0x00] } 2120 60 PUSH1 0x00 2122 80 DUP1 2123 FD *REVERT // Stack delta = +0 // Outputs[1] { @2123 revert(memory[0x00:0x00]); } // Block terminates label_2124: // Incoming jump from 0x211F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2125 stack[-3] // @2126 msg.data[stack[-3]:stack[-3] + 0x20] // } 2124 5B JUMPDEST 2125 82 DUP3 2126 35 CALLDATALOAD 2127 61 PUSH2 0x212f 212A 81 DUP2 212B 61 PUSH2 0x20fc 212E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2126 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2127 stack[1] = 0x212f // @212A stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x20fc, returns to 0x212F label_212F: // Incoming return from call to 0x20FC at 0x212E // Inputs[5] // { // @2130 stack[-6] // @2130 stack[-1] // @2133 stack[-4] // @2137 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2138 stack[-5] // } 212F 5B JUMPDEST 2130 94 SWAP5 2131 60 PUSH1 0x20 2133 93 SWAP4 2134 90 SWAP1 2135 93 SWAP4 2136 01 ADD 2137 35 CALLDATALOAD 2138 93 SWAP4 2139 50 POP 213A 50 POP 213B 50 POP 213C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2130 stack[-6] = stack[-1] // @2138 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_213D: // Incoming call from 0x02EC, returns to 0x02ED // Incoming call from 0x034F, returns to 0x0350 // Inputs[2] // { // @2145 stack[-1] // @2146 stack[-2] // } 213D 5B JUMPDEST 213E 60 PUSH1 0x00 2140 80 DUP1 2141 60 PUSH1 0x00 2143 60 PUSH1 0x60 2145 84 DUP5 2146 86 DUP7 2147 03 SUB 2148 12 SLT 2149 15 ISZERO 214A 61 PUSH2 0x2152 214D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @213E stack[0] = 0x00 // @2140 stack[1] = 0x00 // @2141 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2152, if !(stack[-2] - stack[-1] i< 0x60) label_214E: // Incoming jump from 0x214D, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2151 memory[0x00:0x00] } 214E 60 PUSH1 0x00 2150 80 DUP1 2151 FD *REVERT // Stack delta = +0 // Outputs[1] { @2151 revert(memory[0x00:0x00]); } // Block terminates label_2152: // Incoming jump from 0x214D, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2153 stack[-4] // @2154 msg.data[stack[-4]:stack[-4] + 0x20] // } 2152 5B JUMPDEST 2153 83 DUP4 2154 35 CALLDATALOAD 2155 61 PUSH2 0x215d 2158 81 DUP2 2159 61 PUSH2 0x20fc 215C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2154 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @2155 stack[1] = 0x215d // @2158 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x20fc, returns to 0x215D label_215D: // Incoming return from call to 0x20FC at 0x215C // Inputs[4] // { // @215E stack[-1] // @215E stack[-4] // @2162 stack[-5] // @2164 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 215D 5B JUMPDEST 215E 92 SWAP3 215F 50 POP 2160 60 PUSH1 0x20 2162 84 DUP5 2163 01 ADD 2164 35 CALLDATALOAD 2165 61 PUSH2 0x216d 2168 81 DUP2 2169 61 PUSH2 0x20fc 216C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @215E stack[-4] = stack[-1] // @2164 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2165 stack[0] = 0x216d // @2168 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x20fc, returns to 0x216D label_216D: // Incoming return from call to 0x20FC at 0x216C // Inputs[6] // { // @216E stack[-4] // @216E stack[-1] // @216F stack[-7] // @2171 stack[-6] // @2177 stack[-5] // @217B msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 216D 5B JUMPDEST 216E 92 SWAP3 216F 95 SWAP6 2170 92 SWAP3 2171 94 SWAP5 2172 50 POP 2173 50 POP 2174 50 POP 2175 60 PUSH1 0x40 2177 91 SWAP2 2178 90 SWAP1 2179 91 SWAP2 217A 01 ADD 217B 35 CALLDATALOAD 217C 90 SWAP1 217D 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @216F stack[-7] = stack[-4] // @2171 stack[-6] = stack[-1] // @217C stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_217E: // Incoming jump from 0x1817 // Incoming jump from 0x21D6 // Incoming jump from 0x21AE // Inputs[1] { @2193 memory[0x00:0x24] } 217E 5B JUMPDEST 217F 63 PUSH4 0x4e487b71 2184 60 PUSH1 0xe0 2186 1B SHL 2187 60 PUSH1 0x00 2189 52 MSTORE 218A 60 PUSH1 0x41 218C 60 PUSH1 0x04 218E 52 MSTORE 218F 60 PUSH1 0x24 2191 60 PUSH1 0x00 2193 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2189 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @218E memory[0x04:0x24] = 0x41 // @2193 revert(memory[0x00:0x24]); // } // Block terminates label_2194: // Incoming call from 0x2252, returns to 0x178B // Incoming call from 0x238A, returns to 0x190F // Inputs[1] { @21A1 stack[-2] } 2194 5B JUMPDEST 2195 60 PUSH1 0x00 2197 67 PUSH8 0xffffffffffffffff 21A0 80 DUP1 21A1 84 DUP5 21A2 11 GT 21A3 15 ISZERO 21A4 61 PUSH2 0x21af 21A7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2195 stack[0] = 0x00 // @2197 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x21af, if !(stack[-2] > 0xffffffffffffffff) label_21A8: // Incoming jump from 0x21A7, if not !(stack[-2] > 0xffffffffffffffff) 21A8 61 PUSH2 0x21af 21AB 61 PUSH2 0x217e 21AE 56 *JUMP // Stack delta = +1 // Outputs[1] { @21A8 stack[0] = 0x21af } // Block ends with unconditional jump to 0x217e label_21AF: // Incoming jump from 0x21A7, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @21B2 memory[0x40:0x60] // @21B5 stack[-4] // @21C4 stack[-1] // } 21AF 5B JUMPDEST 21B0 60 PUSH1 0x40 21B2 51 MLOAD 21B3 60 PUSH1 0x1f 21B5 85 DUP6 21B6 01 ADD 21B7 60 PUSH1 0x1f 21B9 19 NOT 21BA 90 SWAP1 21BB 81 DUP2 21BC 16 AND 21BD 60 PUSH1 0x3f 21BF 01 ADD 21C0 16 AND 21C1 81 DUP2 21C2 01 ADD 21C3 90 SWAP1 21C4 82 DUP3 21C5 82 DUP3 21C6 11 GT 21C7 81 DUP2 21C8 83 DUP4 21C9 10 LT 21CA 17 OR 21CB 15 ISZERO 21CC 61 PUSH2 0x21d7 21CF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21C3 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @21C3 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x21d7, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_21D0: // Incoming jump from 0x21CF, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 21D0 61 PUSH2 0x21d7 21D3 61 PUSH2 0x217e 21D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @21D0 stack[0] = 0x21d7 } // Block ends with unconditional jump to 0x217e label_21D7: // Incoming jump from 0x21CF, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @21D8 stack[-2] // @21DC stack[-1] // @21DD stack[-4] // @21DF stack[-6] // @21E2 stack[-7] // @21E4 stack[-5] // } 21D7 5B JUMPDEST 21D8 81 DUP2 21D9 60 PUSH1 0x40 21DB 52 MSTORE 21DC 80 DUP1 21DD 93 SWAP4 21DE 50 POP 21DF 85 DUP6 21E0 81 DUP2 21E1 52 MSTORE 21E2 86 DUP7 21E3 86 DUP7 21E4 86 DUP7 21E5 01 ADD 21E6 11 GT 21E7 15 ISZERO 21E8 61 PUSH2 0x21f0 21EB 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @21DB memory[0x40:0x60] = stack[-2] // @21DD stack[-4] = stack[-1] // @21E1 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x21f0, if !(stack[-5] + stack[-6] > stack[-7]) label_21EC: // Incoming jump from 0x21EB, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @21EF memory[0x00:0x00] } 21EC 60 PUSH1 0x00 21EE 80 DUP1 21EF FD *REVERT // Stack delta = +0 // Outputs[1] { @21EF revert(memory[0x00:0x00]); } // Block terminates label_21F0: // Incoming jump from 0x21EB, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @21F1 stack[-6] // @21F2 stack[-5] // @21F5 stack[-1] // @21F7 msg.data[stack[-5]:stack[-5] + stack[-6]] // @2204 stack[-8] // @2204 stack[-4] // @2205 stack[-7] // } 21F0 5B JUMPDEST 21F1 85 DUP6 21F2 85 DUP6 21F3 60 PUSH1 0x20 21F5 83 DUP4 21F6 01 ADD 21F7 37 CALLDATACOPY 21F8 60 PUSH1 0x00 21FA 60 PUSH1 0x20 21FC 87 DUP8 21FD 83 DUP4 21FE 01 ADD 21FF 01 ADD 2200 52 MSTORE 2201 50 POP 2202 50 POP 2203 50 POP 2204 93 SWAP4 2205 92 SWAP3 2206 50 POP 2207 50 POP 2208 50 POP 2209 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @21F7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @2200 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2204 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_220A: // Incoming call from 0x038F, returns to 0x0390 // Inputs[2] // { // @220F stack[-1] // @2210 stack[-2] // } 220A 5B JUMPDEST 220B 60 PUSH1 0x00 220D 60 PUSH1 0x20 220F 82 DUP3 2210 84 DUP5 2211 03 SUB 2212 12 SLT 2213 15 ISZERO 2214 61 PUSH2 0x221c 2217 57 *JUMPI // Stack delta = +1 // Outputs[1] { @220B stack[0] = 0x00 } // Block ends with conditional jump to 0x221c, if !(stack[-2] - stack[-1] i< 0x20) label_2218: // Incoming jump from 0x2217, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @221B memory[0x00:0x00] } 2218 60 PUSH1 0x00 221A 80 DUP1 221B FD *REVERT // Stack delta = +0 // Outputs[1] { @221B revert(memory[0x00:0x00]); } // Block terminates label_221C: // Incoming jump from 0x2217, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @221D stack[-2] // @221E msg.data[stack[-2]:stack[-2] + 0x20] // } 221C 5B JUMPDEST 221D 81 DUP2 221E 35 CALLDATALOAD 221F 67 PUSH8 0xffffffffffffffff 2228 81 DUP2 2229 11 GT 222A 15 ISZERO 222B 61 PUSH2 0x2233 222E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @221E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2233, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_222F: // Incoming jump from 0x222E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2232 memory[0x00:0x00] } 222F 60 PUSH1 0x00 2231 80 DUP1 2232 FD *REVERT // Stack delta = +0 // Outputs[1] { @2232 revert(memory[0x00:0x00]); } // Block terminates label_2233: // Incoming jump from 0x222E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2234 stack[-3] // @2235 stack[-1] // @223A stack[-4] // } 2233 5B JUMPDEST 2234 82 DUP3 2235 01 ADD 2236 60 PUSH1 0x1f 2238 81 DUP2 2239 01 ADD 223A 84 DUP5 223B 13 SGT 223C 61 PUSH2 0x2244 223F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2235 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2244, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_2240: // Incoming jump from 0x223F, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @2243 memory[0x00:0x00] } 2240 60 PUSH1 0x00 2242 80 DUP1 2243 FD *REVERT // Stack delta = +0 // Outputs[1] { @2243 revert(memory[0x00:0x00]); } // Block terminates label_2244: // Incoming jump from 0x223F, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2248 stack[-4] // @2249 stack[-1] // @224A msg.data[stack[-1]:stack[-1] + 0x20] // } 2244 5B JUMPDEST 2245 61 PUSH2 0x178b 2248 84 DUP5 2249 82 DUP3 224A 35 CALLDATALOAD 224B 60 PUSH1 0x20 224D 84 DUP5 224E 01 ADD 224F 61 PUSH2 0x2194 2252 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2245 stack[0] = 0x178b // @2248 stack[1] = stack[-4] // @224A stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @224E stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2194, returns to 0x178B label_2253: // Incoming call from 0x042F, returns to 0x0430 // Incoming call from 0x0B7E, returns to 0x0B7F // Incoming call from 0x03AF, returns to 0x03B0 // Incoming call from 0x05AA, returns to 0x05AB // Incoming call from 0x0E63, returns to 0x0E64 // Incoming call from 0x0541, returns to 0x0542 // Incoming call from 0x040F, returns to 0x0410 // Inputs[2] // { // @2258 stack[-1] // @2259 stack[-2] // } 2253 5B JUMPDEST 2254 60 PUSH1 0x00 2256 60 PUSH1 0x20 2258 82 DUP3 2259 84 DUP5 225A 03 SUB 225B 12 SLT 225C 15 ISZERO 225D 61 PUSH2 0x2265 2260 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2254 stack[0] = 0x00 } // Block ends with conditional jump to 0x2265, if !(stack[-2] - stack[-1] i< 0x20) label_2261: // Incoming jump from 0x2260, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2264 memory[0x00:0x00] } 2261 60 PUSH1 0x00 2263 80 DUP1 2264 FD *REVERT // Stack delta = +0 // Outputs[1] { @2264 revert(memory[0x00:0x00]); } // Block terminates label_2265: // Incoming jump from 0x2260, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2266 stack[-2] // @2267 msg.data[stack[-2]:stack[-2] + 0x20] // } 2265 5B JUMPDEST 2266 81 DUP2 2267 35 CALLDATALOAD 2268 61 PUSH2 0x190f 226B 81 DUP2 226C 61 PUSH2 0x20fc 226F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2267 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2268 stack[1] = 0x190f // @226B stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x20fc, returns to 0x190F label_2270: // Incoming call from 0x2314, returns to 0x2315 // Incoming call from 0x22EE, returns to 0x22EF // Inputs[2] // { // @2274 stack[-2] // @2277 stack[-1] // } 2270 5B JUMPDEST 2271 60 PUSH1 0x00 2273 80 DUP1 2274 83 DUP4 2275 60 PUSH1 0x1f 2277 84 DUP5 2278 01 ADD 2279 12 SLT 227A 61 PUSH2 0x2282 227D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2271 stack[0] = 0x00 // @2273 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2282, if stack[-1] + 0x1f i< stack[-2] label_227E: // Incoming jump from 0x227D, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2281 memory[0x00:0x00] } 227E 60 PUSH1 0x00 2280 80 DUP1 2281 FD *REVERT // Stack delta = +0 // Outputs[1] { @2281 revert(memory[0x00:0x00]); } // Block terminates label_2282: // Incoming jump from 0x227D, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2284 stack[-3] // @2285 msg.data[stack[-3]:stack[-3] + 0x20] // } 2282 5B JUMPDEST 2283 50 POP 2284 81 DUP2 2285 35 CALLDATALOAD 2286 67 PUSH8 0xffffffffffffffff 228F 81 DUP2 2290 11 GT 2291 15 ISZERO 2292 61 PUSH2 0x229a 2295 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2285 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x229a, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2296: // Incoming jump from 0x2295, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2299 memory[0x00:0x00] } 2296 60 PUSH1 0x00 2298 80 DUP1 2299 FD *REVERT // Stack delta = +0 // Outputs[1] { @2299 revert(memory[0x00:0x00]); } // Block terminates label_229A: // Incoming jump from 0x2295, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @229D stack[-3] // @229F stack[-2] // @22A1 stack[-4] // @22A4 stack[-1] // } 229A 5B JUMPDEST 229B 60 PUSH1 0x20 229D 83 DUP4 229E 01 ADD 229F 91 SWAP2 22A0 50 POP 22A1 83 DUP4 22A2 60 PUSH1 0x20 22A4 82 DUP3 22A5 60 PUSH1 0x05 22A7 1B SHL 22A8 85 DUP6 22A9 01 ADD 22AA 01 ADD 22AB 11 GT 22AC 15 ISZERO 22AD 61 PUSH2 0x1cab 22B0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @229F stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x1cab, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_22B1: // Incoming jump from 0x22B0, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @22B4 memory[0x00:0x00] } 22B1 60 PUSH1 0x00 22B3 80 DUP1 22B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @22B4 revert(memory[0x00:0x00]); } // Block terminates label_22B5: // Incoming call from 0x03CF, returns to 0x03D0 // Incoming call from 0x04CC, returns to 0x04CD // Inputs[2] // { // @22BE stack[-1] // @22BF stack[-2] // } 22B5 5B JUMPDEST 22B6 60 PUSH1 0x00 22B8 80 DUP1 22B9 60 PUSH1 0x00 22BB 80 DUP1 22BC 60 PUSH1 0x40 22BE 85 DUP6 22BF 87 DUP8 22C0 03 SUB 22C1 12 SLT 22C2 15 ISZERO 22C3 61 PUSH2 0x22cb 22C6 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @22B6 stack[0] = 0x00 // @22B8 stack[1] = 0x00 // @22B9 stack[2] = 0x00 // @22BB stack[3] = 0x00 // } // Block ends with conditional jump to 0x22cb, if !(stack[-2] - stack[-1] i< 0x40) label_22C7: // Incoming jump from 0x22C6, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22CA memory[0x00:0x00] } 22C7 60 PUSH1 0x00 22C9 80 DUP1 22CA FD *REVERT // Stack delta = +0 // Outputs[1] { @22CA revert(memory[0x00:0x00]); } // Block terminates label_22CB: // Incoming jump from 0x22C6, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22CC stack[-5] // @22CD msg.data[stack[-5]:stack[-5] + 0x20] // } 22CB 5B JUMPDEST 22CC 84 DUP5 22CD 35 CALLDATALOAD 22CE 67 PUSH8 0xffffffffffffffff 22D7 80 DUP1 22D8 82 DUP3 22D9 11 GT 22DA 15 ISZERO 22DB 61 PUSH2 0x22e3 22DE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22CD stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @22CE stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x22e3, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) label_22DF: // Incoming jump from 0x22DE, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @22E2 memory[0x00:0x00] } 22DF 60 PUSH1 0x00 22E1 80 DUP1 22E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @22E2 revert(memory[0x00:0x00]); } // Block terminates label_22E3: // Incoming jump from 0x22DE, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @22E7 stack[-8] // @22E8 stack[-2] // @22E9 stack[-7] // } 22E3 5B JUMPDEST 22E4 61 PUSH2 0x22ef 22E7 88 DUP9 22E8 83 DUP4 22E9 89 DUP10 22EA 01 ADD 22EB 61 PUSH2 0x2270 22EE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22E4 stack[0] = 0x22ef // @22E7 stack[1] = stack[-8] // @22EA stack[2] = stack[-7] + stack[-2] // } // Block ends with call to 0x2270, returns to 0x22EF label_22EF: // Incoming return from call to 0x2270 at 0x22EE // Inputs[8] // { // @22F0 stack[-1] // @22F0 stack[-2] // @22F1 stack[-8] // @22F3 stack[-7] // @22F7 stack[-9] // @22F9 msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @22FA stack[-4] // @22FC stack[-3] // } 22EF 5B JUMPDEST 22F0 90 SWAP1 22F1 96 SWAP7 22F2 50 POP 22F3 94 SWAP5 22F4 50 POP 22F5 60 PUSH1 0x20 22F7 87 DUP8 22F8 01 ADD 22F9 35 CALLDATALOAD 22FA 91 SWAP2 22FB 50 POP 22FC 80 DUP1 22FD 82 DUP3 22FE 11 GT 22FF 15 ISZERO 2300 61 PUSH2 0x2308 2303 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @22F1 stack[-8] = stack[-2] // @22F3 stack[-7] = stack[-1] // @22FA stack[-4] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2308, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) label_2304: // Incoming jump from 0x2303, if not !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) // Inputs[1] { @2307 memory[0x00:0x00] } 2304 60 PUSH1 0x00 2306 80 DUP1 2307 FD *REVERT // Stack delta = +0 // Outputs[1] { @2307 revert(memory[0x00:0x00]); } // Block terminates label_2308: // Incoming jump from 0x2303, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) // Inputs[3] // { // @230D stack[-8] // @230E stack[-2] // @230F stack[-7] // } 2308 5B JUMPDEST 2309 50 POP 230A 61 PUSH2 0x2315 230D 87 DUP8 230E 82 DUP3 230F 88 DUP9 2310 01 ADD 2311 61 PUSH2 0x2270 2314 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @230A stack[-1] = 0x2315 // @230D stack[0] = stack[-8] // @2310 stack[1] = stack[-7] + stack[-2] // } // Block ends with call to 0x2270, returns to 0x2315 label_2315: // Incoming return from call to 0x2270 at 0x2314 // Inputs[7] // { // @2316 stack[-7] // @2316 stack[-1] // @2317 stack[-10] // @2318 stack[-6] // @2319 stack[-9] // @231B stack[-2] // @231B stack[-8] // } 2315 5B JUMPDEST 2316 95 SWAP6 2317 98 SWAP9 2318 94 SWAP5 2319 97 SWAP8 231A 50 POP 231B 95 SWAP6 231C 50 POP 231D 50 POP 231E 50 POP 231F 50 POP 2320 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @2316 stack[-7] = stack[-1] // @2317 stack[-10] = stack[-7] // @2319 stack[-9] = stack[-6] // @231B stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_2321: // Incoming call from 0x2499, returns to 0x249A // Incoming call from 0x24A7, returns to 0x24A8 // Incoming call from 0x244A, returns to 0x190F // Incoming call from 0x2361, returns to 0x2362 // Inputs[2] // { // @2322 stack[-1] // @2323 msg.data[stack[-1]:stack[-1] + 0x20] // } 2321 5B JUMPDEST 2322 80 DUP1 2323 35 CALLDATALOAD 2324 80 DUP1 2325 15 ISZERO 2326 15 ISZERO 2327 81 DUP2 2328 14 EQ 2329 61 PUSH2 0x2331 232C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2323 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2331, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_232D: // Incoming jump from 0x232C, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @2330 memory[0x00:0x00] } 232D 60 PUSH1 0x00 232F 80 DUP1 2330 FD *REVERT // Stack delta = +0 // Outputs[1] { @2330 revert(memory[0x00:0x00]); } // Block terminates label_2331: // Incoming jump from 0x232C, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @2332 stack[-1] // @2332 stack[-3] // @2333 stack[-2] // } 2331 5B JUMPDEST 2332 91 SWAP2 2333 90 SWAP1 2334 50 POP 2335 56 *JUMP // Stack delta = -2 // Outputs[1] { @2332 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2336: // Incoming call from 0x0497, returns to 0x0498 // Inputs[2] // { // @233C stack[-1] // @233D stack[-2] // } 2336 5B JUMPDEST 2337 60 PUSH1 0x00 2339 80 DUP1 233A 60 PUSH1 0x40 233C 83 DUP4 233D 85 DUP6 233E 03 SUB 233F 12 SLT 2340 15 ISZERO 2341 61 PUSH2 0x2349 2344 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2337 stack[0] = 0x00 // @2339 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2349, if !(stack[-2] - stack[-1] i< 0x40) label_2345: // Incoming jump from 0x2344, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2348 memory[0x00:0x00] } 2345 60 PUSH1 0x00 2347 80 DUP1 2348 FD *REVERT // Stack delta = +0 // Outputs[1] { @2348 revert(memory[0x00:0x00]); } // Block terminates label_2349: // Incoming jump from 0x2344, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @234A stack[-3] // @234B msg.data[stack[-3]:stack[-3] + 0x20] // } 2349 5B JUMPDEST 234A 82 DUP3 234B 35 CALLDATALOAD 234C 61 PUSH2 0x2354 234F 81 DUP2 2350 61 PUSH2 0x20fc 2353 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @234B stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @234C stack[1] = 0x2354 // @234F stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x20fc, returns to 0x2354 label_2354: // Incoming return from call to 0x20FC at 0x2353 // Inputs[3] // { // @2355 stack[-3] // @2355 stack[-1] // @235C stack[-4] // } 2354 5B JUMPDEST 2355 91 SWAP2 2356 50 POP 2357 61 PUSH2 0x2362 235A 60 PUSH1 0x20 235C 84 DUP5 235D 01 ADD 235E 61 PUSH2 0x2321 2361 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2355 stack[-3] = stack[-1] // @2357 stack[-1] = 0x2362 // @235D stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x2321, returns to 0x2362 label_2362: // Incoming return from call to 0x2321 at 0x2361 // Inputs[6] // { // @2363 stack[-1] // @2363 stack[-2] // @2365 stack[-5] // @2367 stack[-6] // @2367 stack[-3] // @2368 stack[-4] // } 2362 5B JUMPDEST 2363 90 SWAP1 2364 50 POP 2365 92 SWAP3 2366 50 POP 2367 92 SWAP3 2368 90 SWAP1 2369 50 POP 236A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2365 stack[-5] = stack[-1] // @2367 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_236B: // Incoming call from 0x23EA, returns to 0x23EB // Incoming call from 0x248A, returns to 0x248B // Inputs[2] // { // @236E stack[-2] // @2371 stack[-1] // } 236B 5B JUMPDEST 236C 60 PUSH1 0x00 236E 82 DUP3 236F 60 PUSH1 0x1f 2371 83 DUP4 2372 01 ADD 2373 12 SLT 2374 61 PUSH2 0x237c 2377 57 *JUMPI // Stack delta = +1 // Outputs[1] { @236C stack[0] = 0x00 } // Block ends with conditional jump to 0x237c, if stack[-1] + 0x1f i< stack[-2] label_2378: // Incoming jump from 0x2377, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @237B memory[0x00:0x00] } 2378 60 PUSH1 0x00 237A 80 DUP1 237B FD *REVERT // Stack delta = +0 // Outputs[1] { @237B revert(memory[0x00:0x00]); } // Block terminates label_237C: // Incoming jump from 0x2377, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @2380 stack[-3] // @2381 stack[-2] // @2382 msg.data[stack[-2]:stack[-2] + 0x20] // } 237C 5B JUMPDEST 237D 61 PUSH2 0x190f 2380 83 DUP4 2381 83 DUP4 2382 35 CALLDATALOAD 2383 60 PUSH1 0x20 2385 85 DUP6 2386 01 ADD 2387 61 PUSH2 0x2194 238A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @237D stack[0] = 0x190f // @2380 stack[1] = stack[-3] // @2382 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @2386 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x2194, returns to 0x190F label_238B: // Incoming call from 0x0501, returns to 0x0502 // Inputs[2] // { // @2394 stack[-1] // @2395 stack[-2] // } 238B 5B JUMPDEST 238C 60 PUSH1 0x00 238E 80 DUP1 238F 60 PUSH1 0x00 2391 80 DUP1 2392 60 PUSH1 0x80 2394 85 DUP6 2395 87 DUP8 2396 03 SUB 2397 12 SLT 2398 15 ISZERO 2399 61 PUSH2 0x23a1 239C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @238C stack[0] = 0x00 // @238E stack[1] = 0x00 // @238F stack[2] = 0x00 // @2391 stack[3] = 0x00 // } // Block ends with conditional jump to 0x23a1, if !(stack[-2] - stack[-1] i< 0x80) label_239D: // Incoming jump from 0x239C, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @23A0 memory[0x00:0x00] } 239D 60 PUSH1 0x00 239F 80 DUP1 23A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @23A0 revert(memory[0x00:0x00]); } // Block terminates label_23A1: // Incoming jump from 0x239C, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @23A2 stack[-5] // @23A3 msg.data[stack[-5]:stack[-5] + 0x20] // } 23A1 5B JUMPDEST 23A2 84 DUP5 23A3 35 CALLDATALOAD 23A4 61 PUSH2 0x23ac 23A7 81 DUP2 23A8 61 PUSH2 0x20fc 23AB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23A3 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @23A4 stack[1] = 0x23ac // @23A7 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x20fc, returns to 0x23AC label_23AC: // Incoming return from call to 0x20FC at 0x23AB // Inputs[4] // { // @23AD stack[-5] // @23AD stack[-1] // @23B1 stack[-6] // @23B3 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 23AC 5B JUMPDEST 23AD 93 SWAP4 23AE 50 POP 23AF 60 PUSH1 0x20 23B1 85 DUP6 23B2 01 ADD 23B3 35 CALLDATALOAD 23B4 61 PUSH2 0x23bc 23B7 81 DUP2 23B8 61 PUSH2 0x20fc 23BB 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @23AD stack[-5] = stack[-1] // @23B3 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @23B4 stack[0] = 0x23bc // @23B7 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x20fc, returns to 0x23BC label_23BC: // Incoming return from call to 0x20FC at 0x23BB // Inputs[6] // { // @23BD stack[-1] // @23BD stack[-4] // @23C1 stack[-6] // @23C3 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @23C4 stack[-3] // @23CA msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 23BC 5B JUMPDEST 23BD 92 SWAP3 23BE 50 POP 23BF 60 PUSH1 0x40 23C1 85 DUP6 23C2 01 ADD 23C3 35 CALLDATALOAD 23C4 91 SWAP2 23C5 50 POP 23C6 60 PUSH1 0x60 23C8 85 DUP6 23C9 01 ADD 23CA 35 CALLDATALOAD 23CB 67 PUSH8 0xffffffffffffffff 23D4 81 DUP2 23D5 11 GT 23D6 15 ISZERO 23D7 61 PUSH2 0x23df 23DA 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @23BD stack[-4] = stack[-1] // @23C4 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @23CA stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x23df, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_23DB: // Incoming jump from 0x23DA, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @23DE memory[0x00:0x00] } 23DB 60 PUSH1 0x00 23DD 80 DUP1 23DE FD *REVERT // Stack delta = +0 // Outputs[1] { @23DE revert(memory[0x00:0x00]); } // Block terminates label_23DF: // Incoming jump from 0x23DA, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @23E3 stack[-7] // @23E4 stack[-1] // @23E5 stack[-6] // } 23DF 5B JUMPDEST 23E0 61 PUSH2 0x23eb 23E3 87 DUP8 23E4 82 DUP3 23E5 88 DUP9 23E6 01 ADD 23E7 61 PUSH2 0x236b 23EA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23E0 stack[0] = 0x23eb // @23E3 stack[1] = stack[-7] // @23E6 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x236b, returns to 0x23EB label_23EB: // Incoming return from call to 0x236B at 0x23EA // Inputs[8] // { // @23EC stack[-1] // @23EC stack[-3] // @23EF stack[-6] // @23F0 stack[-9] // @23F1 stack[-5] // @23F2 stack[-8] // @23F4 stack[-7] // @23F4 stack[-4] // } 23EB 5B JUMPDEST 23EC 91 SWAP2 23ED 50 POP 23EE 50 POP 23EF 92 SWAP3 23F0 95 SWAP6 23F1 91 SWAP2 23F2 94 SWAP5 23F3 50 POP 23F4 92 SWAP3 23F5 50 POP 23F6 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @23EF stack[-6] = stack[-1] // @23F0 stack[-9] = stack[-6] // @23F2 stack[-8] = stack[-5] // @23F4 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_23F7: // Incoming call from 0x0561, returns to 0x0562 // Inputs[2] // { // @23FD stack[-1] // @23FE stack[-2] // } 23F7 5B JUMPDEST 23F8 60 PUSH1 0x00 23FA 80 DUP1 23FB 60 PUSH1 0x40 23FD 83 DUP4 23FE 85 DUP6 23FF 03 SUB 2400 12 SLT 2401 15 ISZERO 2402 61 PUSH2 0x240a 2405 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23F8 stack[0] = 0x00 // @23FA stack[1] = 0x00 // } // Block ends with conditional jump to 0x240a, if !(stack[-2] - stack[-1] i< 0x40) label_2406: // Incoming jump from 0x2405, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2409 memory[0x00:0x00] } 2406 60 PUSH1 0x00 2408 80 DUP1 2409 FD *REVERT // Stack delta = +0 // Outputs[1] { @2409 revert(memory[0x00:0x00]); } // Block terminates label_240A: // Incoming jump from 0x2405, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @240B stack[-3] // @240C msg.data[stack[-3]:stack[-3] + 0x20] // } 240A 5B JUMPDEST 240B 82 DUP3 240C 35 CALLDATALOAD 240D 61 PUSH2 0x2415 2410 81 DUP2 2411 61 PUSH2 0x20fc 2414 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @240C stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @240D stack[1] = 0x2415 // @2410 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x20fc, returns to 0x2415 label_2415: // Incoming return from call to 0x20FC at 0x2414 // Inputs[4] // { // @2416 stack[-1] // @2416 stack[-3] // @241A stack[-4] // @241C msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2415 5B JUMPDEST 2416 91 SWAP2 2417 50 POP 2418 60 PUSH1 0x20 241A 83 DUP4 241B 01 ADD 241C 35 CALLDATALOAD 241D 61 PUSH2 0x2425 2420 81 DUP2 2421 61 PUSH2 0x20fc 2424 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2416 stack[-3] = stack[-1] // @241C stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @241D stack[0] = 0x2425 // @2420 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x20fc, returns to 0x2425 label_2425: // Incoming return from call to 0x20FC at 0x2424 // Inputs[6] // { // @2426 stack[-1] // @2427 stack[-2] // @242A stack[-5] // @242C stack[-6] // @242C stack[-3] // @242D stack[-4] // } 2425 5B JUMPDEST 2426 80 DUP1 2427 91 SWAP2 2428 50 POP 2429 50 POP 242A 92 SWAP3 242B 50 POP 242C 92 SWAP3 242D 90 SWAP1 242E 50 POP 242F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @242A stack[-5] = stack[-1] // @242C stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2430: // Incoming call from 0x05CA, returns to 0x05CB // Inputs[2] // { // @2435 stack[-1] // @2436 stack[-2] // } 2430 5B JUMPDEST 2431 60 PUSH1 0x00 2433 60 PUSH1 0x20 2435 82 DUP3 2436 84 DUP5 2437 03 SUB 2438 12 SLT 2439 15 ISZERO 243A 61 PUSH2 0x2442 243D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2431 stack[0] = 0x00 } // Block ends with conditional jump to 0x2442, if !(stack[-2] - stack[-1] i< 0x20) label_243E: // Incoming jump from 0x243D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2441 memory[0x00:0x00] } 243E 60 PUSH1 0x00 2440 80 DUP1 2441 FD *REVERT // Stack delta = +0 // Outputs[1] { @2441 revert(memory[0x00:0x00]); } // Block terminates label_2442: // Incoming jump from 0x243D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2446 stack[-2] } 2442 5B JUMPDEST 2443 61 PUSH2 0x190f 2446 82 DUP3 2447 61 PUSH2 0x2321 244A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2443 stack[0] = 0x190f // @2446 stack[1] = stack[-2] // } // Block ends with call to 0x2321, returns to 0x190F label_244B: // Incoming call from 0x05DD, returns to 0x05DE // Inputs[2] // { // @2454 stack[-1] // @2455 stack[-2] // } 244B 5B JUMPDEST 244C 60 PUSH1 0x00 244E 80 DUP1 244F 60 PUSH1 0x00 2451 80 DUP1 2452 60 PUSH1 0x80 2454 85 DUP6 2455 87 DUP8 2456 03 SUB 2457 12 SLT 2458 15 ISZERO 2459 61 PUSH2 0x2461 245C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @244C stack[0] = 0x00 // @244E stack[1] = 0x00 // @244F stack[2] = 0x00 // @2451 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2461, if !(stack[-2] - stack[-1] i< 0x80) label_245D: // Incoming jump from 0x245C, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2460 memory[0x00:0x00] } 245D 60 PUSH1 0x00 245F 80 DUP1 2460 FD *REVERT // Stack delta = +0 // Outputs[1] { @2460 revert(memory[0x00:0x00]); } // Block terminates label_2461: // Incoming jump from 0x245C, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[4] // { // @2462 stack[-5] // @2463 msg.data[stack[-5]:stack[-5] + 0x20] // @2464 stack[-4] // @246A msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 2461 5B JUMPDEST 2462 84 DUP5 2463 35 CALLDATALOAD 2464 93 SWAP4 2465 50 POP 2466 60 PUSH1 0x20 2468 85 DUP6 2469 01 ADD 246A 35 CALLDATALOAD 246B 67 PUSH8 0xffffffffffffffff 2474 81 DUP2 2475 11 GT 2476 15 ISZERO 2477 61 PUSH2 0x247f 247A 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2464 stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @246A stack[0] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x247f, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_247B: // Incoming jump from 0x247A, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @247E memory[0x00:0x00] } 247B 60 PUSH1 0x00 247D 80 DUP1 247E FD *REVERT // Stack delta = +0 // Outputs[1] { @247E revert(memory[0x00:0x00]); } // Block terminates label_247F: // Incoming jump from 0x247A, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2483 stack[-7] // @2484 stack[-1] // @2485 stack[-6] // } 247F 5B JUMPDEST 2480 61 PUSH2 0x248b 2483 87 DUP8 2484 82 DUP3 2485 88 DUP9 2486 01 ADD 2487 61 PUSH2 0x236b 248A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2480 stack[0] = 0x248b // @2483 stack[1] = stack[-7] // @2486 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x236b, returns to 0x248B label_248B: // Incoming return from call to 0x236B at 0x248A // Inputs[3] // { // @248C stack[-5] // @248C stack[-1] // @2494 stack[-7] // } 248B 5B JUMPDEST 248C 93 SWAP4 248D 50 POP 248E 50 POP 248F 61 PUSH2 0x249a 2492 60 PUSH1 0x40 2494 86 DUP7 2495 01 ADD 2496 61 PUSH2 0x2321 2499 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @248C stack[-5] = stack[-1] // @248F stack[-2] = 0x249a // @2495 stack[-1] = stack[-7] + 0x40 // } // Block ends with call to 0x2321, returns to 0x249A label_249A: // Incoming return from call to 0x2321 at 0x2499 // Inputs[3] // { // @249B stack[-3] // @249B stack[-1] // @24A2 stack[-6] // } 249A 5B JUMPDEST 249B 91 SWAP2 249C 50 POP 249D 61 PUSH2 0x24a8 24A0 60 PUSH1 0x60 24A2 86 DUP7 24A3 01 ADD 24A4 61 PUSH2 0x2321 24A7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @249B stack[-3] = stack[-1] // @249D stack[-1] = 0x24a8 // @24A3 stack[0] = stack[-6] + 0x60 // } // Block ends with call to 0x2321, returns to 0x24A8 label_24A8: // Incoming return from call to 0x2321 at 0x24A7 // Inputs[8] // { // @24A9 stack[-2] // @24A9 stack[-1] // @24AB stack[-5] // @24AC stack[-8] // @24AD stack[-4] // @24AE stack[-7] // @24B0 stack[-3] // @24B0 stack[-6] // } 24A8 5B JUMPDEST 24A9 90 SWAP1 24AA 50 POP 24AB 92 SWAP3 24AC 95 SWAP6 24AD 91 SWAP2 24AE 94 SWAP5 24AF 50 POP 24B0 92 SWAP3 24B1 50 POP 24B2 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @24AB stack[-5] = stack[-1] // @24AC stack[-8] = stack[-5] // @24AE stack[-7] = stack[-4] // @24B0 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-8] label_24B3: // Incoming call from 0x0D24, returns to 0x068F // Incoming call from 0x068E, returns to 0x068F // Incoming call from 0x1FB7, returns to 0x1FB8 // Incoming call from 0x06BA, returns to 0x06BB // Inputs[1] { @24B6 stack[-1] } 24B3 5B JUMPDEST 24B4 60 PUSH1 0x01 24B6 81 DUP2 24B7 81 DUP2 24B8 1C SHR 24B9 90 SWAP1 24BA 82 DUP3 24BB 16 AND 24BC 80 DUP1 24BD 61 PUSH2 0x24c7 24C0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @24B9 stack[0] = stack[-1] >> 0x01 // @24BB stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x24c7, if stack[-1] & 0x01 label_24C1: // Incoming jump from 0x24C0, if not stack[-1] & 0x01 // Inputs[2] // { // @24C3 stack[-2] // @24CC stack[-1] // } 24C1 60 PUSH1 0x7f 24C3 82 DUP3 24C4 16 AND 24C5 91 SWAP2 24C6 50 POP 24C7 5B JUMPDEST 24C8 60 PUSH1 0x20 24CA 82 DUP3 24CB 10 LT 24CC 81 DUP2 24CD 14 EQ 24CE 15 ISZERO 24CF 61 PUSH2 0x24e8 24D2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @24C5 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x24e8, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_24D3: // Incoming jump from 0x24D2, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x24D2, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @24E7 memory[0x00:0x24] } 24D3 63 PUSH4 0x4e487b71 24D8 60 PUSH1 0xe0 24DA 1B SHL 24DB 60 PUSH1 0x00 24DD 52 MSTORE 24DE 60 PUSH1 0x22 24E0 60 PUSH1 0x04 24E2 52 MSTORE 24E3 60 PUSH1 0x24 24E5 60 PUSH1 0x00 24E7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @24DD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @24E2 memory[0x04:0x24] = 0x22 // @24E7 revert(memory[0x00:0x24]); // } // Block terminates label_24E8: // Incoming jump from 0x24D2, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x24D2, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @24EA stack[-4] // @24EA stack[-2] // @24EB stack[-3] // } 24E8 5B JUMPDEST 24E9 50 POP 24EA 91 SWAP2 24EB 90 SWAP1 24EC 50 POP 24ED 56 *JUMP // Stack delta = -3 // Outputs[1] { @24EA stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_24EE: // Incoming jump from 0x0E75 // Incoming jump from 0x0B90 // Incoming jump from 0x1883 // Incoming jump from 0x0B69 // Incoming jump from 0x0E4E // Inputs[1] { @2503 memory[0x00:0x24] } 24EE 5B JUMPDEST 24EF 63 PUSH4 0x4e487b71 24F4 60 PUSH1 0xe0 24F6 1B SHL 24F7 60 PUSH1 0x00 24F9 52 MSTORE 24FA 60 PUSH1 0x32 24FC 60 PUSH1 0x04 24FE 52 MSTORE 24FF 60 PUSH1 0x24 2501 60 PUSH1 0x00 2503 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @24F9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @24FE memory[0x04:0x24] = 0x32 // @2503 revert(memory[0x00:0x24]); // } // Block terminates label_2504: // Incoming call from 0x25BD, returns to 0x25BE // Inputs[3] // { // @2507 stack[-1] // @2508 memory[stack[-1]:stack[-1] + 0x20] // @250D stack[-2] // } 2504 5B JUMPDEST 2505 60 PUSH1 0x00 2507 81 DUP2 2508 51 MLOAD 2509 61 PUSH2 0x2516 250C 81 DUP2 250D 85 DUP6 250E 60 PUSH1 0x20 2510 86 DUP7 2511 01 ADD 2512 61 PUSH2 0x2078 2515 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2505 stack[0] = 0x00 // @2508 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2509 stack[2] = 0x2516 // @250C stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @250D stack[4] = stack[-2] // @2511 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2078, returns to 0x2516 label_2516: // Incoming return from call to 0x2078 at 0x2515 // Inputs[4] // { // @2517 stack[-1] // @2517 stack[-4] // @2518 stack[-2] // @251B stack[-5] // } 2516 5B JUMPDEST 2517 92 SWAP3 2518 90 SWAP1 2519 92 SWAP3 251A 01 ADD 251B 92 SWAP3 251C 91 SWAP2 251D 50 POP 251E 50 POP 251F 56 *JUMP // Stack delta = -4 // Outputs[1] { @251B stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2520: // Incoming call from 0x0EF8, returns to 0x0EF9 // Inputs[2] // { // @2524 stack[-3] // @2525 storage[stack[-3]] // } 2520 5B JUMPDEST 2521 60 PUSH1 0x00 2523 80 DUP1 2524 84 DUP5 2525 54 SLOAD 2526 81 DUP2 2527 60 PUSH1 0x01 2529 82 DUP3 252A 81 DUP2 252B 1C SHR 252C 91 SWAP2 252D 50 POP 252E 80 DUP1 252F 83 DUP4 2530 16 AND 2531 80 DUP1 2532 61 PUSH2 0x253c 2535 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2521 stack[0] = 0x00 // @2523 stack[1] = 0x00 // @2525 stack[2] = storage[stack[-3]] // @2527 stack[4] = 0x01 // @252C stack[3] = storage[stack[-3]] >> 0x01 // @2530 stack[5] = storage[stack[-3]] & 0x01 // } // Block ends with conditional jump to 0x253c, if storage[stack[-3]] & 0x01 label_2536: // Incoming jump from 0x2535, if not storage[stack[-3]] & 0x01 // Inputs[2] // { // @2538 stack[-3] // @2542 stack[-1] // } 2536 60 PUSH1 0x7f 2538 83 DUP4 2539 16 AND 253A 92 SWAP3 253B 50 POP 253C 5B JUMPDEST 253D 60 PUSH1 0x20 253F 80 DUP1 2540 84 DUP5 2541 10 LT 2542 82 DUP3 2543 14 EQ 2544 15 ISZERO 2545 61 PUSH2 0x255c 2548 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @253A stack[-3] = stack[-3] & 0x7f // @253D stack[0] = 0x20 // } // Block ends with conditional jump to 0x255c, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_2549: // Incoming jump from 0x2548, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2548, if not !(stack[-1] == (stack[-3] < 0x20)) // Inputs[2] // { // @2551 stack[-6] // @255B memory[stack[-6]:stack[-6] + 0x24] // } 2549 63 PUSH4 0x4e487b71 254E 60 PUSH1 0xe0 2550 1B SHL 2551 86 DUP7 2552 52 MSTORE 2553 60 PUSH1 0x22 2555 60 PUSH1 0x04 2557 52 MSTORE 2558 60 PUSH1 0x24 255A 86 DUP7 255B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2552 memory[stack[-6]:stack[-6] + 0x20] = 0x4e487b71 << 0xe0 // @2557 memory[0x04:0x24] = 0x22 // @255B revert(memory[stack[-6]:stack[-6] + 0x24]); // } // Block terminates label_255C: // Incoming jump from 0x2548, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2548, if !(stack[-1] == (stack[-3] < 0x20)) // Inputs[1] { @255D stack[-2] } 255C 5B JUMPDEST 255D 81 DUP2 255E 80 DUP1 255F 15 ISZERO 2560 61 PUSH2 0x2570 2563 57 *JUMPI // Stack delta = +1 // Outputs[1] { @255D stack[0] = stack[-2] } // Block ends with conditional jump to 0x2570, if !stack[-2] label_2564: // Incoming jump from 0x2563, if not !stack[-2] // Inputs[1] { @2566 stack[-1] } 2564 60 PUSH1 0x01 2566 81 DUP2 2567 14 EQ 2568 61 PUSH2 0x2581 256B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2581, if stack[-1] == 0x01 label_256C: // Incoming jump from 0x256B, if not stack[-1] == 0x01 256C 61 PUSH2 0x25ae 256F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x25ae label_2570: // Incoming jump from 0x2563, if !stack[-2] // Inputs[4] // { // @2574 stack[-6] // @2576 stack[-9] // @2578 stack[-5] // @257B stack[-7] // } 2570 5B JUMPDEST 2571 60 PUSH1 0xff 2573 19 NOT 2574 86 DUP7 2575 16 AND 2576 89 DUP10 2577 52 MSTORE 2578 84 DUP5 2579 89 DUP10 257A 01 ADD 257B 96 SWAP7 257C 50 POP 257D 61 PUSH2 0x25ae 2580 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2577 memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @257B stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x25ae label_2581: // Incoming jump from 0x256B, if stack[-1] == 0x01 // Inputs[3] // { // @2584 stack[-11] // @258A memory[0x00:0x20] // @258E stack[-5] // } 2581 5B JUMPDEST 2582 60 PUSH1 0x00 2584 8B DUP12 2585 81 DUP2 2586 52 MSTORE 2587 60 PUSH1 0x20 2589 90 SWAP1 258A 20 SHA3 258B 60 PUSH1 0x00 258D 5B JUMPDEST 258E 86 DUP7 258F 81 DUP2 2590 10 LT 2591 15 ISZERO 2592 61 PUSH2 0x25a6 2595 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2586 memory[0x00:0x20] = stack[-11] // @258A stack[0] = keccak256(memory[0x00:0x20]) // @258B stack[1] = 0x00 // } // Block ends with conditional jump to 0x25a6, if !(0x00 < stack[-5]) label_2596: // Incoming jump from 0x2595, if not !(stack[-1] < stack[-7]) // Incoming jump from 0x2595, if not !(0x00 < stack[-5]) // Inputs[6] // { // @2596 stack[-2] // @2597 storage[stack[-2]] // @2598 stack[-11] // @2599 stack[-1] // @259D stack[-6] // @25A0 stack[-4] // } 2596 81 DUP2 2597 54 SLOAD 2598 8B DUP12 2599 82 DUP3 259A 01 ADD 259B 52 MSTORE 259C 90 SWAP1 259D 85 DUP6 259E 01 ADD 259F 90 SWAP1 25A0 83 DUP4 25A1 01 ADD 25A2 61 PUSH2 0x258d 25A5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @259B memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @259F stack[-2] = stack[-6] + stack[-2] // @25A1 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x258d label_25A6: // Incoming jump from 0x2595, if !(stack[-1] < stack[-7]) // Incoming jump from 0x2595, if !(0x00 < stack[-5]) // Inputs[3] // { // @25A9 stack[-7] // @25AA stack[-11] // @25AC stack[-9] // } 25A6 5B JUMPDEST 25A7 50 POP 25A8 50 POP 25A9 84 DUP5 25AA 89 DUP10 25AB 01 ADD 25AC 96 SWAP7 25AD 50 POP // Stack delta = -2 // Outputs[1] { @25AC stack[-9] = stack[-11] + stack[-7] } // Block continues label_25AE: // Incoming jump from 0x25AD // Incoming jump from 0x2580 // Incoming jump from 0x256F // Inputs[2] // { // @25B8 stack[-7] // @25B9 stack[-10] // } 25AE 5B JUMPDEST 25AF 50 POP 25B0 50 POP 25B1 50 POP 25B2 50 POP 25B3 50 POP 25B4 50 POP 25B5 61 PUSH2 0x25be 25B8 81 DUP2 25B9 85 DUP6 25BA 61 PUSH2 0x2504 25BD 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @25B5 stack[-6] = 0x25be // @25B8 stack[-5] = stack[-7] // @25B9 stack[-4] = stack[-10] // } // Block ends with call to 0x2504, returns to 0x25BE label_25BE: // Incoming return from call to 0x2504 at 0x25BD // Inputs[3] // { // @25BF stack[-1] // @25BF stack[-7] // @25C0 stack[-6] // } 25BE 5B JUMPDEST 25BF 95 SWAP6 25C0 94 SWAP5 25C1 50 POP 25C2 50 POP 25C3 50 POP 25C4 50 POP 25C5 50 POP 25C6 56 *JUMP // Stack delta = -6 // Outputs[1] { @25BF stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_25C7: // Incoming call from 0x16CF, returns to 0x16D0 // Inputs[5] // { // @25D3 stack[-5] // @25D5 stack[-1] // @25D8 stack[-4] // @25E0 stack[-3] // @25F4 stack[-2] // } 25C7 5B JUMPDEST 25C8 60 PUSH1 0x00 25CA 60 PUSH1 0x01 25CC 60 PUSH1 0x01 25CE 60 PUSH1 0xa0 25D0 1B SHL 25D1 03 SUB 25D2 80 DUP1 25D3 87 DUP8 25D4 16 AND 25D5 83 DUP4 25D6 52 MSTORE 25D7 80 DUP1 25D8 86 DUP7 25D9 16 AND 25DA 60 PUSH1 0x20 25DC 84 DUP5 25DD 01 ADD 25DE 52 MSTORE 25DF 50 POP 25E0 83 DUP4 25E1 60 PUSH1 0x40 25E3 83 DUP4 25E4 01 ADD 25E5 52 MSTORE 25E6 60 PUSH1 0x80 25E8 60 PUSH1 0x60 25EA 83 DUP4 25EB 01 ADD 25EC 52 MSTORE 25ED 61 PUSH2 0x25f9 25F0 60 PUSH1 0x80 25F2 83 DUP4 25F3 01 ADD 25F4 84 DUP5 25F5 61 PUSH2 0x20a4 25F8 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @25C8 stack[0] = 0x00 // @25D6 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @25DE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @25E5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @25EC memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @25ED stack[1] = 0x25f9 // @25F3 stack[2] = stack[-1] + 0x80 // @25F4 stack[3] = stack[-2] // } // Block ends with call to 0x20a4, returns to 0x25F9 label_25F9: // Incoming return from call to 0x20A4 at 0x25F8 // Inputs[3] // { // @25FA stack[-1] // @25FA stack[-8] // @25FB stack[-7] // } 25F9 5B JUMPDEST 25FA 96 SWAP7 25FB 95 SWAP6 25FC 50 POP 25FD 50 POP 25FE 50 POP 25FF 50 POP 2600 50 POP 2601 50 POP 2602 56 *JUMP // Stack delta = -7 // Outputs[1] { @25FA stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2603: // Incoming call from 0x1716, returns to 0x1717 // Inputs[2] // { // @2608 stack[-1] // @2609 stack[-2] // } 2603 5B JUMPDEST 2604 60 PUSH1 0x00 2606 60 PUSH1 0x20 2608 82 DUP3 2609 84 DUP5 260A 03 SUB 260B 12 SLT 260C 15 ISZERO 260D 61 PUSH2 0x2615 2610 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2604 stack[0] = 0x00 } // Block ends with conditional jump to 0x2615, if !(stack[-2] - stack[-1] i< 0x20) label_2611: // Incoming jump from 0x2610, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2614 memory[0x00:0x00] } 2611 60 PUSH1 0x00 2613 80 DUP1 2614 FD *REVERT // Stack delta = +0 // Outputs[1] { @2614 revert(memory[0x00:0x00]); } // Block terminates label_2615: // Incoming jump from 0x2610, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2616 stack[-2] // @2617 memory[stack[-2]:stack[-2] + 0x20] // } 2615 5B JUMPDEST 2616 81 DUP2 2617 51 MLOAD 2618 61 PUSH2 0x190f 261B 81 DUP2 261C 61 PUSH2 0x2045 261F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2617 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2618 stack[1] = 0x190f // @261B stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2045, returns to 0x190F label_2620: // Incoming jump from 0x268C // Incoming jump from 0x26B8 // Incoming jump from 0x2649 // Incoming jump from 0x26D7 // Inputs[1] { @2635 memory[0x00:0x24] } 2620 5B JUMPDEST 2621 63 PUSH4 0x4e487b71 2626 60 PUSH1 0xe0 2628 1B SHL 2629 60 PUSH1 0x00 262B 52 MSTORE 262C 60 PUSH1 0x11 262E 60 PUSH1 0x04 2630 52 MSTORE 2631 60 PUSH1 0x24 2633 60 PUSH1 0x00 2635 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @262B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2630 memory[0x04:0x24] = 0x11 // @2635 revert(memory[0x00:0x24]); // } // Block terminates label_2636: // Incoming call from 0x17E6, returns to 0x17E7 // Inputs[1] { @263C stack[-1] } 2636 5B JUMPDEST 2637 60 PUSH1 0x00 2639 60 PUSH1 0x00 263B 19 NOT 263C 82 DUP3 263D 14 EQ 263E 15 ISZERO 263F 61 PUSH2 0x264a 2642 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2637 stack[0] = 0x00 } // Block ends with conditional jump to 0x264a, if !(stack[-1] == ~0x00) label_2643: // Incoming jump from 0x2642, if not !(stack[-1] == ~0x00) 2643 61 PUSH2 0x264a 2646 61 PUSH2 0x2620 2649 56 *JUMP // Stack delta = +1 // Outputs[1] { @2643 stack[0] = 0x264a } // Block ends with unconditional jump to 0x2620 label_264A: // Incoming jump from 0x2642, if !(stack[-1] == ~0x00) // Inputs[2] // { // @264E stack[-2] // @264F stack[-3] // } 264A 5B JUMPDEST 264B 50 POP 264C 60 PUSH1 0x01 264E 01 ADD 264F 90 SWAP1 2650 56 *JUMP // Stack delta = -2 // Outputs[1] { @264F stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2651: // Incoming jump from 0x26A0 // Incoming jump from 0x2675 // Inputs[1] { @2666 memory[0x00:0x24] } 2651 5B JUMPDEST 2652 63 PUSH4 0x4e487b71 2657 60 PUSH1 0xe0 2659 1B SHL 265A 60 PUSH1 0x00 265C 52 MSTORE 265D 60 PUSH1 0x12 265F 60 PUSH1 0x04 2661 52 MSTORE 2662 60 PUSH1 0x24 2664 60 PUSH1 0x00 2666 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @265C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2661 memory[0x04:0x24] = 0x12 // @2666 revert(memory[0x00:0x24]); // } // Block terminates label_2667: // Incoming call from 0x18BD, returns to 0x18BE // Incoming call from 0x17F5, returns to 0x17F6 // Inputs[1] { @266A stack[-2] } 2667 5B JUMPDEST 2668 60 PUSH1 0x00 266A 82 DUP3 266B 61 PUSH2 0x2676 266E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2668 stack[0] = 0x00 } // Block ends with conditional jump to 0x2676, if stack[-2] label_266F: // Incoming jump from 0x266E, if not stack[-2] 266F 61 PUSH2 0x2676 2672 61 PUSH2 0x2651 2675 56 *JUMP // Stack delta = +1 // Outputs[1] { @266F stack[0] = 0x2676 } // Block ends with unconditional jump to 0x2651 label_2676: // Incoming jump from 0x266E, if stack[-2] // Inputs[3] // { // @2678 stack[-3] // @2678 stack[-2] // @2679 stack[-4] // } 2676 5B JUMPDEST 2677 50 POP 2678 04 DIV 2679 90 SWAP1 267A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2679 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_267B: // Incoming call from 0x1856, returns to 0x1857 // Incoming call from 0x18E9, returns to 0x18EA // Inputs[2] // { // @267E stack[-2] // @267F stack[-1] // } 267B 5B JUMPDEST 267C 60 PUSH1 0x00 267E 82 DUP3 267F 82 DUP3 2680 10 LT 2681 15 ISZERO 2682 61 PUSH2 0x268d 2685 57 *JUMPI // Stack delta = +1 // Outputs[1] { @267C stack[0] = 0x00 } // Block ends with conditional jump to 0x268d, if !(stack[-1] < stack[-2]) label_2686: // Incoming jump from 0x2685, if not !(stack[-1] < stack[-2]) 2686 61 PUSH2 0x268d 2689 61 PUSH2 0x2620 268C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2686 stack[0] = 0x268d } // Block ends with unconditional jump to 0x2620 label_268D: // Incoming jump from 0x2685, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @268F stack[-2] // @268F stack[-3] // @2690 stack[-4] // } 268D 5B JUMPDEST 268E 50 POP 268F 03 SUB 2690 90 SWAP1 2691 56 *JUMP // Stack delta = -3 // Outputs[1] { @2690 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_2692: // Incoming call from 0x1863, returns to 0x1864 // Inputs[1] { @2695 stack[-2] } 2692 5B JUMPDEST 2693 60 PUSH1 0x00 2695 82 DUP3 2696 61 PUSH2 0x26a1 2699 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2693 stack[0] = 0x00 } // Block ends with conditional jump to 0x26a1, if stack[-2] label_269A: // Incoming jump from 0x2699, if not stack[-2] 269A 61 PUSH2 0x26a1 269D 61 PUSH2 0x2651 26A0 56 *JUMP // Stack delta = +1 // Outputs[1] { @269A stack[0] = 0x26a1 } // Block ends with unconditional jump to 0x2651 label_26A1: // Incoming jump from 0x2699, if stack[-2] // Inputs[3] // { // @26A3 stack[-3] // @26A3 stack[-2] // @26A4 stack[-4] // } 26A1 5B JUMPDEST 26A2 50 POP 26A3 06 MOD 26A4 90 SWAP1 26A5 56 *JUMP // Stack delta = -3 // Outputs[1] { @26A4 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_26A6: // Incoming call from 0x1F8F, returns to 0x1F90 // Incoming call from 0x186E, returns to 0x186F // Inputs[2] // { // @26A9 stack[-2] // @26AB stack[-1] // } 26A6 5B JUMPDEST 26A7 60 PUSH1 0x00 26A9 82 DUP3 26AA 19 NOT 26AB 82 DUP3 26AC 11 GT 26AD 15 ISZERO 26AE 61 PUSH2 0x26b9 26B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26A7 stack[0] = 0x00 } // Block ends with conditional jump to 0x26b9, if !(stack[-1] > ~stack[-2]) label_26B2: // Incoming jump from 0x26B1, if not !(stack[-1] > ~stack[-2]) 26B2 61 PUSH2 0x26b9 26B5 61 PUSH2 0x2620 26B8 56 *JUMP // Stack delta = +1 // Outputs[1] { @26B2 stack[0] = 0x26b9 } // Block ends with unconditional jump to 0x2620 label_26B9: // Incoming jump from 0x26B1, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @26BB stack[-2] // @26BB stack[-3] // @26BC stack[-4] // } 26B9 5B JUMPDEST 26BA 50 POP 26BB 01 ADD 26BC 90 SWAP1 26BD 56 *JUMP // Stack delta = -3 // Outputs[1] { @26BC stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_26BE: // Incoming call from 0x190B, returns to 0x190C // Incoming call from 0x18F3, returns to 0x18F4 // Inputs[2] // { // @26C1 stack[-1] // @26C6 stack[-2] // } 26BE 5B JUMPDEST 26BF 60 PUSH1 0x00 26C1 81 DUP2 26C2 60 PUSH1 0x00 26C4 19 NOT 26C5 04 DIV 26C6 83 DUP4 26C7 11 GT 26C8 82 DUP3 26C9 15 ISZERO 26CA 15 ISZERO 26CB 16 AND 26CC 15 ISZERO 26CD 61 PUSH2 0x26d8 26D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26BF stack[0] = 0x00 } // Block ends with conditional jump to 0x26d8, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_26D1: // Incoming jump from 0x26D0, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 26D1 61 PUSH2 0x26d8 26D4 61 PUSH2 0x2620 26D7 56 *JUMP // Stack delta = +1 // Outputs[1] { @26D1 stack[0] = 0x26d8 } // Block ends with unconditional jump to 0x2620 label_26D8: // Incoming jump from 0x26D0, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @26DA stack[-3] // @26DA stack[-2] // @26DB stack[-4] // } 26D8 5B JUMPDEST 26D9 50 POP 26DA 02 MUL 26DB 90 SWAP1 26DC 56 *JUMP // Stack delta = -3 // Outputs[1] { @26DB stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_26DD: // Incoming jump from 0x1CC5 // Incoming jump from 0x1D44 // Incoming jump from 0x1E13 // Incoming jump from 0x1CE2 // Incoming jump from 0x1DA6 // Inputs[1] { @26F2 memory[0x00:0x24] } 26DD 5B JUMPDEST 26DE 63 PUSH4 0x4e487b71 26E3 60 PUSH1 0xe0 26E5 1B SHL 26E6 60 PUSH1 0x00 26E8 52 MSTORE 26E9 60 PUSH1 0x21 26EB 60 PUSH1 0x04 26ED 52 MSTORE 26EE 60 PUSH1 0x24 26F0 60 PUSH1 0x00 26F2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26E8 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @26ED memory[0x04:0x24] = 0x21 // @26F2 revert(memory[0x00:0x24]); // } // Block terminates 26F3 FE *ASSERT 26F4 A2 LOG2 26F5 64 PUSH5 0x6970667358 26FB 22 22 26FC 12 SLT 26FD 20 SHA3 26FE E5 E5 26FF BF BF 2700 DD DD 2701 F2 CALLCODE 2702 11 GT 2703 AF AF 2704 CB CB 2705 92 SWAP3 2706 2D 2D 2707 06 MOD 2708 B5 B5 2709 C8 C8 270A 71 PUSH18 0xd540ef9c3638e678b347b3e81cb6b4c60f13 271D 74 PUSH21 0x64736f6c63430008090033