// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/sam.c
// Function: bam_sym_lookup
static int bam_sym_lookup(void *data, char *str, char **end,
                          hts_expr_val_t *res) {
    hb_pair *hb = (hb_pair *)data;
    const bam1_t *b = hb->b;

    res->is_str = 0;
    switch(*str) {
    case 'c':
        if (memcmp(str, "cigar", 5) == 0) {
            *end = str+5;
            res->is_str = 1;
            ks_clear(&res->s);
            uint32_t *cigar = bam_get_cigar(b);
            int i, n = b->core.n_cigar, r = 0;
            if (n) {
                for (i = 0; i < n; i++) {
                    r |= kputw (bam_cigar_oplen(cigar[i]), &res->s) < 0;
                    r |= kputc_(bam_cigar_opchr(cigar[i]), &res->s) < 0;
                }
                r |= kputs("", &res->s) < 0;
            } else {
                r |= kputs("*", &res->s) < 0;
            }
            return r ? -1 : 0;
        }
        break;

    case 'e':
        if (memcmp(str, "endpos", 6) == 0) {
            *end = str+6;
            res->d = bam_endpos(b);
            return 0;
        }
        break;

    case 'f':
        if (memcmp(str, "flag", 4) == 0) {
            str = *end = str+4;
            if (*str != '.') {
                res->d = b->core.flag;
                return 0;
            } else {
                str++;
                if (!memcmp(str, "paired", 6)) {
                    *end = str+6;
                    res->d = b->core.flag & BAM_FPAIRED;
                    return 0;
                } else if (!memcmp(str, "proper_pair", 11)) {
                    *end = str+11;
                    res->d = b->core.flag & BAM_FPROPER_PAIR;
                    return 0;
                } else if (!memcmp(str, "unmap", 5)) {
                    *end = str+5;
                    res->d = b->core.flag & BAM_FUNMAP;
                    return 0;
                } else if (!memcmp(str, "munmap", 6)) {
                    *end = str+6;
                    res->d = b->core.flag & BAM_FMUNMAP;
                    return 0;
                } else if (!memcmp(str, "reverse", 7)) {
                    *end = str+7;
                    res->d = b->core.flag & BAM_FREVERSE;
                    return 0;
                } else if (!memcmp(str, "mreverse", 8)) {
                    *end = str+8;
                    res->d = b->core.flag & BAM_FMREVERSE;
                    return 0;
                } else if (!memcmp(str, "read1", 5)) {
                    *end = str+5;
                    res->d = b->core.flag & BAM_FREAD1;
                    return 0;
                } else if (!memcmp(str, "read2", 5)) {
                    *end = str+5;
                    res->d = b->core.flag & BAM_FREAD2;
                    return 0;
                } else if (!memcmp(str, "secondary", 9)) {
                    *end = str+9;
                    res->d = b->core.flag & BAM_FSECONDARY;
                    return 0;
                } else if (!memcmp(str, "qcfail", 6)) {
                    *end = str+6;
                    res->d = b->core.flag & BAM_FQCFAIL;
                    return 0;
                } else if (!memcmp(str, "dup", 3)) {
                    *end = str+3;
                    res->d = b->core.flag & BAM_FDUP;
                    return 0;
                } else if (!memcmp(str, "supplementary", 13)) {
                    *end = str+13;
                    res->d = b->core.flag & BAM_FSUPPLEMENTARY;
                    return 0;
                } else {
                    hts_log_error("Unrecognised flag string");
                    return -1;
                }
            }
        }
        break;

    case 'h':
        if (memcmp(str, "hclen", 5) == 0) {
            int hclen = 0;
            uint32_t *cigar = bam_get_cigar(b);
            uint32_t ncigar = b->core.n_cigar;

            // left
            if (ncigar > 0 && bam_cigar_op(cigar[0]) == BAM_CHARD_CLIP)
                hclen = bam_cigar_oplen(cigar[0]);

            // right
            if (ncigar > 1 && bam_cigar_op(cigar[ncigar-1]) == BAM_CHARD_CLIP)
                hclen += bam_cigar_oplen(cigar[ncigar-1]);

            *end = str+5;
            res->d = hclen;
            return 0;
        }
        break;

    case 'l':
        if (memcmp(str, "library", 7) == 0) {
            *end = str+7;
            res->is_str = 1;
            const char *lib = bam_get_library(hb->h, b);
            kputs(lib ? lib : "", ks_clear(&res->s));
            return 0;
        }
        break;

    case 'm':
        if (memcmp(str, "mapq", 4) == 0) {
            *end = str+4;
            res->d = b->core.qual;
            return 0;
        } else if (memcmp(str, "mpos", 4) == 0) {
            *end = str+4;
            res->d = b->core.mpos+1;
            return 0;
        } else if (memcmp(str, "mrname", 6) == 0) {
            *end = str+6;
            res->is_str = 1;
            const char *rn = sam_hdr_tid2name(hb->h, b->core.mtid);
            kputs(rn ? rn : "*", ks_clear(&res->s));
            return 0;
        } else if (memcmp(str, "mrefid", 6) == 0) {
            *end = str+6;
            res->d = b->core.mtid;
            return 0;
        }
        break;

    case 'n':
        if (memcmp(str, "ncigar", 6) == 0) {
            *end = str+6;
            res->d = b->core.n_cigar;
            return 0;
        }
        break;

    case 'p':
        if (memcmp(str, "pos", 3) == 0) {
            *end = str+3;
            res->d = b->core.pos+1;
            return 0;
        } else if (memcmp(str, "pnext", 5) == 0) {
            *end = str+5;
            res->d = b->core.mpos+1;
            return 0;
        }
        break;

    case 'q':
        if (memcmp(str, "qlen", 4) == 0) {
            *end = str+4;
            res->d = bam_cigar2qlen(b->core.n_cigar, bam_get_cigar(b));
            return 0;
        } else if (memcmp(str, "qname", 5) == 0) {
            *end = str+5;
            res->is_str = 1;
            kputs(bam_get_qname(b), ks_clear(&res->s));
            return 0;
        } else if (memcmp(str, "qual", 4) == 0) {
            *end = str+4;
            ks_clear(&res->s);
            if (ks_resize(&res->s, b->core.l_qseq+1) < 0)
                return -1;
            memcpy(res->s.s, bam_get_qual(b), b->core.l_qseq);
            res->s.l = b->core.l_qseq;
            res->is_str = 1;
            return 0;
        }
        break;

    case 'r':
        if (memcmp(str, "rlen", 4) == 0) {
            *end = str+4;
            res->d = bam_cigar2rlen(b->core.n_cigar, bam_get_cigar(b));
            return 0;
        } else if (memcmp(str, "rname", 5) == 0) {
            *end = str+5;
            res->is_str = 1;
            const char *rn = sam_hdr_tid2name(hb->h, b->core.tid);
            kputs(rn ? rn : "*", ks_clear(&res->s));
            return 0;
        } else if (memcmp(str, "rnext", 5) == 0) {
            *end = str+5;
            res->is_str = 1;
            const char *rn = sam_hdr_tid2name(hb->h, b->core.mtid);
            kputs(rn ? rn : "*", ks_clear(&res->s));
            return 0;
        } else if (memcmp(str, "refid", 5) == 0) {
            *end = str+5;
            res->d = b->core.tid;
            return 0;
        }
        break;

    case 's':
        if (memcmp(str, "seq", 3) == 0) {
            *end = str+3;
            ks_clear(&res->s);
            if (ks_resize(&res->s, b->core.l_qseq+1) < 0)
                return -1;
            nibble2base(bam_get_seq(b), res->s.s, b->core.l_qseq);
            res->s.s[b->core.l_qseq] = 0;
            res->s.l = b->core.l_qseq;
            res->is_str = 1;
            return 0;
        } else if (memcmp(str, "sclen", 5) == 0) {
            int sclen = 0;
            uint32_t *cigar = bam_get_cigar(b);
            int ncigar = b->core.n_cigar;
            int left = 0;

            // left
            if (ncigar > 0
                && bam_cigar_op(cigar[0]) == BAM_CSOFT_CLIP)
                left = 0, sclen += bam_cigar_oplen(cigar[0]);
            else if (ncigar > 1
                     && bam_cigar_op(cigar[0]) == BAM_CHARD_CLIP
                     && bam_cigar_op(cigar[1]) == BAM_CSOFT_CLIP)
                left = 1, sclen += bam_cigar_oplen(cigar[1]);

            // right
            if (ncigar-1 > left
                && bam_cigar_op(cigar[ncigar-1]) == BAM_CSOFT_CLIP)
                sclen += bam_cigar_oplen(cigar[ncigar-1]);
            else if (ncigar-2 > left
                     && bam_cigar_op(cigar[ncigar-1]) == BAM_CHARD_CLIP
                     && bam_cigar_op(cigar[ncigar-2]) == BAM_CSOFT_CLIP)
                sclen += bam_cigar_oplen(cigar[ncigar-2]);

            *end = str+5;
            res->d = sclen;
            return 0;
        }
        break;

    case 't':
        if (memcmp(str, "tlen", 4) == 0) {
            *end = str+4;
            res->d = b->core.isize;
            return 0;
        }
        break;

    case '[':
        if (*str == '[' && str[1] && str[2] && str[3] == ']') {
            /* aux tags */
            *end = str+4;

            uint8_t *aux = bam_aux_get(b, str+1);
            if (aux) {
                // we define the truth of a tag to be its presence, even if 0.
                res->is_true = 1;
                switch (*aux) {
                case 'Z':
                case 'H':
                    res->is_str = 1;
                    kputs((char *)aux+1, ks_clear(&res->s));
                    break;

                case 'A':
                    res->is_str = 1;
                    kputsn((char *)aux+1, 1, ks_clear(&res->s));
                    break;

                case 'i': case 'I':
                case 's': case 'S':
                case 'c': case 'C':
                    res->is_str = 0;
                    res->d = bam_aux2i(aux);
                    break;

                case 'f':
                case 'd':
                    res->is_str = 0;
                    res->d = bam_aux2f(aux);
                    break;

                default:
                    hts_log_error("Aux type '%c not yet supported by filters",
                                  *aux);
                    return -1;
                }
                return 0;

            } else {
                // hence absent tags are always false (and strings)
                res->is_str = 1;
                res->s.l = 0;
                res->d = 0;
                res->is_true = 0;
                return 0;
            }
        }
        break;
    }

    // All successful matches in switch should return 0.
    // So if we didn't match, it's a parse error.
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x8(%rdi), %r15
movb $0x0, (%rcx)
movzbl (%rsi), %eax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
addl $-0x5b, %eax
cmpl $0x19, %eax
ja 0x259ff
movq %rcx, %r11
leaq 0x7506e(%rip), %rcx     # 0x9a08c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, 0x1(%rsi)
je 0x259ff
cmpb $0x0, 0x2(%rsi)
je 0x259ff
cmpb $0x5d, 0x3(%rsi)
jne 0x259ff
movq %r11, %rbx
leaq 0x1(%rsi), %rax
addq $0x4, %rsi
movq %rsi, (%rdx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2c960
testq %rax, %rax
je 0x25a54
movq %rbx, %r8
movb $0x1, 0x1(%rbx)
movzbl (%rax), %ecx
cmpl $0x59, %ecx
jle 0x25a7a
leal -0x63(%rcx), %edx
cmpl $0x6, %edx
ja 0x25ae6
leaq 0x7508b(%rip), %rsi     # 0x9a118
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movb $0x0, (%r8)
movq %rax, %rdi
movq %r8, %rbx
callq 0x2f623
jmp 0x254c9
cmpl $0x6e656c72, (%rsi)     # imm = 0x6E656C72
je 0x25741
movl $0x6d616e72, %eax       # imm = 0x6D616E72
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x65, %ecx
orl %eax, %ecx
je 0x258a1
movl $0x78656e72, %eax       # imm = 0x78656E72
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x74, %ecx
orl %eax, %ecx
je 0x2598c
movl $0x69666572, %eax       # imm = 0x69666572
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x64, %ecx
orl %eax, %ecx
jne 0x259ff
addq $0x5, %rsi
movq %rsi, (%rdx)
cvtsi2sdl 0x8(%r15), %xmm0
jmp 0x259f6
movl $0x656c6368, %eax       # imm = 0x656C6368
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x6e, %ecx
orl %eax, %ecx
jne 0x259ff
movzwl 0x12(%r15), %ecx
addq 0x38(%r15), %rcx
movl 0x14(%r15), %edi
testl %edi, %edi
je 0x259d0
movl (%rcx), %r8d
movl %r8d, %r9d
andl $0xf, %r9d
shrl $0x4, %r8d
xorl %eax, %eax
cmpl $0x5, %r9d
cmovel %r8d, %eax
jmp 0x259d2
cmpl $0x6e656c74, (%rsi)     # imm = 0x6E656C74
jne 0x259ff
addq $0x4, %rsi
movq %rsi, (%rdx)
cvtsi2sdq 0x28(%r15), %xmm0
jmp 0x259f6
movl $0x7262696c, %eax       # imm = 0x7262696C
xorl (%rsi), %eax
movl $0x79726172, %ecx       # imm = 0x79726172
xorl 0x3(%rsi), %ecx
orl %eax, %ecx
jne 0x259ff
addq $0x7, %rsi
movq %rsi, (%rdx)
movq %r11, %rbx
movb $0x1, (%r11)
movq (%rdi), %r14
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x75f33(%rip), %rsi     # 0x9b0e5
movq %r15, %rdi
callq 0x2c960
leaq 0x73b0c(%rip), %r15     # 0x98ccd
testq %rax, %rax
je 0x2522b
incq %rax
leaq 0x75f15(%rip), %rsi     # 0x9b0e5
leaq 0x75f11(%rip), %rdx     # 0x9b0e8
leaq 0x75f0d(%rip), %r8      # 0x9b0eb
leaq 0x20(%rsp), %r9
movq %r14, %rdi
movq %rax, %rcx
callq 0x8b620
testl %eax, %eax
js 0x2522b
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %r14
movl $0x3ff, %r12d           # imm = 0x3FF
cmpq %r12, %rax
cmovbq %rax, %r12
leaq 0x94ab0(%rip), %r15     # 0xb9cc0
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x43c0
movb $0x0, (%r12,%r15)
movq %r14, %rdi
callq 0x45c0
movq %rbx, %r14
movq $0x0, 0x8(%rbx)
movq %r15, %rdi
callq 0x41d0
movq %rax, %r12
addq $0x2, %rax
je 0x25a11
cmpq %rax, 0x10(%r14)
movq %r14, %r8
jae 0x25294
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
xorl %r14d, %r14d
testq %rcx, %rcx
movl $0x0, %r13d
cmoveq %rdx, %r13
addq %rax, %r13
movq 0x18(%r8), %rdi
movq %r13, %rsi
callq 0x4840
testq %rax, %rax
je 0x259ff
movq %rbx, %r8
movq %rax, 0x18(%rbx)
movq %r13, 0x10(%rbx)
movq 0x18(%r8), %rdi
addq 0x8(%r8), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r8, %rbx
callq 0x43c0
addq 0x8(%rbx), %r12
movq %r12, 0x8(%rbx)
movq 0x18(%rbx), %rax
movb $0x0, (%rax,%r12)
jmp 0x259fc
movzwl (%rsi), %eax
xorl $0x6573, %eax           # imm = 0x6573
movzbl 0x2(%rsi), %ecx
xorl $0x71, %ecx
orw %ax, %cx
je 0x25792
movl $0x656c6373, %eax       # imm = 0x656C6373
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x6e, %ecx
orl %eax, %ecx
jne 0x259ff
movzwl 0x12(%r15), %ecx
addq 0x38(%r15), %rcx
movslq 0x14(%r15), %rdi
testq %rdi, %rdi
jle 0x258fd
movl (%rcx), %eax
movl %eax, %r8d
andl $0xf, %r8d
cmpl $0x4, %r8d
jne 0x258fd
shrl $0x4, %eax
jmp 0x25939
cmpl $0x67616c66, (%rsi)     # imm = 0x67616C66
jne 0x259ff
leaq 0x4(%rsi), %rax
movq %rax, (%rdx)
cmpb $0x2e, 0x4(%rsi)
jne 0x258f3
movl $0x72696170, %eax       # imm = 0x72696170
xorl 0x5(%rsi), %eax
movzwl 0x9(%rsi), %ecx
xorl $0x6465, %ecx           # imm = 0x6465
orl %eax, %ecx
je 0x25a66
movabsq $0x705f7265706f7270, %rax # imm = 0x705F7265706F7270
xorq 0x5(%rsi), %rax
movabsq $0x726961705f726570, %rcx # imm = 0x726961705F726570
xorq 0x8(%rsi), %rcx
orq %rax, %rcx
je 0x25abe
movl $0x616d6e75, %eax       # imm = 0x616D6E75
xorl 0x5(%rsi), %eax
movzbl 0x9(%rsi), %ecx
xorl $0x70, %ecx
orl %eax, %ecx
je 0x25ad2
movl $0x6d6e756d, %eax       # imm = 0x6D6E756D
xorl 0x5(%rsi), %eax
movzwl 0x9(%rsi), %ecx
xorl $0x7061, %ecx           # imm = 0x7061
orl %eax, %ecx
je 0x25b0e
movl $0x65766572, %eax       # imm = 0x65766572
xorl 0x5(%rsi), %eax
movl $0x65737265, %ecx       # imm = 0x65737265
xorl 0x8(%rsi), %ecx
orl %eax, %ecx
je 0x25b5a
movabsq $0x657372657665726d, %rax # imm = 0x657372657665726D
cmpq %rax, 0x5(%rsi)
je 0x25b6e
movl $0x64616572, %eax       # imm = 0x64616572
movl 0x5(%rsi), %ecx
xorl %eax, %ecx
movzbl 0x9(%rsi), %edi
xorl $0x31, %edi
orl %ecx, %edi
je 0x25b82
xorl 0x5(%rsi), %eax
movzbl 0x9(%rsi), %ecx
xorl $0x32, %ecx
orl %eax, %ecx
je 0x25b96
movabsq $0x7261646e6f636573, %rax # imm = 0x7261646E6F636573
xorq 0x5(%rsi), %rax
movzbl 0xd(%rsi), %ecx
xorq $0x79, %rcx
orq %rax, %rcx
je 0x25bac
movl $0x61666371, %eax       # imm = 0x61666371
xorl 0x5(%rsi), %eax
movzwl 0x9(%rsi), %ecx
xorl $0x6c69, %ecx           # imm = 0x6C69
orl %eax, %ecx
je 0x25bc2
movzwl 0x5(%rsi), %eax
xorl $0x7564, %eax           # imm = 0x7564
movzbl 0x7(%rsi), %ecx
xorl $0x70, %ecx
orw %ax, %cx
je 0x25bd8
movabsq $0x656d656c70707573, %rax # imm = 0x656D656C70707573
xorq 0x5(%rsi), %rax
movabsq $0x797261746e656d65, %rcx # imm = 0x797261746E656D65
xorq 0xa(%rsi), %rcx
orq %rax, %rcx
je 0x25bee
leaq 0x75bc0(%rip), %rsi     # 0x9b041
leaq 0x75bc8(%rip), %rdx     # 0x9b050
movl $0x1, %edi
xorl %eax, %eax
callq 0x14378
jmp 0x259ff
movl $0x70646e65, %eax       # imm = 0x70646E65
xorl (%rsi), %eax
movzwl 0x4(%rsi), %ecx
xorl $0x736f, %ecx           # imm = 0x736F
orl %eax, %ecx
jne 0x259ff
addq $0x6, %rsi
movq %rsi, (%rdx)
movq %r15, %rdi
movq %r11, %rbx
callq 0x23b0a
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x20(%rbx)
jmp 0x259fc
movl $0x61676963, %eax       # imm = 0x61676963
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x72, %ecx
orl %eax, %ecx
jne 0x259ff
addq $0x5, %rsi
movq %rsi, (%rdx)
movb $0x1, (%r11)
leaq 0x8(%r11), %r14
movq $0x0, 0x8(%r11)
movl 0x14(%r15), %eax
testq %rax, %rax
je 0x25a1e
movq %rax, (%rsp)
testl %eax, %eax
jle 0x25a32
movq %r11, 0x18(%rsp)
movzwl 0x12(%r15), %eax
addq 0x38(%r15), %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rsp), %r15
movq %r14, 0x8(%rsp)
movq 0x10(%rsp), %rbx
movl (%rbx,%r12,4), %edi
shrl $0x4, %edi
movq %r14, %rsi
callq 0x32cef
movl %eax, %ebp
movl (%rbx,%r12,4), %eax
andl $0xf, %eax
leaq 0x75a7e(%rip), %rcx     # 0x9afdd
movb (%rax,%rcx), %bl
movq 0x18(%rsp), %r8
movq 0x8(%r8), %rax
incq %rax
cmpq %rax, 0x10(%r8)
jae 0x255bc
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x18(%r8), %rdi
movq %r15, %rsi
movq %r8, %r14
callq 0x4840
testq %rax, %rax
je 0x255ed
movq %rax, 0x18(%r14)
movq %r15, 0x10(%r14)
movq %r14, %r8
movq 0x8(%rsp), %r14
movq (%rsp), %r15
movq 0x8(%r8), %rax
movq 0x18(%r8), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x8(%r8)
movb %bl, (%rcx,%rax)
movl $0x1, %eax
orl %ebp, %eax
shrl $0x1f, %eax
orl %eax, %r13d
incq %r12
cmpq %r12, %r15
jne 0x2553b
jmp 0x25a35
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x8(%rsp), %r14
movq (%rsp), %r15
jmp 0x255d4
cmpl $0x7170616d, (%rsi)     # imm = 0x7170616D
je 0x25828
cmpl $0x736f706d, (%rsi)     # imm = 0x736F706D
je 0x258b8
movl $0x616e726d, %eax       # imm = 0x616E726D
xorl (%rsi), %eax
movzwl 0x4(%rsi), %ecx
xorl $0x656d, %ecx           # imm = 0x656D
orl %eax, %ecx
je 0x25992
movl $0x6665726d, %eax       # imm = 0x6665726D
xorl (%rsi), %eax
movzwl 0x4(%rsi), %ecx
xorl $0x6469, %ecx           # imm = 0x6469
orl %eax, %ecx
jne 0x259ff
addq $0x6, %rsi
movq %rsi, (%rdx)
cvtsi2sdl 0x1c(%r15), %xmm0
jmp 0x259f6
movl $0x6769636e, %eax       # imm = 0x6769636E
xorl (%rsi), %eax
movzwl 0x4(%rsi), %ecx
xorl $0x7261, %ecx           # imm = 0x7261
orl %eax, %ecx
jne 0x259ff
addq $0x6, %rsi
movq %rsi, (%rdx)
movl 0x14(%r15), %eax
jmp 0x258c6
cmpl $0x6e656c71, (%rsi)     # imm = 0x6E656C71
je 0x25839
movl $0x6d616e71, %eax       # imm = 0x6D616E71
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x65, %ecx
orl %eax, %ecx
je 0x258d0
cmpl $0x6c617571, (%rsi)     # imm = 0x6C617571
jne 0x259ff
addq $0x4, %rsi
movq %rsi, (%rdx)
leaq 0x8(%r11), %rdi
movq $0x0, 0x8(%r11)
movslq 0x18(%r15), %rsi
incq %rsi
movq %r11, %rbx
callq 0x2db8c
testl %eax, %eax
js 0x259ff
movl 0x14(%r15), %eax
shll $0x2, %eax
addq 0x38(%r15), %rax
movq 0x18(%rbx), %rdi
movzwl 0x12(%r15), %ecx
movslq 0x18(%r15), %rdx
leal 0x1(%rdx), %esi
sarl %esi
movslq %esi, %rsi
addq %rcx, %rsi
addq %rax, %rsi
callq 0x43c0
jmp 0x25818
movzwl (%rsi), %eax
xorl $0x6f70, %eax           # imm = 0x6F70
movzbl 0x2(%rsi), %ecx
xorl $0x73, %ecx
orw %ax, %cx
je 0x2588c
movl $0x78656e70, %eax       # imm = 0x78656E70
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x74, %ecx
orl %eax, %ecx
jne 0x259ff
addq $0x5, %rsi
jmp 0x258bc
addq $0x4, %rsi
movq %rsi, (%rdx)
movslq 0x14(%r15), %rax
testq %rax, %rax
jle 0x25898
movzwl 0x12(%r15), %edx
addq 0x38(%r15), %rdx
xorl %esi, %esi
xorl %edi, %edi
movl (%rdx,%rsi,4), %r8d
leal (%r8,%r8), %ecx
movl $0x3c1a7, %r9d          # imm = 0x3C1A7
shrl %cl, %r9d
shll $0x1e, %r9d
sarl $0x1f, %r9d
shrl $0x4, %r8d
andl %r9d, %r8d
addq %r8, %rdi
incq %rsi
cmpq %rsi, %rax
jne 0x25762
jmp 0x25882
addq $0x3, %rsi
movq %rsi, (%rdx)
movq $0x0, 0x8(%r11)
movslq 0x18(%r15), %rcx
leaq 0x1(%rcx), %rax
cmpq %rax, 0x10(%r11)
jae 0x257e5
movq %rax, %rdx
shrq %rdx
xorl %r12d, %r12d
cmpl $-0x1, %ecx
cmovgeq %rdx, %r12
addq %rax, %r12
movq 0x18(%r11), %rdi
movq %r12, %rsi
movq %r11, %rbx
callq 0x4840
testq %rax, %rax
je 0x259ff
movq %rbx, %r11
movq %rax, 0x18(%rbx)
movq %r12, 0x10(%rbx)
movl 0x14(%r15), %eax
movl 0x18(%r15), %edx
shll $0x2, %eax
addq 0x38(%r15), %rax
movzwl 0x12(%r15), %edi
addq %rax, %rdi
movq 0x18(%r11), %rsi
leaq 0x93f81(%rip), %rax     # 0xb9788
movq %r11, %rbx
callq *(%rax)
movq 0x18(%rbx), %rax
movslq 0x18(%r15), %rcx
movb $0x0, (%rax,%rcx)
movslq 0x18(%r15), %rax
movq %rax, 0x8(%rbx)
movb $0x1, (%rbx)
jmp 0x259fc
addq $0x4, %rsi
movq %rsi, (%rdx)
movzbl 0xe(%r15), %eax
jmp 0x259f2
addq $0x4, %rsi
movq %rsi, (%rdx)
movslq 0x14(%r15), %rax
testq %rax, %rax
jle 0x25898
movzwl 0x12(%r15), %ecx
addq 0x38(%r15), %rcx
xorl %edx, %edx
movl $0x3c1a7, %esi          # imm = 0x3C1A7
xorl %edi, %edi
movl (%rcx,%rdx,4), %r8d
leal (%r8,%r8), %r9d
btl %r9d, %esi
movl $0x0, %r9d
sbbl %r9d, %r9d
shrl $0x4, %r8d
andl %r9d, %r8d
addq %r8, %rdi
incq %rdx
cmpq %rdx, %rax
jne 0x2585b
cvtsi2sd %rdi, %xmm0
jmp 0x259f6
addq $0x3, %rsi
movq %rsi, (%rdx)
movq (%r15), %rax
jmp 0x258c3
xorpd %xmm0, %xmm0
jmp 0x259f6
addq $0x5, %rsi
movq %rsi, (%rdx)
movb $0x1, (%r11)
movq (%rdi), %rdi
movl 0x8(%r15), %esi
jmp 0x259a4
addq $0x4, %rsi
movq %rsi, (%rdx)
movq 0x20(%r15), %rax
incq %rax
cvtsi2sd %rax, %xmm0
jmp 0x259f6
addq $0x5, %rsi
movq %rsi, (%rdx)
movb $0x1, (%r11)
movq 0x38(%r15), %rdi
movq $0x0, 0x8(%r11)
addq $0x8, %r11
movq %r11, %rsi
jmp 0x259c9
movzwl 0x10(%r15), %eax
jmp 0x259f2
xorl %eax, %eax
cmpl $0x2, %edi
jl 0x25939
movl (%rcx), %r9d
andl $0xf, %r9d
movl $0x0, %r8d
cmpl $0x5, %r9d
jne 0x2593c
movl 0x4(%rcx), %r9d
movl %r9d, %r10d
andl $0xf, %r10d
shrl $0x4, %r9d
xorl %eax, %eax
xorl %r8d, %r8d
cmpl $0x4, %r10d
sete %r8b
cmovel %r9d, %eax
jmp 0x2593c
xorl %r8d, %r8d
leal -0x1(%rdi), %r9d
cmpl %r8d, %r9d
jle 0x25965
movl %r9d, %r9d
movl (%rcx,%r9,4), %r9d
movl %r9d, %r10d
andl $0xf, %r10d
cmpl $0x4, %r10d
jne 0x25965
shrl $0x4, %r9d
addl %r9d, %eax
jmp 0x259eb
leal -0x2(%rdi), %r9d
cmpl %r8d, %r9d
jle 0x259eb
movl -0x4(%rcx,%rdi,4), %edi
andl $0xf, %edi
cmpl $0x5, %edi
jne 0x259eb
movl %r9d, %edi
movl (%rcx,%rdi,4), %ecx
movl %ecx, %edi
andl $0xf, %edi
cmpl $0x4, %edi
je 0x259e6
jmp 0x259eb
addq $0x5, %rsi
jmp 0x25996
addq $0x6, %rsi
movq %rsi, (%rdx)
movb $0x1, (%r11)
movq (%rdi), %rdi
movl 0x1c(%r15), %esi
movq %r11, %rbx
callq 0x8bd81
testq %rax, %rax
leaq 0x75dda(%rip), %rdi     # 0x9b790
cmovneq %rax, %rdi
movq $0x0, 0x8(%rbx)
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x27c76
jmp 0x259fc
xorl %eax, %eax
cmpl $0x2, %edi
jb 0x259eb
decl %edi
movl (%rcx,%rdi,4), %ecx
movl %ecx, %edi
andl $0xf, %edi
cmpl $0x5, %edi
jne 0x259eb
shrl $0x4, %ecx
addl %ecx, %eax
addq $0x5, %rsi
movq %rsi, (%rdx)
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%r11)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4050
movl $0x4b, (%rax)
jmp 0x259fc
leaq 0x75d6b(%rip), %rdi     # 0x9b790
movq %r14, %rsi
callq 0x27c76
shrl $0x1f, %eax
jmp 0x25a4a
xorl %r13d, %r13d
leaq 0x73291(%rip), %rdi     # 0x98ccd
movq %r14, %rsi
callq 0x27c76
shrl $0x1f, %eax
orl %r13d, %eax
xorl %r14d, %r14d
negl %eax
sbbl %r14d, %r14d
jmp 0x259ff
movw $0x1, (%rbx)
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq %r14, 0x20(%rbx)
jmp 0x259ff
addq $0xb, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x1, %eax
jmp 0x259f2
leal -0x41(%rcx), %edx
cmpl $0x8, %edx
ja 0x25b22
leaq 0x74667(%rip), %rsi     # 0x9a0f4
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movb $0x1, (%r8)
incq %rax
movq $0x0, 0x8(%r8)
addq $0x8, %r8
movl $0x1, %esi
movq %rax, %rdi
movq %r8, %rdx
callq 0x27bd9
jmp 0x259fc
addq $0x10, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x2, %eax
jmp 0x259f2
addq $0xa, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x4, %eax
jmp 0x259f2
cmpl $0x73, %ecx
je 0x25b27
cmpl $0x5a, %ecx
jne 0x25b3b
movb $0x1, (%r8)
incq %rax
movq $0x0, 0x8(%r8)
addq $0x8, %r8
movq %rax, %rdi
movq %r8, %rsi
jmp 0x259c9
addq $0xb, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x8, %eax
jmp 0x259f2
cmpl $0x53, %ecx
jne 0x25b3b
movb $0x0, (%r8)
movq %rax, %rdi
movq %r8, %rbx
callq 0x2f5cb
jmp 0x254c4
leaq 0x754ff(%rip), %rsi     # 0x9b041
leaq 0x75572(%rip), %rdx     # 0x9b0bb
movl $0x1, %edi
xorl %eax, %eax
callq 0x14378
jmp 0x259ff
addq $0xc, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x10, %eax
jmp 0x259f2
addq $0xd, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x20, %eax
jmp 0x259f2
addq $0xa, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x40, %eax
jmp 0x259f2
addq $0xa, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x80, %eax
jmp 0x259f2
addq $0xe, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x100, %eax            # imm = 0x100
jmp 0x259f2
addq $0xb, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x200, %eax            # imm = 0x200
jmp 0x259f2
addq $0x8, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x400, %eax            # imm = 0x400
jmp 0x259f2
addq $0x12, %rsi
movq %rsi, (%rdx)
movzwl 0x10(%r15), %eax
andl $0x800, %eax            # imm = 0x800
jmp 0x259f2