// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/sam.c
// Function: sam_parse1
int sam_parse1(kstring_t *s, sam_hdr_t *h, bam1_t *b)
{
#define _read_token(_p) (_p); do { char *tab = strchr((_p), '\t'); if (!tab) goto err_ret; *tab = '\0'; (_p) = tab + 1; } while (0)

#if HTS_ALLOW_UNALIGNED != 0 && ULONG_MAX == 0xffffffffffffffff

// Macro that operates on 64-bits at a time.
#define COPY_MINUS_N(to,from,n,l,failed)                        \
    do {                                                        \
        uint64_u *from8 = (uint64_u *)(from);                   \
        uint64_u *to8 = (uint64_u *)(to);                       \
        uint64_t uflow = 0;                                     \
        size_t l8 = (l)>>3, i;                                  \
        for (i = 0; i < l8; i++) {                              \
            to8[i] = from8[i] - (n)*0x0101010101010101UL;       \
            uflow |= to8[i];                                    \
        }                                                       \
        for (i<<=3; i < (l); ++i) {                             \
            to[i] = from[i] - (n);                              \
            uflow |= to[i];                                     \
        }                                                       \
        failed = (uflow & 0x8080808080808080UL) > 0;            \
    } while (0)

#else

// Basic version which operates a byte at a time
#define COPY_MINUS_N(to,from,n,l,failed) do {                \
        uint8_t uflow = 0;                                   \
        for (i = 0; i < (l); ++i) {                          \
            (to)[i] = (from)[i] - (n);                       \
            uflow |= (uint8_t) (to)[i];                      \
        }                                                    \
        failed = (uflow & 0x80) > 0;                         \
    } while (0)

#endif

#define _get_mem(type_t, x, b, l) if (possibly_expand_bam_data((b), (l)) < 0) goto err_ret; *(x) = (type_t*)((b)->data + (b)->l_data); (b)->l_data += (l)
#define _parse_err(cond, ...) do { if (cond) { hts_log_error(__VA_ARGS__); goto err_ret; } } while (0)
#define _parse_warn(cond, ...) do { if (cond) { hts_log_warning(__VA_ARGS__); } } while (0)

    uint8_t *t;

    char *p = s->s, *q;
    int i, overflow = 0;
    char logbuf[40];
    hts_pos_t cigreflen;
    bam1_core_t *c = &b->core;

    b->l_data = 0;
    memset(c, 0, 32);

    // qname
    q = _read_token(p);

    _parse_warn(p - q <= 1, "empty query name");
    _parse_err(p - q > 255, "query name too long");
    // resize large enough for name + extranul
    if (possibly_expand_bam_data(b, (p - q) + 4) < 0) goto err_ret;
    memcpy(b->data + b->l_data, q, p-q); b->l_data += p-q;

    c->l_extranul = (4 - (b->l_data & 3)) & 3;
    memcpy(b->data + b->l_data, "\0\0\0\0", c->l_extranul);
    b->l_data += c->l_extranul;

    c->l_qname = p - q + c->l_extranul;

    // flag
    c->flag = parse_sam_flag(p, &p, &overflow);
    if (*p++ != '\t') goto err_ret; // malformated flag

    // chr
    q = _read_token(p);
    if (strcmp(q, "*")) {
        _parse_err(h->n_targets == 0, "no SQ lines present in the header");
        c->tid = bam_name2id(h, q);
        _parse_err(c->tid < -1, "failed to parse header");
        _parse_warn(c->tid < 0, "unrecognized reference name %s; treated as unmapped", hts_strprint(logbuf, sizeof logbuf, '"', q, SIZE_MAX));
    } else c->tid = -1;

    // pos
    c->pos = hts_str2uint(p, &p, 62, &overflow) - 1;
    if (*p++ != '\t') goto err_ret;
    if (c->pos < 0 && c->tid >= 0) {
        _parse_warn(1, "mapped query cannot have zero coordinate; treated as unmapped");
        c->tid = -1;
    }
    if (c->tid < 0) c->flag |= BAM_FUNMAP;

    // mapq
    c->qual = hts_str2uint(p, &p, 8, &overflow);
    if (*p++ != '\t') goto err_ret;
    // cigar
    if (*p != '*') {
        uint32_t *cigar = NULL;
        int old_l_data = b->l_data;
        int n_cigar = bam_parse_cigar(p, &p, b);
        if (n_cigar < 1 || *p++ != '\t') goto err_ret;
        cigar = (uint32_t *)(b->data + old_l_data);

        // can't use bam_endpos() directly as some fields not yet set up
        cigreflen = (!(c->flag&BAM_FUNMAP))? bam_cigar2rlen(c->n_cigar, cigar) : 1;
        if (cigreflen == 0) cigreflen = 1;
    } else {
        _parse_warn(!(c->flag&BAM_FUNMAP), "mapped query must have a CIGAR; treated as unmapped");
        c->flag |= BAM_FUNMAP;
        q = _read_token(p);
        cigreflen = 1;
    }
    _parse_err(HTS_POS_MAX - cigreflen <= c->pos,
               "read ends beyond highest supported position");
    c->bin = hts_reg2bin(c->pos, c->pos + cigreflen, 14, 5);
    // mate chr
    q = _read_token(p);
    if (strcmp(q, "=") == 0) {
        c->mtid = c->tid;
    } else if (strcmp(q, "*") == 0) {
        c->mtid = -1;
    } else {
        c->mtid = bam_name2id(h, q);
        _parse_err(c->mtid < -1, "failed to parse header");
        _parse_warn(c->mtid < 0, "unrecognized mate reference name %s; treated as unmapped", hts_strprint(logbuf, sizeof logbuf, '"', q, SIZE_MAX));
    }
    // mpos
    c->mpos = hts_str2uint(p, &p, 62, &overflow) - 1;
    if (*p++ != '\t') goto err_ret;
    if (c->mpos < 0 && c->mtid >= 0) {
        _parse_warn(1, "mapped mate cannot have zero coordinate; treated as unmapped");
        c->mtid = -1;
    }
    // tlen
    c->isize = hts_str2int(p, &p, 63, &overflow);
    if (*p++ != '\t') goto err_ret;
    _parse_err(overflow, "number outside allowed range");
    // seq
    q = _read_token(p);
    if (strcmp(q, "*")) {
        _parse_err(p - q - 1 > INT32_MAX, "read sequence is too long");
        c->l_qseq = p - q - 1;
        hts_pos_t ql = bam_cigar2qlen(c->n_cigar, (uint32_t*)(b->data + c->l_qname));
        _parse_err(c->n_cigar && ql != c->l_qseq, "CIGAR and query sequence are of different length");
        i = (c->l_qseq + 1) >> 1;
        _get_mem(uint8_t, &t, b, i);

        unsigned int lqs2 = c->l_qseq&~1, i;
        for (i = 0; i < lqs2; i+=2)
            t[i>>1] = (seq_nt16_table[(unsigned char)q[i]] << 4) | seq_nt16_table[(unsigned char)q[i+1]];
        for (; i < c->l_qseq; ++i)
            t[i>>1] = seq_nt16_table[(unsigned char)q[i]] << ((~i&1)<<2);
    } else c->l_qseq = 0;
    // qual
    _get_mem(uint8_t, &t, b, c->l_qseq);
    if (p[0] == '*' && (p[1] == '\t' || p[1] == '\0')) {
        memset(t, 0xff, c->l_qseq);
        p += 2;
    } else {
        int failed = 0;
        _parse_err(s->l - (p - s->s) < c->l_qseq
                   || (p[c->l_qseq] != '\t' && p[c->l_qseq] != '\0'),
                   "SEQ and QUAL are of different length");
        COPY_MINUS_N(t, p, 33, c->l_qseq, failed);
        _parse_err(failed, "invalid QUAL character");
        p += c->l_qseq + 1;
    }

    // aux
    if (aux_parse(p, s->s + s->l, b, 0, NULL) < 0)
        goto err_ret;

    if (bam_tag2cigar(b, 1, 1) < 0)
        return -2;
    return 0;

#undef _parse_warn
#undef _parse_err
#undef _get_mem
#undef _read_token
err_ret:
    return -2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
movq 0x10(%rdi), %rbx
andl $0x0, 0x14(%rsp)
movq %rdx, %r14
andl $0x0, 0x40(%rdx)
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movups %xmm0, 0x10(%rdx)
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x4190
movq %rax, %r13
pushq $-0x2
popq %rax
testq %r13, %r13
je 0x21f43
movq %r15, 0x18(%rsp)
movb $0x0, (%r13)
leaq 0x1(%r13), %r15
movq %r15, 0x8(%rsp)
movq %r15, %rbp
subq %rbx, %rbp
cmpq $0x1, %rbp
jg 0x2190a
leaq 0x57fd2(%rip), %rsi     # 0x798c9
leaq 0x57fd6(%rip), %rdx     # 0x798d4
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x110c6
jmp 0x21930
cmpq $0x100, %rbp            # imm = 0x100
jb 0x21930
leaq 0x57faf(%rip), %rsi     # 0x798c9
leaq 0x57fc4(%rip), %rdx     # 0x798e5
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x110c6
jmp 0x21f40
leaq 0x4(%rbp), %rsi
movq %r14, %rdi
callq 0x2200f
testl %eax, %eax
js 0x21f40
movslq 0x40(%r14), %rdi
addq 0x38(%r14), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x43c0
addl 0x40(%r14), %ebp
movl %ebp, 0x40(%r14)
movl %ebp, %eax
negb %al
andb $0x3, %al
movb %al, 0xf(%r14)
movslq %ebp, %rdi
addq 0x38(%r14), %rdi
movzbl %al, %edx
xorl %esi, %esi
callq 0x4260
movzbl 0xf(%r14), %eax
addl %eax, 0x40(%r14)
subl %ebx, %eax
addl %r15d, %eax
movw %ax, 0x12(%r14)
movb (%r15), %al
leal -0x31(%rax), %ecx
cmpb $0x8, %cl
ja 0x219af
leaq 0x8(%rsp), %rsi
pushq $0x10
popq %rdx
leaq 0x14(%rsp), %rcx
movq %r15, %rdi
callq 0x2204d
jmp 0x219c9
cmpb $0x30, %al
jne 0x219c7
cmpb $0x9, 0x2(%r13)
jne 0x21a47
addq $0x2, %r13
movq %r13, 0x8(%rsp)
xorl %eax, %eax
movw %ax, 0x10(%r14)
movq 0x8(%rsp), %r13
leaq 0x1(%r13), %rbx
movq %rbx, 0x8(%rsp)
cmpb $0x9, (%r13)
jne 0x21f40
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x4190
testq %rax, %rax
je 0x21f40
movq %rax, %r15
movb $0x0, (%rax)
incq %r15
movq %r15, 0x8(%rsp)
cmpb $0x2a, (%rbx)
jne 0x21a19
cmpb $0x0, 0x2(%r13)
je 0x21ac3
cmpl $0x0, (%r12)
je 0x21a73
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6cf38
movl %eax, 0x8(%r14)
cmpl $-0x2, %eax
jg 0x21a86
leaq 0x57e8e(%rip), %rsi     # 0x798c9
leaq 0x57ed9(%rip), %rdx     # 0x7991b
jmp 0x21921
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x4130
cmpq $0x10000, %rax          # imm = 0x10000
jb 0x219c9
movl $0x1, 0x14(%rsp)
movw $0xffff, %ax            # imm = 0xFFFF
jmp 0x219c9
leaq 0x57e4f(%rip), %rsi     # 0x798c9
leaq 0x57e78(%rip), %rdx     # 0x798f9
jmp 0x21921
testl %eax, %eax
jns 0x21ac8
leaq 0x20(%rsp), %rdi
pushq $0x28
popq %rsi
pushq $0x22
popq %rdx
pushq $-0x1
popq %r8
movq %rbx, %rcx
callq 0x2b8d6
leaq 0x57e21(%rip), %rsi     # 0x798c9
leaq 0x57e83(%rip), %rdx     # 0x79932
pushq $0x3
popq %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x110c6
movq 0x8(%rsp), %r15
jmp 0x21ac8
orl $-0x1, 0x8(%r14)
leaq 0x8(%rsp), %rbx
pushq $0x3e
popq %rdx
leaq 0x14(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2204d
decq %rax
movq %rax, (%r14)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
cmpb $0x9, (%rcx)
jne 0x21f40
movl 0x8(%r14), %ecx
testq %rax, %rax
js 0x21b08
testl %ecx, %ecx
jns 0x21b2e
jmp 0x21b29
testl %ecx, %ecx
js 0x21b29
leaq 0x57db6(%rip), %rsi     # 0x798c9
leaq 0x57e4c(%rip), %rdx     # 0x79966
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x110c6
orl $-0x1, 0x8(%r14)
orb $0x4, 0x10(%r14)
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdi
pushq $0x8
popq %rdx
leaq 0x14(%rsp), %rcx
movq %rbx, %rsi
callq 0x2204d
movb %al, 0xe(%r14)
movq (%rbx), %rax
leaq 0x1(%rax), %rdi
movq %rdi, (%rbx)
cmpb $0x9, (%rax)
jne 0x21f40
cmpb $0x2a, (%rdi)
jne 0x21bb9
movzwl 0x10(%r14), %eax
testb $0x4, %al
jne 0x21b8d
leaq 0x57d57(%rip), %rsi     # 0x798c9
leaq 0x57e2b(%rip), %rdx     # 0x799a4
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x110c6
movzwl 0x10(%r14), %eax
movq 0x8(%rsp), %rdi
orl $0x4, %eax
movw %ax, 0x10(%r14)
pushq $0x9
popq %rsi
callq 0x4190
testq %rax, %rax
je 0x21f40
movq %rax, %r13
movb $0x0, (%rax)
incq %r13
movq %r13, 0x8(%rsp)
pushq $0x1
popq %rsi
jmp 0x21c11
movslq 0x40(%r14), %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x22111
testq %rax, %rax
jle 0x21f40
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %r13
movq %r13, 0x8(%rsp)
cmpb $0x9, (%rax)
jne 0x21f40
testb $0x4, 0x10(%r14)
jne 0x21c06
addq 0x38(%r14), %rbx
movl 0x14(%r14), %edi
movq %rbx, %rsi
callq 0x1e4e1
movq %rax, %rsi
jmp 0x21c09
pushq $0x1
popq %rsi
cmpq $0x1, %rsi
adcq $0x0, %rsi
movabsq $0x7fffffff7fffffff, %rax # imm = 0x7FFFFFFF7FFFFFFF
subq %rsi, %rax
movq (%r14), %rdi
cmpq %rdi, %rax
jle 0x21c72
addq %rdi, %rsi
callq 0x1e461
movw %ax, 0xc(%r14)
pushq $0x9
popq %rsi
movq %r13, %rdi
callq 0x4190
testq %rax, %rax
je 0x21f40
movb $0x0, (%rax)
incq %rax
movq %rax, 0x8(%rsp)
movzbl (%r13), %eax
cmpl $0x2a, %eax
je 0x21c85
cmpl $0x3d, %eax
jne 0x21c8c
cmpb $0x0, 0x1(%r13)
jne 0x21c8c
movl 0x8(%r14), %eax
movl %eax, 0x1c(%r14)
jmp 0x21ce1
leaq 0x57c50(%rip), %rsi     # 0x798c9
leaq 0x57d58(%rip), %rdx     # 0x799d8
jmp 0x21921
cmpb $0x0, 0x1(%r13)
je 0x21cdc
movq %r12, %rdi
movq %r13, %rsi
callq 0x6cf38
movl %eax, 0x1c(%r14)
cmpl $-0x2, %eax
jle 0x21a34
testl %eax, %eax
jns 0x21ce1
leaq 0x20(%rsp), %rdi
pushq $0x28
popq %rsi
pushq $0x22
popq %rdx
pushq $-0x1
popq %r8
movq %r13, %rcx
callq 0x2b8d6
leaq 0x57c03(%rip), %rsi     # 0x798c9
leaq 0x57d37(%rip), %rdx     # 0x79a04
pushq $0x3
popq %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x110c6
jmp 0x21ce1
orl $-0x1, 0x1c(%r14)
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdi
pushq $0x3e
popq %rdx
leaq 0x14(%rsp), %rcx
movq %rbx, %rsi
callq 0x2204d
decq %rax
movq %rax, 0x20(%r14)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdi
movq %rdi, (%rbx)
cmpb $0x9, (%rcx)
jne 0x21f40
testq %rax, %rax
jns 0x21d41
cmpl $0x0, 0x1c(%r14)
js 0x21d41
leaq 0x57ba3(%rip), %rsi     # 0x798c9
leaq 0x57d10(%rip), %rdx     # 0x79a3d
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x110c6
orl $-0x1, 0x1c(%r14)
movq 0x8(%rsp), %rdi
leaq 0x8(%rsp), %rbx
pushq $0x3f
popq %rdx
leaq 0x14(%rsp), %rcx
movq %rbx, %rsi
callq 0x22273
movq %rax, 0x28(%r14)
movq (%rbx), %r15
leaq 0x1(%r15), %r12
movq %r12, (%rbx)
cmpb $0x9, (%r15)
jne 0x21f40
cmpl $0x0, 0x14(%rsp)
je 0x21d88
leaq 0x57b4d(%rip), %rsi     # 0x798c9
leaq 0x57cf7(%rip), %rdx     # 0x79a7a
jmp 0x21921
pushq $0x9
popq %rsi
movq %r12, %rdi
callq 0x4190
testq %rax, %rax
je 0x21f40
movq %rax, %rbx
movb $0x0, (%rax)
incq %rbx
movq %rbx, 0x8(%rsp)
cmpb $0x2a, (%r12)
jne 0x21dbc
cmpb $0x0, 0x2(%r15)
je 0x21eb3
movq %r12, %rax
notq %rax
addq %rax, %rbx
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, %rbx
jl 0x21de2
leaq 0x57af3(%rip), %rsi     # 0x798c9
leaq 0x57cba(%rip), %rdx     # 0x79a97
jmp 0x21921
movl %ebx, 0x18(%r14)
movl 0x14(%r14), %ebp
movzwl 0x12(%r14), %esi
addq 0x38(%r14), %rsi
movl %ebp, %edi
callq 0x1e4a9
testl %ebp, %ebp
je 0x21e19
movslq %ebx, %rcx
cmpq %rcx, %rax
je 0x21e19
leaq 0x57abc(%rip), %rsi     # 0x798c9
leaq 0x578f0(%rip), %rdx     # 0x79704
jmp 0x21921
incl %ebx
sarl %ebx
movslq %ebx, %rsi
movq %r14, %rdi
callq 0x2200f
testl %eax, %eax
js 0x21f40
movslq 0x40(%r14), %rcx
movq %rcx, %rax
addq 0x38(%r14), %rax
addl %ecx, %ebx
movl %ebx, 0x40(%r14)
movl 0x18(%r14), %ecx
andl $-0x2, %ecx
xorl %edx, %edx
leaq 0x55abf(%rip), %rsi     # 0x77910
movq %rax, %r8
xorl %edi, %edi
cmpq %rcx, %rdi
jae 0x21ea5
movzbl 0x1(%r15,%rdi), %r9d
movb (%rsi,%r9), %r9b
shlb $0x4, %r9b
movzbl 0x2(%r15,%rdi), %r10d
orb (%rsi,%r10), %r9b
movb %r9b, (%r8)
addq $0x2, %rdi
addb $0x8, %dl
incq %r8
jmp 0x21e56
movzbl (%r12,%rdi), %ecx
movb (%rsi,%rcx), %r8b
movl %edx, %ecx
notb %cl
andb $0x4, %cl
shlb %cl, %r8b
movq %rdi, %rcx
shrq %rcx
movb %r8b, (%rax,%rcx)
incq %rdi
addb $0x4, %dl
movl 0x18(%r14), %ecx
cmpq %rcx, %rdi
jb 0x21e82
movslq %ecx, %rsi
jmp 0x21eba
andl $0x0, 0x18(%r14)
xorl %esi, %esi
movq %r14, %rdi
callq 0x2200f
testl %eax, %eax
js 0x21f40
movslq 0x40(%r14), %rdi
movl 0x18(%r14), %eax
leal (%rdi,%rax), %ecx
movslq %eax, %rdx
addq 0x38(%r14), %rdi
movl %ecx, 0x40(%r14)
movq 0x8(%rsp), %rcx
cmpb $0x2a, (%rcx)
jne 0x21f52
movzbl 0x1(%rcx), %esi
cmpl $0x9, %esi
je 0x21ef3
testl %esi, %esi
jne 0x21f52
movl $0xff, %esi
callq 0x4260
movq 0x8(%rsp), %rdi
addq $0x2, %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
addq (%rax), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x22393
testl %eax, %eax
pushq $-0x2
popq %rax
js 0x21f43
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %edx, %esi
callq 0x1e8b9
sarl $0x1f, %eax
andl $-0x2, %eax
jmp 0x21f43
pushq $-0x2
popq %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsp), %r8
movq (%r8), %rsi
subq %rcx, %rsi
addq 0x10(%r8), %rsi
cmpq %rdx, %rsi
jb 0x21fa2
movzbl (%rcx,%rdx), %edx
testl %edx, %edx
je 0x21f73
cmpl $0x9, %edx
jne 0x21fa2
movl %eax, %edx
sarl $0x3, %edx
movslq %edx, %rsi
xorl %edx, %edx
movabsq $-0x2121212121212121, %r8 # imm = 0xDEDEDEDEDEDEDEDF
xorl %r9d, %r9d
cmpq %r9, %rsi
je 0x21fb5
movq (%rcx,%r9,8), %r10
addq %r8, %r10
movq %r10, (%rdi,%r9,8)
orq %r10, %rdx
incq %r9
jmp 0x21f8a
leaq 0x57920(%rip), %rsi     # 0x798c9
leaq 0x57b01(%rip), %rdx     # 0x79ab1
jmp 0x21921
shlq $0x3, %rsi
cltq
cmpq %rax, %rsi
jae 0x21fdc
movq 0x8(%rsp), %rax
movb (%rax,%rsi), %al
addb $-0x21, %al
movb %al, (%rdi,%rsi)
movzbl %al, %eax
orq %rax, %rdx
incq %rsi
movl 0x18(%r14), %eax
jmp 0x21fb9
movabsq $-0x7f7f7f7f7f7f7f80, %rcx # imm = 0x8080808080808080
testq %rcx, %rdx
je 0x21ffe
leaq 0x578d7(%rip), %rsi     # 0x798c9
leaq 0x57add(%rip), %rdx     # 0x79ad6
jmp 0x21921
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax), %rdi
incq %rdi
jmp 0x21f06