// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_put_bam_seq
int cram_put_bam_seq(cram_fd *fd, bam_seq_t *b) {
    cram_container *c;

    if (!fd->ctr) {
        fd->ctr = cram_new_container(fd->seqs_per_slice,
                                     fd->slices_per_container);
        if (!fd->ctr)
            return -1;
        fd->ctr->record_counter = fd->record_counter;

        pthread_mutex_lock(&fd->ref_lock);
        fd->ctr->no_ref = fd->no_ref;
        fd->ctr->embed_ref = fd->embed_ref;
        pthread_mutex_unlock(&fd->ref_lock);
    }
    c = fd->ctr;

    int embed_ref = c->embed_ref;

    if (!c->slice || c->curr_rec == c->max_rec ||
        (bam_ref(b) != c->curr_ref && c->curr_ref >= -1) ||
        (c->s_num_bases + c->s_aux_bytes >= fd->bases_per_slice)) {
        int slice_rec, curr_rec, multi_seq = fd->multi_seq == 1;
        int curr_ref = c->slice ? c->curr_ref : bam_ref(b);

        /*
         * Start packing slices when we routinely have under 1/4tr full.
         *
         * This option isn't available if we choose to embed references
         * since we can only have one per slice.
         *
         * The multi_seq var here refers to our intention for the next slice.
         * This slice has already been encoded so we output as-is.
         */
        if (fd->multi_seq == -1 && c->curr_rec < c->max_rec/4+10 &&
            fd->last_slice && fd->last_slice < c->max_rec/4+10 &&
            embed_ref<=0) {
            if (!c->multi_seq)
                hts_log_info("Multi-ref enabled for next container");
            multi_seq = 1;
        } else if (fd->multi_seq == 1) {
            pthread_mutex_lock(&fd->metrics_lock);
            if (fd->last_RI_count <= c->max_slice && fd->multi_seq_user != 1) {
                multi_seq = 0;
                hts_log_info("Multi-ref disabled for next container");
            }
            pthread_mutex_unlock(&fd->metrics_lock);
        }

        slice_rec = c->slice_rec;
        curr_rec  = c->curr_rec;

        if (CRAM_MAJOR_VERS(fd->version) == 1 ||
            c->curr_rec == c->max_rec || fd->multi_seq != 1 || !c->slice ||
            c->s_num_bases + c->s_aux_bytes >= fd->bases_per_slice) {
            if (NULL == (c = cram_next_container(fd, b))) {
                if (fd->ctr) {
                    // prevent cram_close attempting to flush
                    fd->ctr_mt = fd->ctr; // delay free when threading
                    fd->ctr = NULL;
                }
                return -1;
            }
        }

        /*
         * Due to our processing order, some things we've already done we
         * cannot easily undo. So when we first notice we should be packing
         * multiple sequences per container we emit the small partial
         * container as-is and then start a fresh one in a different mode.
         */
        if (multi_seq == 0 && fd->multi_seq == 1 && fd->multi_seq_user == -1) {
            // User selected auto-mode, we're currently using multi-seq, but
            // have detected we don't need to.  Switch back to auto.
            fd->multi_seq = -1;
        } else if (multi_seq) {
            // We detected we need multi-seq
            fd->multi_seq = 1;
            c->multi_seq = 1;
            c->pos_sorted = 0;

            // Cram_next_container may end up flushing an existing one and
            // triggering fd->embed_ref=2 if no reference is found.
            // Embedded refs are incompatible with multi-seq, so we bail
            // out and switch to no_ref in this scenario.  We do this
            // within the container only, as multi_seq may be temporary
            // and we switch back away from it again.
            pthread_mutex_lock(&fd->ref_lock);
            if (fd->embed_ref > 0 && c->curr_rec == 0 && c->curr_slice == 0) {
                hts_log_warning("Changing from embed_ref to no_ref mode");
                // Should we update fd->embed_ref and no_ref here too?
                // Doing so means if we go into multi-seq and back out
                // again, eg due a cluster of tiny refs in the middle of
                // much larger ones, then we bake in no-ref mode.
                //
                // However for unsorted data we're realistically not
                // going to switch back.
                c->embed_ref = fd->embed_ref = 0; // or -1 for auto?
                c->no_ref = fd->no_ref = 1;
            }
            pthread_mutex_unlock(&fd->ref_lock);

            if (!c->refs_used) {
                pthread_mutex_lock(&fd->ref_lock);
                c->refs_used = calloc(fd->refs->nref, sizeof(int));
                pthread_mutex_unlock(&fd->ref_lock);
                if (!c->refs_used)
                    return -1;
            }
        }

        fd->last_slice = curr_rec - slice_rec;
        c->slice_rec = c->curr_rec;

        // Have we seen this reference before?
        if (bam_ref(b) >= 0 && curr_ref >= 0 && bam_ref(b) != curr_ref &&
            embed_ref<=0 && !fd->unsorted && multi_seq) {

            if (!c->refs_used) {
                pthread_mutex_lock(&fd->ref_lock);
                c->refs_used = calloc(fd->refs->nref, sizeof(int));
                pthread_mutex_unlock(&fd->ref_lock);
                if (!c->refs_used)
                    return -1;
            } else if (c->refs_used && c->refs_used[bam_ref(b)]) {
                pthread_mutex_lock(&fd->ref_lock);
                fd->unsorted = 1;
                fd->multi_seq = 1;
                pthread_mutex_unlock(&fd->ref_lock);
            }
        }

        c->curr_ref = bam_ref(b);
        if (c->refs_used && c->curr_ref >= 0) c->refs_used[c->curr_ref]++;
    }

    if (!c->bams) {
        /* First time through, allocate a set of bam pointers */
        pthread_mutex_lock(&fd->bam_list_lock);
        if (fd->bl) {
            spare_bams *spare = fd->bl;
            c->bams = spare->bams;
            fd->bl = spare->next;
            free(spare);
        } else {
            c->bams = calloc(c->max_c_rec, sizeof(bam_seq_t *));
            if (!c->bams) {
                pthread_mutex_unlock(&fd->bam_list_lock);
                return -1;
            }
        }
        pthread_mutex_unlock(&fd->bam_list_lock);
    }

    /* Copy or alloc+copy the bam record, for later encoding */
    if (c->bams[c->curr_c_rec]) {
        if (bam_copy1(c->bams[c->curr_c_rec], b) == NULL)
            return -1;
    } else {
        c->bams[c->curr_c_rec] = bam_dup1(b);
        if (c->bams[c->curr_c_rec] == NULL)
            return -1;
    }
    if (bam_seq_len(b)) {
        c->s_num_bases += bam_seq_len(b);
    } else {
        // No sequence in BAM record.  CRAM doesn't directly support this
        // case, it ends up being stored as a string of N's for each query
        // consuming CIGAR operation.  As this can become very inefficient
        // in time and memory, data where the query length is excessively
        // long are rejected.
        hts_pos_t qlen = bam_cigar2qlen(b->core.n_cigar, bam_get_cigar(b));
        if (qlen > 100000000) {
            hts_log_error("CIGAR query length %"PRIhts_pos
                          " for read \"%s\" is too long",
                          qlen, bam_get_qname(b));
            return -1;
        }
        c->s_num_bases += qlen;
    }
    c->curr_rec++;
    c->curr_c_rec++;
    c->s_aux_bytes += bam_get_l_aux(b);
    c->n_mapped += (bam_flag(b) & BAM_FUNMAP) ? 0 : 1;
    fd->record_counter++;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x6239e
movq -0x10(%rbp), %rax
movl 0x214(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x21c(%rax), %esi
callq 0x74730
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x6233a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4730
movq -0x10(%rbp), %rax
movl 0x224(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl %ecx, 0xec(%rax)
movq -0x10(%rbp), %rax
movl 0x220(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl %ecx, 0xe8(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4330
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0xe8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x62419
movq -0x20(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x64(%rcx), %eax
je 0x62419
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x78(%rcx), %eax
je 0x623ef
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x78(%rax)
jge 0x62419
movq -0x20(%rbp), %rax
movq 0x288(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x290(%rcx), %rax
movq -0x10(%rbp), %rcx
movslq 0x218(%rcx), %rcx
cmpq %rcx, %rax
jb 0x6291e
movq -0x10(%rbp), %rax
cmpl $0x1, 0x889c(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x62449
movq -0x20(%rbp), %rax
movl 0x78(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x62453
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x889c(%rax)
jne 0x624fa
movq -0x20(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movl 0x64(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x50(%rbp), %eax
addl $0xa, %ecx
cmpl %ecx, %eax
jge 0x624fa
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8894(%rax)
je 0x624fa
movq -0x10(%rbp), %rax
movl 0x8894(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x20(%rbp), %rax
movl 0x64(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x54(%rbp), %eax
addl $0xa, %ecx
cmpl %ecx, %eax
jge 0x624fa
cmpl $0x0, -0x24(%rbp)
jg 0x624fa
movq -0x20(%rbp), %rax
cmpl $0x0, 0xac(%rax)
jne 0x624f1
movl $0x4, %edi
leaq 0x9204c(%rip), %rsi     # 0xf452f
leaq 0x92056(%rip), %rdx     # 0xf4540
movb $0x0, %al
callq 0x1b030
movl $0x1, -0x30(%rbp)
jmp 0x6256a
movq -0x10(%rbp), %rax
cmpl $0x1, 0x889c(%rax)
jne 0x62568
movq -0x10(%rbp), %rdi
addq $0x88c8, %rdi           # imm = 0x88C8
callq 0x4730
movq -0x10(%rbp), %rax
movl 0x8898(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jg 0x62558
movq -0x10(%rbp), %rax
cmpl $0x1, 0x88a0(%rax)
je 0x62558
movl $0x0, -0x30(%rbp)
movl $0x4, %edi
leaq 0x91fe5(%rip), %rsi     # 0xf452f
leaq 0x92014(%rip), %rdx     # 0xf4565
movb $0x0, %al
callq 0x1b030
movq -0x10(%rbp), %rdi
addq $0x88c8, %rdi           # imm = 0x88C8
callq 0x4330
jmp 0x6256a
movq -0x20(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
sarl $0x8, %eax
cmpl $0x1, %eax
je 0x625de
movq -0x20(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x64(%rcx), %eax
je 0x625de
movq -0x10(%rbp), %rax
cmpl $0x1, 0x889c(%rax)
jne 0x625de
movq -0x20(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x625de
movq -0x20(%rbp), %rax
movq 0x288(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x290(%rcx), %rax
movq -0x10(%rbp), %rcx
movslq 0x218(%rcx), %rcx
cmpq %rcx, %rax
jb 0x6262e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x62bd0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x6262c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x62620
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
jmp 0x6262e
cmpl $0x0, -0x30(%rbp)
jne 0x62661
movq -0x10(%rbp), %rax
cmpl $0x1, 0x889c(%rax)
jne 0x62661
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x88a0(%rax)
jne 0x62661
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x889c(%rax) # imm = 0xFFFFFFFF
jmp 0x6279a
cmpl $0x0, -0x30(%rbp)
je 0x62798
movq -0x10(%rbp), %rax
movl $0x1, 0x889c(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0xac(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4730
movq -0x10(%rbp), %rax
cmpl $0x0, 0x220(%rax)
jle 0x62718
movq -0x20(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0x62718
movq -0x20(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x62718
movl $0x3, %edi
leaq 0x91e5d(%rip), %rsi     # 0xf452f
leaq 0x91eb2(%rip), %rdx     # 0xf458b
movb $0x0, %al
callq 0x1b030
movq -0x10(%rbp), %rax
movl $0x0, 0x220(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xe8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x224(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0xec(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4330
movq -0x20(%rbp), %rax
cmpq $0x0, 0x278(%rax)
jne 0x62796
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4730
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x42f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x278(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4330
movq -0x20(%rbp), %rax
cmpq $0x0, 0x278(%rax)
jne 0x62794
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
jmp 0x62796
jmp 0x62798
jmp 0x6279a
movl -0x2c(%rbp), %ecx
subl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8894(%rax)
movq -0x20(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x74(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x628da
cmpl $0x0, -0x34(%rbp)
jl 0x628da
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x34(%rbp), %eax
je 0x628da
cmpl $0x0, -0x24(%rbp)
jg 0x628da
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88a4(%rax)
jne 0x628da
cmpl $0x0, -0x30(%rbp)
je 0x628da
movq -0x20(%rbp), %rax
cmpq $0x0, 0x278(%rax)
jne 0x62873
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4730
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x42f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x278(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4330
movq -0x20(%rbp), %rax
cmpq $0x0, 0x278(%rax)
jne 0x62871
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
jmp 0x628d8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x278(%rax)
je 0x628d6
movq -0x20(%rbp), %rax
movq 0x278(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x628d6
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4730
movq -0x10(%rbp), %rax
movl $0x1, 0x88a4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x889c(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4330
jmp 0x628d8
jmp 0x628da
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x278(%rax)
je 0x6291c
movq -0x20(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jl 0x6291c
movq -0x20(%rbp), %rax
movq 0x278(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x78(%rcx), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x6291e
movq -0x20(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0x629e9
movq -0x10(%rbp), %rdi
addq $0x8948, %rdi           # imm = 0x8948
callq 0x4730
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8940(%rax)
je 0x6298d
movq -0x10(%rbp), %rax
movq 0x8940(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xf0(%rax)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8940(%rax)
movq -0x40(%rbp), %rdi
callq 0x45a0
jmp 0x629d9
movq -0x20(%rbp), %rax
movslq 0x6c(%rax), %rdi
movl $0x8, %esi
callq 0x42f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xf0(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0x629d7
movq -0x10(%rbp), %rdi
addq $0x8948, %rdi           # imm = 0x8948
callq 0x4330
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
jmp 0x629d9
movq -0x10(%rbp), %rdi
addq $0x8948, %rdi           # imm = 0x8948
callq 0x4330
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x70(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x62a37
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x70(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x33080
cmpq $0x0, %rax
jne 0x62a35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
jmp 0x62a82
movq -0x18(%rbp), %rdi
callq 0x33160
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x70(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x70(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x62a80
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
jmp 0x62a82
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x62aa8
movq -0x18(%rbp), %rax
movslq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x288(%rax), %rcx
movq %rcx, 0x288(%rax)
jmp 0x62b1f
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x18(%rbp), %rax
movzwl 0x12(%rax), %eax
cltq
addq %rax, %rsi
callq 0x33940
movq %rax, -0x48(%rbp)
cmpq $0x5f5e100, -0x48(%rbp) # imm = 0x5F5E100
jle 0x62b09
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x38(%rax), %r8
movl $0x1, %edi
leaq 0x91a40(%rip), %rsi     # 0xf452f
leaq 0x91abc(%rip), %rdx     # 0xf45b2
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62bc0
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x288(%rax), %rcx
movq %rcx, 0x288(%rax)
movq -0x20(%rbp), %rax
movl 0x68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x68(%rax)
movq -0x20(%rbp), %rax
movl 0x70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x70(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %ecx
shll $0x2, %ecx
subl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
subl %ecx, %eax
movq -0x18(%rbp), %rcx
subl 0x18(%rcx), %eax
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %ecx
addl $0x1, %ecx
sarl %ecx
subl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
addq 0x290(%rax), %rcx
movq %rcx, 0x290(%rax)
movq -0x18(%rbp), %rax
movzwl 0x10(%rax), %edx
andl $0x4, %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x20(%rbp), %rax
addl 0x298(%rax), %ecx
movl %ecx, 0x298(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)