// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq 0x8(%rdi), %r12
movb $0x0, (%rcx)
movzbl (%rsi), %eax
pushq $-0x1
popq %rbp
addl $-0x5b, %eax
cmpl $0x19, %eax
ja 0x200b6
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x59a55(%rip), %rcx     # 0x7911c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, 0x1(%r15)
je 0x200b6
cmpb $0x0, 0x2(%r15)
je 0x200b6
cmpb $0x5d, 0x3(%r15)
jne 0x200b6
leaq 0x1(%r15), %rsi
addq $0x4, %r15
movq %r15, (%r14)
movq %r12, %rdi
callq 0x24528
testq %rax, %rax
je 0x1ff23
movb $0x1, 0x1(%rbx)
movzbl (%rax), %ecx
leal -0x41(%rcx), %edx
cmpl $0x8, %edx
jbe 0x1ff4c
leal -0x63(%rcx), %edx
cmpl $0x6, %edx
ja 0x1ff93
leaq 0x59a75(%rip), %rsi     # 0x791a8
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movb $0x0, (%rbx)
movq %rax, %rdi
callq 0x261a0
jmp 0x200af
cmpl $0x6e656c72, (%r15)     # imm = 0x6E656C72
je 0x1fd13
leaq 0x5a890(%rip), %rsi     # 0x79ff0
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1fddc
leaq 0x5a89e(%rip), %rsi     # 0x7a018
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1fe42
leaq 0x5a863(%rip), %rsi     # 0x79ff7
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
addq $0x5, %r15
movq %r15, (%r14)
cvtsi2sdl 0x8(%r12), %xmm0
jmp 0x200af
leaq 0x5a816(%rip), %rsi     # 0x79fd7
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
movl 0x14(%r12), %ecx
xorl %ebp, %ebp
movl $0x0, %eax
testl %ecx, %ecx
je 0x1f81a
movzwl 0x12(%r12), %edx
addq 0x38(%r12), %rdx
movl (%rdx), %esi
movl %esi, %edi
andl $0xf, %edi
shrl $0x4, %esi
xorl %eax, %eax
cmpl $0x5, %edi
cmovel %esi, %eax
cmpl $0x1, %ecx
je 0x1f81a
decl %ecx
movl (%rdx,%rcx,4), %ecx
movl %ecx, %edx
andl $0xf, %edx
cmpl $0x5, %edx
jne 0x1f81a
shrl $0x4, %ecx
addl %ecx, %eax
addq $0x5, %r15
movq %r15, (%r14)
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
jmp 0x200b6
cmpl $0x6e656c74, (%r15)     # imm = 0x6E656C74
jne 0x200b6
addq $0x4, %r15
movq %r15, (%r14)
cvtsi2sdq 0x28(%r12), %xmm0
jmp 0x200af
leaq 0x5a787(%rip), %rsi     # 0x79fdd
pushq $0x7
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
addq $0x7, %r15
movq %r15, (%r14)
movb $0x1, (%rbx)
movq (%r13), %r15
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x5a7c5(%rip), %rsi     # 0x7a053
movq %r12, %rdi
callq 0x24528
leaq 0x584b9(%rip), %r14     # 0x77d56
testq %rax, %rax
je 0x1f907
incq %rax
leaq 0x5a7a7(%rip), %rsi     # 0x7a053
leaq 0x5a7a3(%rip), %rdx     # 0x7a056
leaq 0x5a79f(%rip), %r8      # 0x7a059
leaq 0x10(%rsp), %r9
movq %r15, %rdi
movq %rax, %rcx
callq 0x6cb74
testl %eax, %eax
js 0x1f907
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %r15
movl $0x3ff, %r12d           # imm = 0x3FF
cmpq %r12, %rax
cmovbq %rax, %r12
leaq 0x7f3d4(%rip), %r14     # 0x9ecc0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x43c0
movb $0x0, (%r12,%r14)
movq %r15, %rdi
callq 0x45c0
andq $0x0, 0x8(%rbx)
addq $0x8, %rbx
movq %r14, %rdi
jmp 0x1fe77
leaq 0x5bbb8(%rip), %rsi     # 0x7b4d7
pushq $0x3
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1fd34
leaq 0x5a6e5(%rip), %rsi     # 0x7a01e
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
movzwl 0x12(%r12), %ecx
addq 0x38(%r12), %rcx
movslq 0x14(%r12), %rdx
xorl %esi, %esi
testq %rdx, %rdx
jle 0x1fece
movl (%rcx), %eax
movl %eax, %edi
andl $0xf, %edi
cmpl $0x4, %edi
jne 0x1fea1
shrl $0x4, %eax
jmp 0x1fed0
cmpl $0x67616c66, (%r15)     # imm = 0x67616C66
jne 0x200b6
leaq 0x4(%r15), %rax
movq %rax, (%r14)
cmpb $0x2e, 0x4(%r15)
jne 0x1fe37
leaq 0x5(%r15), %r13
leaq 0x5a5ba(%rip), %rsi     # 0x79f63
pushq $0x6
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1ff37
leaq 0x5a5a7(%rip), %rsi     # 0x79f6a
pushq $0xb
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1ff7e
leaq 0x5a59a(%rip), %rsi     # 0x79f77
pushq $0x5
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1ffc9
leaq 0x5a57f(%rip), %rsi     # 0x79f76
pushq $0x6
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1ffde
leaq 0x5a56d(%rip), %rsi     # 0x79f7e
pushq $0x7
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x20010
movabsq $0x657372657665726d, %rax # imm = 0x657372657665726D
cmpq %rax, (%r13)
je 0x20025
leaq 0x59d08(%rip), %rsi     # 0x79747
pushq $0x5
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x20037
leaq 0x5a52d(%rip), %rsi     # 0x79f86
pushq $0x5
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x20049
leaq 0x5a519(%rip), %rsi     # 0x79f8c
pushq $0x9
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x2005d
leaq 0x5a509(%rip), %rsi     # 0x79f96
pushq $0x6
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x20071
leaq 0x5a4f6(%rip), %rsi     # 0x79f9d
pushq $0x3
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x20085
leaq 0x5a4e0(%rip), %rsi     # 0x79fa1
pushq $0xd
popq %rdx
movq %r13, %rdi
callq 0x44d0
testl %eax, %eax
je 0x20099
leaq 0x5a4d4(%rip), %rsi     # 0x79faf
leaq 0x5a4dc(%rip), %rdx     # 0x79fbe
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x110c6
jmp 0x200b6
leaq 0x5a464(%rip), %rsi     # 0x79f5c
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
addq $0x6, %r15
movq %r15, (%r14)
movq %r12, %rdi
callq 0x1e518
jmp 0x1fe1c
leaq 0x5a3e2(%rip), %rsi     # 0x79f08
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
addq $0x5, %r15
movq %r15, (%r14)
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
addq $0x8, %rbx
movl 0x14(%r12), %r14d
testl %r14d, %r14d
je 0x1fe84
movq %rbx, 0x8(%rsp)
movzwl 0x12(%r12), %r15d
addq 0x38(%r12), %r15
xorl %r13d, %r13d
testl %r14d, %r14d
cmovlel %r13d, %r14d
xorl %r12d, %r12d
movq 0x8(%rsp), %rbx
cmpq %r13, %r14
je 0x1fdf1
movl (%r15,%r13,4), %edi
shrl $0x4, %edi
movq %rbx, %rsi
callq 0x21504
movl %eax, %ebp
movl (%r15,%r13,4), %eax
andl $0xf, %eax
leaq 0x5a3a7(%rip), %rcx     # 0x79f4b
movsbl (%rax,%rcx), %edi
movq %rbx, %rsi
callq 0x24655
orl %ebp, %eax
shrl $0x1f, %eax
orl %eax, %r12d
incq %r13
jmp 0x1fb7c
cmpl $0x7170616d, (%r15)     # imm = 0x7170616D
je 0x1fd9f
cmpl $0x736f706d, (%r15)     # imm = 0x736F706D
je 0x1fe0d
leaq 0x5a411(%rip), %rsi     # 0x79fef
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1fe48
leaq 0x5a3fe(%rip), %rsi     # 0x79ff6
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
addq $0x6, %r15
movq %r15, (%r14)
cvtsi2sdl 0x1c(%r12), %xmm0
jmp 0x200af
leaq 0x5a986(%rip), %rsi     # 0x7a5ab
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
addq $0x6, %r15
movq %r15, (%r14)
movl 0x14(%r12), %eax
jmp 0x1fe1c
cmpl $0x6e656c71, (%r15)     # imm = 0x6E656C71
je 0x1fdb1
leaq 0x5a3ab(%rip), %rsi     # 0x7a008
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1fe26
cmpl $0x6c617571, (%r15)     # imm = 0x6C617571
jne 0x200b6
addq $0x4, %r15
movq %r15, (%r14)
andq $0x0, 0x8(%rbx)
leaq 0x8(%rbx), %rdi
movslq 0x18(%r12), %rsi
incq %rsi
callq 0x24d14
testl %eax, %eax
js 0x200b6
movl 0x14(%r12), %eax
shll $0x2, %eax
addq 0x38(%r12), %rax
movq 0x18(%rbx), %rdi
movzwl 0x12(%r12), %ecx
movslq 0x18(%r12), %rdx
leal 0x1(%rdx), %esi
sarl %esi
movslq %esi, %rsi
addq %rcx, %rsi
addq %rax, %rsi
callq 0x43c0
jmp 0x1fd8e
leaq 0x639ff(%rip), %rsi     # 0x836dc
pushq $0x3
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
je 0x1fdcf
leaq 0x5a306(%rip), %rsi     # 0x79ffd
pushq $0x5
popq %rdx
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x200b6
addq $0x5, %r15
jmp 0x1fe11
addq $0x4, %r15
movq %r15, (%r14)
movl 0x14(%r12), %edi
movzwl 0x12(%r12), %esi
addq 0x38(%r12), %rsi
callq 0x1e4e1
jmp 0x1fe1c
addq $0x3, %r15
movq %r15, (%r14)
andq $0x0, 0x8(%rbx)
leaq 0x8(%rbx), %rdi
movslq 0x18(%r12), %rsi
incq %rsi
callq 0x24d14
testl %eax, %eax
js 0x200b6
movl 0x14(%r12), %eax
movl 0x18(%r12), %edx
shll $0x2, %eax
addq 0x38(%r12), %rax
movzwl 0x12(%r12), %edi
addq %rax, %rdi
movq 0x18(%rbx), %rsi
leaq 0x7ea09(%rip), %rax     # 0x9e788
callq *(%rax)
movq 0x18(%rbx), %rax
movslq 0x18(%r12), %rcx
movb $0x0, (%rax,%rcx)
movslq 0x18(%r12), %rax
movq %rax, 0x8(%rbx)
movb $0x1, (%rbx)
jmp 0x200b4
addq $0x4, %r15
movq %r15, (%r14)
movzbl 0xe(%r12), %eax
jmp 0x200ab
addq $0x4, %r15
movq %r15, (%r14)
movl 0x14(%r12), %edi
movzwl 0x12(%r12), %esi
addq 0x38(%r12), %rsi
callq 0x1e4a9
jmp 0x1fe1c
addq $0x3, %r15
movq %r15, (%r14)
movq (%r12), %rax
jmp 0x1fe19
addq $0x5, %r15
movq %r15, (%r14)
movb $0x1, (%rbx)
movq (%r13), %rdi
movl 0x8(%r12), %esi
jmp 0x1fe5b
leaq 0x57f5e(%rip), %rdi     # 0x77d56
movq 0x8(%rsp), %rsi
callq 0x214c5
shrl $0x1f, %eax
orl %r12d, %eax
jmp 0x1fe96
addq $0x4, %r15
movq %r15, (%r14)
movq 0x20(%r12), %rax
incq %rax
cvtsi2sd %rax, %xmm0
jmp 0x200af
addq $0x5, %r15
movq %r15, (%r14)
movb $0x1, (%rbx)
movq 0x38(%r12), %rdi
jmp 0x1fe6e
movzwl 0x10(%r12), %eax
jmp 0x200ab
addq $0x5, %r15
jmp 0x1fe4c
addq $0x6, %r15
movq %r15, (%r14)
movb $0x1, (%rbx)
movq (%r13), %rdi
movl 0x1c(%r12), %esi
callq 0x6cf95
testq %rax, %rax
leaq 0x5a88e(%rip), %rdi     # 0x7a6f8
cmovneq %rax, %rdi
andq $0x0, 0x8(%rbx)
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x214c5
jmp 0x200b4
leaq 0x5a86d(%rip), %rdi     # 0x7a6f8
movq %rbx, %rsi
callq 0x214c5
shrl $0x1f, %eax
xorl %ebp, %ebp
negl %eax
sbbl %ebp, %ebp
jmp 0x200b6
cmpl $0x1, %edx
je 0x1fece
movl $0x0, %eax
cmpl $0x5, %edi
jne 0x1fed0
movl 0x4(%rcx), %edi
movl %edi, %r8d
andl $0xf, %r8d
shrl $0x4, %edi
xorl %eax, %eax
xorl %esi, %esi
cmpl $0x4, %r8d
sete %sil
cmovel %edi, %eax
jmp 0x1fed0
xorl %eax, %eax
leal -0x1(%rdx), %edi
cmpl %esi, %edi
jle 0x1fef0
movl %edi, %edi
movl (%rcx,%rdi,4), %edi
movl %edi, %r8d
andl $0xf, %r8d
cmpl $0x4, %r8d
jne 0x1fef0
shrl $0x4, %edi
addl %edi, %eax
jmp 0x1ff17
leal -0x2(%rdx), %edi
cmpl %esi, %edi
jle 0x1ff17
movl -0x4(%rcx,%rdx,4), %edx
andl $0xf, %edx
cmpl $0x5, %edx
jne 0x1ff17
movl %edi, %edx
movl (%rcx,%rdx,4), %ecx
movl %ecx, %edx
andl $0xf, %edx
cmpl $0x4, %edx
jne 0x1ff17
shrl $0x4, %ecx
addl %ecx, %eax
addq $0x5, %r15
movq %r15, (%r14)
jmp 0x200ab
movw $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
andq $0x0, 0x20(%rbx)
jmp 0x200b4
addq $0xb, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x1, %eax
jmp 0x200ab
leaq 0x59231(%rip), %rsi     # 0x79184
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movb $0x1, (%rbx)
incq %rax
andq $0x0, 0x8(%rbx)
addq $0x8, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x21461
jmp 0x200b4
addq $0x10, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x2, %eax
jmp 0x200ab
cmpl $0x53, %ecx
je 0x1ffb9
cmpl $0x73, %ecx
je 0x1ffb9
cmpl $0x5a, %ecx
jne 0x1fff3
movb $0x1, (%rbx)
incq %rax
andq $0x0, 0x8(%rbx)
addq $0x8, %rbx
movq %rax, %rdi
jmp 0x1fe77
movb $0x0, (%rbx)
movq %rax, %rdi
callq 0x26135
jmp 0x1fe1c
addq $0xa, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x4, %eax
jmp 0x200ab
addq $0xb, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x8, %eax
jmp 0x200ab
leaq 0x59fb5(%rip), %rsi     # 0x79faf
leaq 0x5a028(%rip), %rdx     # 0x7a029
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x110c6
jmp 0x200b6
addq $0xc, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x10, %eax
jmp 0x200ab
addq $0xd, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x20, %eax
jmp 0x200ab
addq $0xa, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x40, %eax
jmp 0x200ab
addq $0xa, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x80, %eax
jmp 0x200ab
addq $0xe, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x100, %eax            # imm = 0x100
jmp 0x200ab
addq $0xb, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x200, %eax            # imm = 0x200
jmp 0x200ab
addq $0x8, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x400, %eax            # imm = 0x400
jmp 0x200ab
addq $0x12, %r15
movq %r15, (%r14)
movzwl 0x10(%r12), %eax
andl $0x800, %eax            # imm = 0x800
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq