// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/sam_mods.c
// Function: bam_parse_basemod2
int bam_parse_basemod2(const bam1_t *b, hts_base_mod_state *state,
                       uint32_t flags) {
    // Reset position, else upcoming calls may fail on
    // seq pos - length comparison
    state->seq_pos = 0;
    state->nmods = 0;
    state->flags = flags;

    // Read MM and ML tags
    uint8_t *mm = bam_aux_get(b, "MM");
    if (!mm) mm = bam_aux_get(b, "Mm");
    if (!mm)
        return 0;
    if (mm[0] != 'Z') {
        hts_log_error("%s: MM tag is not of type Z", bam_get_qname(b));
        return -1;
    }

    uint8_t *mi = bam_aux_get(b, "MN");
    if (mi && bam_aux2i(mi) != b->core.l_qseq && b->core.l_qseq) {
        // bam_aux2i with set errno = EINVAL and return 0 if the tag
        // isn't integer, but 0 will be a seq-length mismatch anyway so
        // triggers an error here too.
        hts_log_error("%s: MM/MN data length is incompatible with"
                      " SEQ length", bam_get_qname(b));
        return -1;
    }

    uint8_t *ml = bam_aux_get(b, "ML");
    if (!ml) ml = bam_aux_get(b, "Ml");
    if (ml && (ml[0] != 'B' || ml[1] != 'C')) {
        hts_log_error("%s: ML tag is not of type B,C", bam_get_qname(b));
        return -1;
    }
    uint8_t *ml_end = ml ? ml+6 + le_to_u32(ml+2) : NULL;
    if (ml) ml += 6;

    // Aggregate freqs of ACGTN if reversed, to get final-delta (later)
    int freq[16];
    if (b->core.flag & BAM_FREVERSE)
        seq_freq(b, freq);

    char *cp = (char *)mm+1;
    int mod_num = 0;
    int implicit = 1;
    while (*cp) {
        for (; *cp; cp++) {
            // cp should be [ACGTNU][+-]([a-zA-Z]+|[0-9]+)[.?]?(,\d+)*;
            unsigned char btype = *cp++;

            if (btype != 'A' && btype != 'C' &&
                btype != 'G' && btype != 'T' &&
                btype != 'U' && btype != 'N')
                return -1;
            if (btype == 'U') btype = 'T';

            btype = seq_nt16_table[btype];

            // Strand
            if (*cp != '+' && *cp != '-')
                return -1; // malformed
            char strand = *cp++;

            // List of modification types
            char *ms = cp, *me; // mod code start and end
            char *cp_end = NULL;
            int chebi = 0;
            if (isdigit_c(*cp)) {
                chebi = strtol(cp, &cp_end, 10);
                cp = cp_end;
                ms = cp-1;
            } else {
                while (*cp && isalpha_c(*cp))
                    cp++;
                if (*cp == '\0')
                    return -1;
            }

            me = cp;

            // Optional explicit vs implicit marker
            implicit = 1;
            if (*cp == '.') {
                // default is implicit = 1;
                cp++;
            } else if (*cp == '?') {
                implicit = 0;
                cp++;
            } else if (*cp != ',' && *cp != ';') {
                // parse error
                return -1;
            }

            long delta;
            int n = 0; // nth symbol in a multi-mod string
            int stride = me-ms;
            int ndelta = 0;

            if (b->core.flag & BAM_FREVERSE) {
                // We process the sequence in left to right order,
                // but delta is successive count of bases to skip
                // counting right to left.  This also means the number
                // of bases to skip at left edge is unrecorded (as it's
                // the remainder).
                //
                // To output mods in left to right, we step through the
                // MM list in reverse and need to identify the left-end
                // "remainder" delta.
                int total_seq = 0;
                for (;;) {
                    cp += (*cp == ',');
                    if (*cp == 0 || *cp == ';')
                        break;

                    delta = strtol(cp, &cp_end, 10);
                    if (cp_end == cp) {
                        hts_log_error("%s: Hit end of MM tag. Missing "
                                      "semicolon?", bam_get_qname(b));
                        return -1;
                    }

                    cp = cp_end;
                    total_seq += delta+1;
                    ndelta++;
                }
                delta = freq[seqi_rc[btype]] - total_seq; // remainder
            } else {
                delta = *cp == ','
                    ? strtol(cp+1, &cp_end, 10)
                    : 0;
                if (!cp_end) {
                    // empty list
                    delta = INT_MAX;
                    cp_end = cp;
                }
            }
            // Now delta is first in list or computed remainder,
            // and cp_end is either start or end of the MM list.
            while (ms < me) {
                state->type     [mod_num] = chebi ? -chebi : *ms;
                state->strand   [mod_num] = (strand == '-');
                state->canonical[mod_num] = btype;
                state->MLstride [mod_num] = stride;
                state->implicit [mod_num] = implicit;

                if (delta < 0) {
                    hts_log_error("%s: MM tag refers to bases beyond sequence "
                                  "length", bam_get_qname(b));
                    return -1;
                }
                state->MMcount  [mod_num] = delta;
                if (b->core.flag & BAM_FREVERSE) {
                    state->MM   [mod_num] = me+1;
                    state->MMend[mod_num] = cp_end;
                    state->ML   [mod_num] = ml ? ml+n +(ndelta-1)*stride: NULL;
                } else {
                    state->MM   [mod_num] = cp_end;
                    state->MMend[mod_num] = NULL;
                    state->ML   [mod_num] = ml ? ml+n : NULL;
                }

                if (++mod_num >= MAX_BASE_MOD) {
                    hts_log_error("%s: Too many base modification types",
                                  bam_get_qname(b));
                    return -1;
                }
                ms++; n++;
            }

            // Skip modification deltas
            if (ml) {
                if (b->core.flag & BAM_FREVERSE) {
                    ml += ndelta*stride;
                } else {
                    while (*cp && *cp != ';') {
                        if (*cp == ',')
                            ml+=stride;
                        cp++;
                    }
                }
                if (ml > ml_end) {
                    hts_log_error("%s: Insufficient number of entries in ML "
                                  "tag", bam_get_qname(b));
                    return -1;
                }
            } else {
                // cp_end already known if FREVERSE
                if (cp_end && (b->core.flag & BAM_FREVERSE))
                    cp = cp_end;
                else
                    while (*cp && *cp != ';')
                        cp++;
            }
            if (!*cp) {
                hts_log_error("%s: Hit end of MM tag. Missing semicolon?",
                              bam_get_qname(b));
                return -1;
            }
        }
    }
    if (ml && ml != ml_end) {
        hts_log_error("%s: Too many entries in ML tag", bam_get_qname(b));
        return -1;
    }

    state->nmods = mod_num;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0x2d00(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x2d04(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2d08(%rax)
movq -0x10(%rbp), %rdi
leaq 0xa994a(%rip), %rsi     # 0xf2e74
callq 0x3e760
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4954e
movq -0x10(%rbp), %rdi
leaq 0xa9932(%rip), %rsi     # 0xf2e77
callq 0x3e760
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x49561
movl $0x0, -0x4(%rbp)
jmp 0x4a017
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5a, %eax
je 0x4959b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa98f9(%rip), %rsi     # 0xf2e7a
leaq 0xa9905(%rip), %rdx     # 0xf2e8d
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movq -0x10(%rbp), %rdi
leaq 0xa9903(%rip), %rsi     # 0xf2ea9
callq 0x3e760
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x49604
movq -0x30(%rbp), %rdi
callq 0x419b0
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
je 0x49604
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x49604
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa9890(%rip), %rsi     # 0xf2e7a
leaq 0xa98bb(%rip), %rdx     # 0xf2eac
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movq -0x10(%rbp), %rdi
leaq 0xa98d3(%rip), %rsi     # 0xf2ee2
callq 0x3e760
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x49633
movq -0x10(%rbp), %rdi
leaq 0xa98bb(%rip), %rsi     # 0xf2ee5
callq 0x3e760
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x49681
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x42, %eax
jne 0x49653
movq -0x38(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x43, %eax
je 0x49681
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa9813(%rip), %rsi     # 0xf2e7a
leaq 0xa987a(%rip), %rdx     # 0xf2ee8
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
cmpq $0x0, -0x38(%rbp)
je 0x496bb
movq -0x38(%rbp), %rax
addq $0x6, %rax
movq %rax, -0xe0(%rbp)
movq -0x38(%rbp), %rdi
addq $0x2, %rdi
callq 0x4a030
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
jmp 0x496c6
xorl %eax, %eax
movq %rax, -0xd8(%rbp)
jmp 0x496c6
movq -0xd8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x496e4
movq -0x38(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x49701
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4a040
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
movl $0x1, -0x90(%rbp)
movq -0x88(%rbp), %rax
cmpb $0x0, (%rax)
je 0x49fc4
jmp 0x49736
movq -0x88(%rbp), %rax
cmpb $0x0, (%rax)
je 0x49fbf
movq -0x88(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x88(%rbp)
movb (%rax), %al
movb %al, -0x91(%rbp)
movzbl -0x91(%rbp), %eax
cmpl $0x41, %eax
je 0x497b7
movzbl -0x91(%rbp), %eax
cmpl $0x43, %eax
je 0x497b7
movzbl -0x91(%rbp), %eax
cmpl $0x47, %eax
je 0x497b7
movzbl -0x91(%rbp), %eax
cmpl $0x54, %eax
je 0x497b7
movzbl -0x91(%rbp), %eax
cmpl $0x55, %eax
je 0x497b7
movzbl -0x91(%rbp), %eax
cmpl $0x4e, %eax
je 0x497b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movzbl -0x91(%rbp), %eax
cmpl $0x55, %eax
jne 0x497ca
movb $0x54, -0x91(%rbp)
movzbl -0x91(%rbp), %eax
movl %eax, %ecx
leaq 0xa6356(%rip), %rax     # 0xefb30
movb (%rax,%rcx), %al
movb %al, -0x91(%rbp)
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x4980d
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x4980d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movq -0x88(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x88(%rbp)
movb (%rax), %al
movb %al, -0x92(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0xb0(%rbp)
movl $0x0, -0xb4(%rbp)
movq -0x88(%rbp), %rax
movsbl (%rax), %edi
callq 0x4a0f0
cmpl $0x0, %eax
je 0x498a1
movq -0x88(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa, %edx
callq 0x46a0
movl %eax, -0xb4(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x49912
jmp 0x498a3
movq -0x88(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xe1(%rbp)
je 0x498d5
movq -0x88(%rbp), %rax
movsbl (%rax), %edi
callq 0x4a120
cmpl $0x0, %eax
setne %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x498e1
jmp 0x498f5
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x498a3
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x49910
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
jmp 0x49912
movq -0x88(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x1, -0x90(%rbp)
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x4994d
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x499a8
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x4997a
movl $0x0, -0x90(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x499a6
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x499a4
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x499a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
jmp 0x499a6
jmp 0x499a8
movl $0x0, -0xc4(%rbp)
movq -0xa8(%rbp), %rax
movq -0xa0(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0xc8(%rbp)
movl $0x0, -0xcc(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x49b00
movl $0x0, -0xd0(%rbp)
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x88(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x49a38
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x49a3d
jmp 0x49ad7
movq -0x88(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa, %edx
callq 0x46a0
movq %rax, -0xc0(%rbp)
movq -0xb0(%rbp), %rax
cmpq -0x88(%rbp), %rax
jne 0x49a9a
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa93fa(%rip), %rsi     # 0xf2e7a
leaq 0xa947f(%rip), %rdx     # 0xf2f06
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0xc0(%rbp), %rcx
addq $0x1, %rcx
movslq -0xd0(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xd0(%rbp)
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x499f1
movzbl -0x91(%rbp), %eax
movl %eax, %ecx
leaq 0xc3d89(%rip), %rax     # 0x10d870
movslq (%rax,%rcx,4), %rax
movl -0x80(%rbp,%rax,4), %eax
subl -0xd0(%rbp), %eax
cltq
movq %rax, -0xc0(%rbp)
jmp 0x49b72
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x49b34
movq -0x88(%rbp), %rdi
addq $0x1, %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa, %edx
callq 0x46a0
movq %rax, -0xf0(%rbp)
jmp 0x49b3f
xorl %eax, %eax
movq %rax, -0xf0(%rbp)
jmp 0x49b3f
movq -0xf0(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0x49b70
movq $0x7fffffff, -0xc0(%rbp) # imm = 0x7FFFFFFF
movq -0x88(%rbp), %rax
movq %rax, -0xb0(%rbp)
jmp 0x49b72
jmp 0x49b74
movq -0xa0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
jae 0x49e0c
cmpl $0x0, -0xb4(%rbp)
je 0x49ba1
xorl %eax, %eax
subl -0xb4(%rbp), %eax
movl %eax, -0xf4(%rbp)
jmp 0x49bb1
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xf4(%rbp)
movl -0xf4(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movsbl -0x92(%rbp), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movb %dl, 0x800(%rax,%rcx)
movzbl -0x91(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movl %edx, 0x400(%rax,%rcx,4)
movl -0xc8(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movl %edx, 0x2500(%rax,%rcx,4)
movl -0x90(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movl %edx, 0x2900(%rax,%rcx,4)
cmpq $0x0, -0xc0(%rbp)
jge 0x49c6c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa9228(%rip), %rsi     # 0xf2e7a
leaq 0xa92d7(%rip), %rdx     # 0xf2f30
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movq -0xc0(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movl %edx, 0x900(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x49d2e
movq -0xa8(%rbp), %rdx
addq $0x1, %rdx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movq %rdx, 0xd00(%rax,%rcx,8)
movq -0xb0(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movq %rdx, 0x1500(%rax,%rcx,8)
cmpq $0x0, -0x38(%rbp)
je 0x49d07
movq -0x38(%rbp), %rax
movslq -0xc4(%rbp), %rcx
addq %rcx, %rax
movl -0xcc(%rbp), %ecx
subl $0x1, %ecx
imull -0xc8(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x100(%rbp)
jmp 0x49d12
xorl %eax, %eax
movq %rax, -0x100(%rbp)
jmp 0x49d12
movq -0x100(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movq %rdx, 0x1d00(%rax,%rcx,8)
jmp 0x49da2
movq -0xb0(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movq %rdx, 0xd00(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movq $0x0, 0x1500(%rax,%rcx,8)
cmpq $0x0, -0x38(%rbp)
je 0x49d7d
movq -0x38(%rbp), %rax
movslq -0xc4(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x108(%rbp)
jmp 0x49d88
xorl %eax, %eax
movq %rax, -0x108(%rbp)
jmp 0x49d88
movq -0x108(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movq %rdx, 0x1d00(%rax,%rcx,8)
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
cmpl $0x100, %eax            # imm = 0x100
jl 0x49de6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa90ae(%rip), %rsi     # 0xf2e7a
leaq 0xa918f(%rip), %rdx     # 0xf2f62
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x49b74
cmpq $0x0, -0x38(%rbp)
je 0x49ef2
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x49e44
movl -0xcc(%rbp), %ecx
imull -0xc8(%rbp), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x49eb8
jmp 0x49e46
movq -0x88(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x109(%rbp)
je 0x49e73
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
setne %al
movb %al, -0x109(%rbp)
movb -0x109(%rbp), %al
testb $0x1, %al
jne 0x49e7f
jmp 0x49eb6
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x49ea2
movl -0xc8(%rbp), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x49e46
jmp 0x49eb8
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jbe 0x49ef0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa8fa4(%rip), %rsi     # 0xf2e7a
leaq 0xa90aa(%rip), %rdx     # 0xf2f87
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
jmp 0x49f6f
cmpq $0x0, -0xb0(%rbp)
je 0x49f1c
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x49f1c
movq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x49f6d
jmp 0x49f1e
movq -0x88(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x10a(%rbp)
je 0x49f4b
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
setne %al
movb %al, -0x10a(%rbp)
movb -0x10a(%rbp), %al
testb $0x1, %al
jne 0x49f57
jmp 0x49f6b
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x49f1e
jmp 0x49f6d
jmp 0x49f6f
movq -0x88(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x49fa6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa8eeb(%rip), %rsi     # 0xf2e7a
leaq 0xa8f70(%rip), %rdx     # 0xf2f06
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
jmp 0x49fa8
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x49736
jmp 0x49724
cmpq $0x0, -0x38(%rbp)
je 0x4a000
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x4a000
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edi
leaq 0xa8e91(%rip), %rsi     # 0xf2e7a
leaq 0xa8fc4(%rip), %rdx     # 0xf2fb4
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a017
movl -0x8c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2d04(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)