// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/realn.c
// Function: sam_prob_realn
int sam_prob_realn(bam1_t *b, const char *ref, hts_pos_t ref_len, int flag) {
    int k, bw, y, yb, ye, xb, xe, fix_bq = 0, apply_baq = flag & BAQ_APPLY,
        extend_baq = flag & BAQ_EXTEND, redo_baq = flag & BAQ_REDO;
    enum htsRealnFlags system = flag & (0xff << 3);
    hts_pos_t i, x;
    uint32_t *cigar = bam_get_cigar(b);
    bam1_core_t *c = &b->core;

    // d(I) e(M) band
    probaln_par_t conf = { 0.001, 0.1, 10 }; // Illumina

    if (b->core.l_qseq > 1000 || system > BAQ_ILLUMINA) {
        // Params that work well on PacBio CCS 15k.  Unknown if they
        // help other long-read platforms yet, but likely better than
        // the short-read tuned ones.
        //
        // This function has no access to the SAM header.
        // Ideally the calling function would check for e.g.
        // @RG PL = "PACBIO" and DS contains "READTYPE=CCS".
        //
        // In the absense of this, we simply auto-detect via a crude
        // short vs long strategy.
        conf.d = 1e-7;
        conf.e = 1e-1;
    }

    uint8_t *bq = NULL, *zq = NULL, *qual = bam_get_qual(b);
    int *state = NULL;
    if ((c->flag & BAM_FUNMAP) || b->core.l_qseq == 0 || qual[0] == (uint8_t)-1)
        return -1; // do nothing

    // test if BQ or ZQ is present, and make sanity checks
    if ((bq = bam_aux_get(b, "BQ")) != NULL) {
        if (!redo_baq) {
            if (realn_check_tag(bq, HTS_LOG_WARNING, "BQ", b) < 0)
                fix_bq = 1;
        }
        ++bq;
    }
    if ((zq = bam_aux_get(b, "ZQ")) != NULL) {
        if (realn_check_tag(zq, HTS_LOG_ERROR, "ZQ", b) < 0)
            return -4;
        ++zq;
    }
    if (bq && redo_baq)
    {
        bam_aux_del(b, bq-1);
        bq = 0;
    }
    if (bq && zq) { // remove the ZQ tag
        bam_aux_del(b, zq-1);
        zq = 0;
    }
    if (!zq && fix_bq) { // Need to fix invalid BQ tag (by realigning)
        assert(bq != NULL);
        bam_aux_del(b, bq-1);
        bq = 0;
    }

    if (bq || zq) {
        if ((apply_baq && zq) || (!apply_baq && bq)) return -3; // in both cases, do nothing
        if (bq && apply_baq) { // then convert BQ to ZQ
            for (i = 0; i < c->l_qseq; ++i)
                qual[i] = qual[i] + 64 < bq[i]? 0 : qual[i] - ((int)bq[i] - 64);
            *(bq - 3) = 'Z';
        } else if (zq && !apply_baq) { // then convert ZQ to BQ
            for (i = 0; i < c->l_qseq; ++i)
                qual[i] += (int)zq[i] - 64;
            *(zq - 3) = 'B';
        }
        return 0;
    }
    // find the start and end of the alignment
    x = c->pos, y = 0, yb = ye = xb = xe = -1;
    for (k = 0; k < c->n_cigar; ++k) {
        int op, l;
        op = cigar[k]&0xf; l = cigar[k]>>4;
        if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) {
            if (yb < 0) yb = y;
            if (xb < 0) xb = x;
            ye = y + l; xe = x + l;
            x += l; y += l;
        } else if (op == BAM_CSOFT_CLIP || op == BAM_CINS) y += l;
        else if (op == BAM_CDEL) x += l;
        else if (op == BAM_CREF_SKIP) return -1; // do nothing if there is a reference skip
    }
    if (xb == -1) // No matches in CIGAR.
        return -1;
    // set bandwidth and the start and the end
    bw = 7;
    if (abs((xe - xb) - (ye - yb)) > bw)
        bw = abs((xe - xb) - (ye - yb)) + 3;
    conf.bw = bw;

    xb -= yb + bw/2; if (xb < 0) xb = 0;
    xe += c->l_qseq - ye + bw/2;
    if (xe - xb - c->l_qseq > bw)
        xb += (xe - xb - c->l_qseq - bw) / 2, xe -= (xe - xb - c->l_qseq - bw) / 2;
    { // glocal
        uint8_t *seq = bam_get_seq(b);
        uint8_t *tseq; // translated seq A=>0,C=>1,G=>2,T=>3,other=>4
        uint8_t *tref; // translated ref
        uint8_t *q; // Probability of incorrect alignment from probaln_glocal()
        size_t lref = xe > xb ? xe - xb : 1;
        size_t align_lqseq;
        if (extend_baq && lref < c->l_qseq)
            lref = c->l_qseq; // So we can recycle tseq,tref for left,rght below
        // Try to make q,tref,tseq reasonably well aligned
        align_lqseq = ((c->l_qseq + 1) | 0xf) + 1;
        // Overflow check - 3 for *bq, sizeof(int) for *state
        if ((SIZE_MAX - lref) / (3 + sizeof(int)) < align_lqseq) {
            errno = ENOMEM;
            goto fail;
        }

        assert(bq == NULL); // bq was used above, but should now be NULL
        bq = malloc(align_lqseq * 3 + lref);
        if (!bq) goto fail;
        q = bq + align_lqseq;
        tseq = q + align_lqseq;
        tref = tseq + align_lqseq;

        memcpy(bq, qual, c->l_qseq); bq[c->l_qseq] = 0;
        for (i = 0; i < c->l_qseq; ++i)
            tseq[i] = seq_nt16_int[bam_seqi(seq, i)];
        for (i = xb; i < xe; ++i) {
            if (i >= ref_len || ref[i] == '\0') { xe = i; break; }
            tref[i-xb] = seq_nt16_int[seq_nt16_table[(unsigned char)ref[i]]];
        }

        state = malloc(c->l_qseq * sizeof(int));
        if (!state) goto fail;
        if (probaln_glocal(tref, xe-xb, tseq, c->l_qseq, qual,
                           &conf, state, q) == INT_MIN) {
            goto fail;
        }

        if (!extend_baq) { // in this block, bq[] is capped by base quality qual[]
            for (k = 0, x = c->pos, y = 0; k < c->n_cigar; ++k) {
                int op = cigar[k]&0xf, l = cigar[k]>>4;
                if (l == 0) continue;
                if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) {
                    // Sanity check running off the end of the sequence
                    // Can only happen if the alignment is broken
                    if (l > c->l_qseq - y)
                        l = c->l_qseq - y;
                    for (i = y; i < y + l; ++i) {
                        if ((state[i]&3) != 0 || state[i]>>2 != x - xb + (i - y)) bq[i] = 0;
                        else bq[i] = bq[i] < q[i]? bq[i] : q[i];
                    }
                    x += l; y += l;
                } else if (op == BAM_CSOFT_CLIP || op == BAM_CINS) {
                    // Need sanity check here too.
                    if (l > c->l_qseq - y)
                        l = c->l_qseq - y;
                    y += l;
                } else if (op == BAM_CDEL) {
                    x += l;
                }
            }
            for (i = 0; i < c->l_qseq; ++i) bq[i] = qual[i] - bq[i] + 64; // finalize BQ
        } else { // in this block, bq[] is BAQ that can be larger than qual[] (different from the above!)
            // tseq,tref are no longer needed, so we can steal them to avoid mallocs
            uint8_t *left = tseq;
            uint8_t *rght = tref;
            int len = 0;

            for (k = 0, x = c->pos, y = 0; k < c->n_cigar; ++k) {
                int op = cigar[k]&0xf, l = cigar[k]>>4;

                // concatenate alignment matches (including sequence (mis)matches)
                // otherwise 50M50M gives a different result to 100M
                if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) {
                    if ((k + 1) < c->n_cigar) {
                        int next_op = bam_cigar_op(cigar[k + 1]);

                        if (next_op == BAM_CMATCH || next_op == BAM_CEQUAL || next_op == BAM_CDIFF) {
                            len += l;
                            continue;
                        }
                    }

                    // last of M/X/= ops
                    l += len;
                    len = 0;
                }

                if (l == 0) continue;
                if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) {
                    // Sanity check running off the end of the sequence
                    // Can only happen if the alignment is broken
                    if (l > c->l_qseq - y)
                        l = c->l_qseq - y;
                    for (i = y; i < y + l; ++i)
                        bq[i] = ((state[i]&3) != 0 || state[i]>>2 != x - xb + (i - y))? 0 : q[i];
                    for (left[y] = bq[y], i = y + 1; i < y + l; ++i)
                        left[i] = bq[i] > left[i-1]? bq[i] : left[i-1];
                    for (rght[y+l-1] = bq[y+l-1], i = y + l - 2; i >= y; --i)
                        rght[i] = bq[i] > rght[i+1]? bq[i] : rght[i+1];
                    for (i = y; i < y + l; ++i)
                        bq[i] = left[i] < rght[i]? left[i] : rght[i];
                    x += l; y += l;
                } else if (op == BAM_CSOFT_CLIP || op == BAM_CINS) {
                    // Need sanity check here too.
                    if (l > c->l_qseq - y)
                        l = c->l_qseq - y;
                    y += l;
                } else if (op == BAM_CDEL) {
                    x += l;
                }
            }
            for (i = 0; i < c->l_qseq; ++i) bq[i] = 64 + (qual[i] <= bq[i]? 0 : qual[i] - bq[i]); // finalize BQ
        }
        if (apply_baq) {
            for (i = 0; i < c->l_qseq; ++i) qual[i] -= bq[i] - 64; // modify qual
            bam_aux_append(b, "ZQ", 'Z', c->l_qseq + 1, bq);
        } else bam_aux_append(b, "BQ", 'Z', c->l_qseq + 1, bq);
        free(bq); free(state);
    }

    return 0;

 fail:
    free(bq); free(state);
    return -4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x24(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x24(%rbp), %eax
andl $0x2, %eax
movl %eax, -0x4c(%rbp)
movl -0x24(%rbp), %eax
andl $0x4, %eax
movl %eax, -0x50(%rbp)
movl -0x24(%rbp), %eax
andl $0x7f8, %eax            # imm = 0x7F8
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0xc7480(%rip), %rax     # 0xeb4a0
movq %rax, -0x84(%rbp)
movl 0xc747b(%rip), %eax     # 0xeb4a8
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3e8, 0x18(%rax)      # imm = 0x3E8
jg 0x24043
cmpl $0x8, -0x54(%rbp)
jbe 0x24060
movss 0xc7451(%rip), %xmm0    # 0xeb49c
movss %xmm0, -0x84(%rbp)
movss 0xc743d(%rip), %xmm0    # 0xeb498
movss %xmm0, -0x80(%rbp)
movq $0x0, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
addl $0x1, %ecx
sarl %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0x78(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x240ea
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x240ea
movq -0xa0(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x240f6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x251bd
movq -0x10(%rbp), %rdi
leaq 0xc73ab(%rip), %rsi     # 0xeb4ac
callq 0x33000
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x24155
cmpl $0x0, -0x50(%rbp)
jne 0x24143
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x3, %esi
leaq 0xc737c(%rip), %rdx     # 0xeb4ac
callq 0x251d0
cmpl $0x0, %eax
jge 0x24141
movl $0x1, -0x44(%rbp)
jmp 0x24143
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc734f(%rip), %rsi     # 0xeb4af
callq 0x33000
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x241b1
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
leaq 0xc7326(%rip), %rdx     # 0xeb4af
callq 0x251d0
cmpl $0x0, %eax
jge 0x2419f
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x251bd
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x241e0
cmpl $0x0, -0x50(%rbp)
je 0x241e0
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
addq $-0x1, %rsi
callq 0x355d0
movq $0x0, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x24213
cmpq $0x0, -0x98(%rbp)
je 0x24213
movq -0x10(%rbp), %rdi
movq -0x98(%rbp), %rsi
addq $-0x1, %rsi
callq 0x355d0
movq $0x0, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x2426d
cmpl $0x0, -0x44(%rbp)
je 0x2426d
cmpq $0x0, -0x90(%rbp)
je 0x2422f
jmp 0x2424e
leaq 0xc727c(%rip), %rdi     # 0xeb4b2
leaq 0xc7280(%rip), %rsi     # 0xeb4bd
movl $0xa0, %edx
leaq 0xc727c(%rip), %rcx     # 0xeb4c5
callq 0x42e0
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
addq $-0x1, %rsi
callq 0x355d0
movq $0x0, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
jne 0x24285
cmpq $0x0, -0x98(%rbp)
je 0x243e4
cmpl $0x0, -0x48(%rbp)
je 0x24295
cmpq $0x0, -0x98(%rbp)
jne 0x242a5
cmpl $0x0, -0x48(%rbp)
jne 0x242b1
cmpq $0x0, -0x90(%rbp)
je 0x242b1
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x251bd
cmpq $0x0, -0x90(%rbp)
je 0x2436e
cmpl $0x0, -0x48(%rbp)
je 0x2436e
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jge 0x24361
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl $0x40, %eax
movq -0x90(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x24311
xorl %eax, %eax
movl %eax, -0x10c(%rbp)
jmp 0x2433a
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x90(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl $0x40, %ecx
subl %ecx, %eax
movl %eax, -0x10c(%rbp)
movl -0x10c(%rbp), %eax
movb %al, %dl
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x242d1
movq -0x90(%rbp), %rax
movb $0x5a, -0x3(%rax)
jmp 0x243d8
cmpq $0x0, -0x98(%rbp)
je 0x243d6
cmpl $0x0, -0x48(%rbp)
jne 0x243d6
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jge 0x243cb
movq -0x98(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %esi
subl $0x40, %esi
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %edx
addl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x24386
movq -0x98(%rbp), %rax
movb $0x42, -0x3(%rax)
jmp 0x243d8
movl $0x0, -0x4(%rbp)
jmp 0x251bd
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x30(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x78(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x24524
movq -0x70(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0xac(%rbp)
movq -0x70(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0xb0(%rbp)
cmpl $0x0, -0xac(%rbp)
je 0x2446c
cmpl $0x7, -0xac(%rbp)
je 0x2446c
cmpl $0x8, -0xac(%rbp)
jne 0x244bf
cmpl $0x0, -0x34(%rbp)
jge 0x24478
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x24485
movq -0x68(%rbp), %rax
movl %eax, -0x3c(%rbp)
movl -0x30(%rbp), %eax
addl -0xb0(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x68(%rbp), %rax
movslq -0xb0(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x40(%rbp)
movslq -0xb0(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xb0(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x24514
cmpl $0x4, -0xac(%rbp)
je 0x244d1
cmpl $0x1, -0xac(%rbp)
jne 0x244df
movl -0xb0(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x24512
cmpl $0x2, -0xac(%rbp)
jne 0x244f9
movslq -0xb0(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x24510
cmpl $0x3, -0xac(%rbp)
jne 0x2450e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x251bd
jmp 0x24510
jmp 0x24512
jmp 0x24514
jmp 0x24516
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x24419
cmpl $-0x1, -0x3c(%rbp)
jne 0x24536
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x251bd
movl $0x7, -0x2c(%rbp)
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movl -0x38(%rbp), %ecx
subl -0x34(%rbp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl -0x2c(%rbp), %eax
jle 0x24572
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movl -0x38(%rbp), %ecx
subl -0x34(%rbp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
addl $0x3, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x34(%rbp), %ecx
movl -0x2c(%rbp), %eax
movl $0x2, %esi
cltd
idivl %esi
addl %eax, %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x2459d
movl $0x0, -0x3c(%rbp)
movq -0x78(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x38(%rbp), %eax
movl %eax, -0x110(%rbp)
movl -0x2c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x110(%rbp), %eax
addl %ecx, %eax
addl -0x40(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movq -0x78(%rbp), %rcx
subl 0x18(%rcx), %eax
cmpl -0x2c(%rbp), %eax
jle 0x2461a
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movq -0x78(%rbp), %rcx
subl 0x18(%rcx), %eax
subl -0x2c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movq -0x78(%rbp), %rcx
subl 0x18(%rcx), %eax
subl -0x2c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x40(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jle 0x2465c
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movl %eax, -0x114(%rbp)
jmp 0x24669
movl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x24669
movl -0x114(%rbp), %eax
cltq
movq %rax, -0xd8(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x246a1
movq -0xd8(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jae 0x246a1
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x78(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
orl $0xf, %eax
addl $0x1, %eax
cltq
movq %rax, -0xe0(%rbp)
movq $-0x1, %rax
subq -0xd8(%rbp), %rax
movl $0x7, %ecx
xorl %edx, %edx
divq %rcx
cmpq -0xe0(%rbp), %rax
jae 0x246eb
callq 0x4050
movl $0xc, (%rax)
jmp 0x2519e
cmpq $0x0, -0x90(%rbp)
jne 0x246f7
jmp 0x24716
leaq 0xc6e02(%rip), %rdi     # 0xeb500
leaq 0xc6db8(%rip), %rsi     # 0xeb4bd
movl $0xdd, %edx
leaq 0xc6db4(%rip), %rcx     # 0xeb4c5
callq 0x42e0
imulq $0x3, -0xe0(%rbp), %rdi
addq -0xd8(%rbp), %rdi
callq 0x4650
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
jne 0x24740
jmp 0x2519e
movq -0x90(%rbp), %rax
addq -0xe0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
addq -0xe0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
addq -0xe0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x43b0
movq -0x90(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jge 0x24818
movq -0xb8(%rbp), %rax
movq -0x60(%rbp), %rcx
sarq %rcx
movzbl (%rax,%rcx), %eax
movq -0x60(%rbp), %rcx
xorq $-0x1, %rcx
andq $0x1, %rcx
shlq $0x2, %rcx
sarl %cl, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0xc5839(%rip), %rax     # 0xea030
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0xc0(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x247b5
movslq -0x3c(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movslq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jge 0x2489b
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x24848
movq -0x18(%rbp), %rax
movq -0x60(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x24851
movq -0x60(%rbp), %rax
movl %eax, -0x40(%rbp)
jmp 0x2489b
movq -0x18(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xc56aa(%rip), %rax     # 0xe9f10
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xc57bd(%rip), %rax     # 0xea030
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0xc8(%rbp), %rax
movq -0x60(%rbp), %rcx
movslq -0x3c(%rbp), %rsi
subq %rsi, %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x24820
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdi
shlq $0x2, %rdi
callq 0x4650
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x248c2
jmp 0x2519e
movq -0xc8(%rbp), %rdi
movl -0x40(%rbp), %esi
subl -0x3c(%rbp), %esi
movq -0xc0(%rbp), %rdx
movq -0x78(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0xa0(%rbp), %r8
movq -0xa8(%rbp), %r10
movq -0xd0(%rbp), %rax
leaq -0x84(%rbp), %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xdb7d0
cmpl $0x80000000, %eax       # imm = 0x80000000
jne 0x24913
jmp 0x2519e
cmpl $0x0, -0x4c(%rbp)
jne 0x24b9b
movl $0x0, -0x28(%rbp)
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x28(%rbp), %eax
movq -0x78(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x24b3c
movq -0x70(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0xe4(%rbp)
movq -0x70(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0xe8(%rbp)
cmpl $0x0, -0xe8(%rbp)
jne 0x2497c
jmp 0x24b2e
cmpl $0x0, -0xe4(%rbp)
je 0x2499b
cmpl $0x7, -0xe4(%rbp)
je 0x2499b
cmpl $0x8, -0xe4(%rbp)
jne 0x24acc
movl -0xe8(%rbp), %eax
movq -0x78(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jle 0x249bf
movq -0x78(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x30(%rbp), %eax
movl %eax, -0xe8(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl -0x30(%rbp), %ecx
addl -0xe8(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x24aaf
movq -0xa8(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x24a27
movq -0xa8(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
sarl $0x2, %eax
cltq
movq -0x68(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
subq %rdx, %rcx
movq -0x60(%rbp), %rdx
movslq -0x30(%rbp), %rsi
subq %rsi, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x24a38
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x24a9c
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0xd0(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x24a71
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x118(%rbp)
jmp 0x24a86
movq -0xd0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x118(%rbp)
movl -0x118(%rbp), %eax
movb %al, %dl
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x24a9e
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x249c7
movslq -0xe8(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xe8(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x24b2c
cmpl $0x4, -0xe4(%rbp)
je 0x24ade
cmpl $0x1, -0xe4(%rbp)
jne 0x24b10
movl -0xe8(%rbp), %eax
movq -0x78(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jle 0x24b02
movq -0x78(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x30(%rbp), %eax
movl %eax, -0xe8(%rbp)
movl -0xe8(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x24b2a
cmpl $0x2, -0xe4(%rbp)
jne 0x24b28
movslq -0xe8(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x24b2a
jmp 0x24b2c
jmp 0x24b2e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x24936
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jge 0x24b96
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x90(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
addl $0x40, %eax
movb %al, %dl
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x24b44
jmp 0x250dc
movq -0xc0(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movl $0x0, -0xfc(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x28(%rbp), %eax
movq -0x78(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x25045
movq -0x70(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x100(%rbp)
movq -0x70(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x104(%rbp)
cmpl $0x0, -0x100(%rbp)
je 0x24c2d
cmpl $0x7, -0x100(%rbp)
je 0x24c2d
cmpl $0x8, -0x100(%rbp)
jne 0x24ca5
movl -0x28(%rbp), %eax
addl $0x1, %eax
movq -0x78(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x24c89
movq -0x70(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x108(%rbp)
cmpl $0x0, -0x108(%rbp)
je 0x24c70
cmpl $0x7, -0x108(%rbp)
je 0x24c70
cmpl $0x8, -0x108(%rbp)
jne 0x24c87
movl -0x104(%rbp), %eax
addl -0xfc(%rbp), %eax
movl %eax, -0xfc(%rbp)
jmp 0x25037
jmp 0x24c89
movl -0xfc(%rbp), %eax
addl -0x104(%rbp), %eax
movl %eax, -0x104(%rbp)
movl $0x0, -0xfc(%rbp)
cmpl $0x0, -0x104(%rbp)
jne 0x24cb3
jmp 0x25037
cmpl $0x0, -0x100(%rbp)
je 0x24cd2
cmpl $0x7, -0x100(%rbp)
je 0x24cd2
cmpl $0x8, -0x100(%rbp)
jne 0x24fd5
movl -0x104(%rbp), %eax
movq -0x78(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jle 0x24cf6
movq -0x78(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x104(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl -0x30(%rbp), %ecx
addl -0x104(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x24da4
movq -0xa8(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x24d5e
movq -0xa8(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
sarl $0x2, %eax
cltq
movq -0x68(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
subq %rdx, %rcx
movq -0x60(%rbp), %rdx
movslq -0x30(%rbp), %rsi
subq %rsi, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x24d68
xorl %eax, %eax
movl %eax, -0x11c(%rbp)
jmp 0x24d7d
movq -0xd0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x11c(%rbp)
movl -0x11c(%rbp), %eax
movb %al, %dl
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x24cfe
movq -0x90(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0xf0(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl -0x30(%rbp), %ecx
addl -0x104(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x24e5e
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0xf0(%rbp), %rcx
movq -0x60(%rbp), %rdx
subq $0x1, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x24e1e
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x120(%rbp)
jmp 0x24e37
movq -0xf0(%rbp), %rax
movq -0x60(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x120(%rbp)
movl -0x120(%rbp), %eax
movb %al, %dl
movq -0xf0(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x24dcc
movq -0x90(%rbp), %rax
movl -0x30(%rbp), %ecx
addl -0x104(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0xf8(%rbp), %rax
movl -0x30(%rbp), %ecx
addl -0x104(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl -0x104(%rbp), %eax
subl $0x2, %eax
cltq
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jl 0x24f26
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0xf8(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl 0x1(%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x24ee9
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x124(%rbp)
jmp 0x24eff
movq -0xf8(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
movl %eax, -0x124(%rbp)
movl -0x124(%rbp), %eax
movb %al, %dl
movq -0xf8(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x24ea2
movslq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl -0x30(%rbp), %ecx
addl -0x104(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x24fb8
movq -0xf0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0xf8(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x24f7c
movq -0xf0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x128(%rbp)
jmp 0x24f91
movq -0xf8(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x128(%rbp)
movl -0x128(%rbp), %eax
movb %al, %dl
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x24f2e
movslq -0x104(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x104(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x25035
cmpl $0x4, -0x100(%rbp)
je 0x24fe7
cmpl $0x1, -0x100(%rbp)
jne 0x25019
movl -0x104(%rbp), %eax
movq -0x78(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jle 0x2500b
movq -0x78(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x25033
cmpl $0x2, -0x100(%rbp)
jne 0x25031
movslq -0x104(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x25033
jmp 0x25035
jmp 0x25037
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x24bda
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jge 0x250da
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x90(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jg 0x2508a
xorl %eax, %eax
movl %eax, -0x12c(%rbp)
jmp 0x250b0
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x90(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x12c(%rbp)
movl -0x12c(%rbp), %eax
addl $0x40, %eax
movb %al, %dl
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x2504d
jmp 0x250dc
cmpl $0x0, -0x48(%rbp)
je 0x25157
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jge 0x2512f
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %esi
subl $0x40, %esi
movq -0xa0(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %edx
subl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x250ea
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq -0x90(%rbp), %r8
leaq 0xc6364(%rip), %rsi     # 0xeb4af
movl $0x5a, %edx
callq 0x35300
jmp 0x2517d
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq -0x90(%rbp), %r8
leaq 0xc6339(%rip), %rsi     # 0xeb4ac
movl $0x5a, %edx
callq 0x35300
movq -0x90(%rbp), %rdi
callq 0x45a0
movq -0xa8(%rbp), %rdi
callq 0x45a0
movl $0x0, -0x4(%rbp)
jmp 0x251bd
movq -0x90(%rbp), %rdi
callq 0x45a0
movq -0xa8(%rbp), %rdi
callq 0x45a0
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)