// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf.c
// Function: vcf_format
int vcf_format(const bcf_hdr_t *h, const bcf1_t *v, kstring_t *s)
{
    int i;
    int32_t max_dt_id = h->n[BCF_DT_ID];
    const char *chrom = bcf_seqname(h, v);
    if (!chrom) {
        hts_log_error("Invalid BCF, CONTIG id=%d not present in the header",
                      v->rid);
        errno = EINVAL;
        return -1;
    }

    bcf_unpack((bcf1_t*)v, BCF_UN_ALL & ~(BCF_UN_INFO|BCF_UN_FMT));

    // Cache of key lengths so we don't keep repeatedly using them.
    // This assumes we're not modifying the header between successive calls
    // to vcf_format, but that would lead to many other forms of breakage
    // so it feels like a valid assumption to make.
    //
    // We cannot just do this in bcf_hdr_sync as some code (eg bcftools
    // annotate) manipulates the headers directly without calling sync to
    // refresh the data structures.  So we must do just-in-time length
    // calculation during writes instead.
    bcf_hdr_aux_t *aux = get_hdr_aux(h);
    if (!aux->key_len) {
        if (!(aux->key_len = calloc(h->n[BCF_DT_ID]+1, sizeof(*aux->key_len))))
            return -1;
    }
    size_t *key_len = aux->key_len;

    kputs(chrom, s); // CHROM
    kputc_('\t', s); kputll(v->pos + 1, s); // POS
    kputc_('\t', s); kputs(v->d.id ? v->d.id : ".", s); // ID
    kputc_('\t', s); // REF
    if (v->n_allele > 0) kputs(v->d.allele[0], s);
    else kputc_('.', s);
    kputc_('\t', s); // ALT
    if (v->n_allele > 1) {
        for (i = 1; i < v->n_allele; ++i) {
            if (i > 1) kputc_(',', s);
            kputs(v->d.allele[i], s);
        }
    } else kputc_('.', s);
    kputc_('\t', s); // QUAL
    if ( bcf_float_is_missing(v->qual) ) kputc_('.', s); // QUAL
    else kputd(v->qual, s);
    kputc_('\t', s); // FILTER
    if (v->d.n_flt) {
        for (i = 0; i < v->d.n_flt; ++i) {
            int32_t idx = v->d.flt[i];
            if (idx < 0 || idx >= max_dt_id
                || h->id[BCF_DT_ID][idx].key == NULL) {
                hts_log_error("Invalid BCF, the FILTER tag id=%d at %s:%"PRIhts_pos" not present in the header",
                              idx, bcf_seqname_safe(h, v), v->pos + 1);
                errno = EINVAL;
                return -1;
            }
            if (i) kputc_(';', s);
            if (!key_len[idx])
                key_len[idx] = strlen(h->id[BCF_DT_ID][idx].key);
            kputsn(h->id[BCF_DT_ID][idx].key, key_len[idx], s);
        }
    } else kputc_('.', s);

    kputc_('\t', s); // INFO
    if (v->n_info) {
        uint8_t *ptr = v->shared.s
            ? (uint8_t *)v->shared.s + v->unpack_size[0] +
               v->unpack_size[1] + v->unpack_size[2]
            : NULL;
        int first = 1;
        bcf_info_t *info = v->d.info;

        // Note if we duplicate this code into custom packed and unpacked
        // implementations then we gain a bit more speed, particularly with
        // clang 13 (up to 5%).  Not sure why this is, but code duplication
        // isn't pleasant and it's still faster adding packed support than
        // not so it's a win, just not as good as it should be.
        const int info_packed = !(v->unpacked & BCF_UN_INFO) && v->shared.l;
        for (i = 0; i < v->n_info; ++i) {
            bcf_info_t in, *z;
            if (info_packed) {
                // Use a local bcf_info_t when data is packed
                z = &in;
                z->key  = bcf_dec_typed_int1(ptr, &ptr);
                z->len  = bcf_dec_size(ptr, &ptr, &z->type);
                z->vptr = ptr;
                ptr += z->len << bcf_type_shift[z->type];
            } else {
                // Else previously unpacked INFO struct
                z = &info[i];

                // Also potentially since deleted
                if ( !z->vptr ) continue;
            }

            bcf_idpair_t *id = z->key >= 0 && z->key < max_dt_id
                ? &h->id[BCF_DT_ID][z->key]
                : NULL;

            if (!id || !id->key) {
                hts_log_error("Invalid BCF, the INFO tag id=%d is %s at %s:%"PRIhts_pos,
                              z->key,
                              z->key < 0 ? "negative"
                              : (z->key >= max_dt_id ? "too large" : "not present in the header"),
                              bcf_seqname_safe(h, v), v->pos+1);
                errno = EINVAL;
                return -1;
            }

            // KEY
            if (!key_len[z->key])
                key_len[z->key] = strlen(id->key);
            size_t id_len = key_len[z->key];
            if (ks_resize(s, s->l + 3 + id_len) < 0)
                return -1;
            char *sptr = s->s + s->l;
            if ( !first ) {
                *sptr++ = ';';
                s->l++;
            }
            first = 0;
            memcpy(sptr, id->key, id_len);
            s->l += id_len;

            // VALUE
            if (z->len <= 0) continue;
            sptr[id_len] = '=';
            s->l++;

            if (z->len != 1 || info_packed) {
                bcf_fmt_array(s, z->len, z->type, z->vptr);
            } else {
                // Single length vectors are unpacked into their
                // own info.v1 union and handled separately.
                if (z->type == BCF_BT_FLOAT) {
                    if ( bcf_float_is_missing(z->v1.f) )
                        kputc_('.', s);
                    else
                        kputd(z->v1.f, s);
                } else if (z->type == BCF_BT_CHAR) {
                    kputc_(z->v1.i, s);
                } else if (z->type < BCF_BT_INT64) {
                    int64_t missing[] = {
                        0, // BCF_BT_NULL
                        bcf_int8_missing,
                        bcf_int16_missing,
                        bcf_int32_missing,
                    };
                    if (z->v1.i == missing[z->type])
                        kputc_('.', s);
                    else
                        kputw(z->v1.i, s);
                } else if (z->type == BCF_BT_INT64) {
                    if (z->v1.i == bcf_int64_missing)
                        kputc_('.', s);
                    else
                        kputll(z->v1.i, s);
                } else {
                    hts_log_error("Unexpected type %d at %s:%"PRIhts_pos, z->type, bcf_seqname_safe(h, v), v->pos+1);
                    errno = EINVAL;
                    return -1;
                }
            }
        }
        if ( first ) kputc_('.', s);
    } else kputc_('.', s);

    // FORMAT and individual information
    if (v->n_sample) {
        int i,j;
        if ( v->n_fmt) {
            uint8_t *ptr = (uint8_t *)v->indiv.s;
            int gt_i = -1;
            bcf_fmt_t *fmt = v->d.fmt;
            int first = 1, ret = 0;
            int fmt_packed = !(v->unpacked & BCF_UN_FMT);

            if (fmt_packed) {
                // Local fmt as we have an array of num FORMAT keys,
                // each of which points to N.Sample values.

                // No real gain to be had in handling unpacked data here,
                // but it doesn't cost us much in complexity either and
                // it gives us flexibility.
                fmt = malloc(v->n_fmt * sizeof(*fmt));
                if (!fmt)
                    return -1;
            }

            // KEYS
            for (i = 0; i < (int)v->n_fmt; ++i) {
                bcf_fmt_t *z;
                z = &fmt[i];
                if (fmt_packed) {
                    z->id   = bcf_dec_typed_int1(ptr, &ptr);
                    z->n    = bcf_dec_size(ptr, &ptr, &z->type);
                    z->p    = ptr;
                    z->size = z->n << bcf_type_shift[z->type];
                    ptr += v->n_sample * z->size;
                }
                if ( !z->p ) continue;
                kputc_(!first ? ':' : '\t', s); first = 0;

                bcf_idpair_t *id = z->id >= 0 && z->id < max_dt_id
                    ? &h->id[BCF_DT_ID][z->id]
                    : NULL;

                if (!id || !id->key) {
                    hts_log_error("Invalid BCF, the FORMAT tag id=%d at %s:%"PRIhts_pos" not present in the header", z->id, bcf_seqname_safe(h, v), v->pos+1);
                    errno = EINVAL;
                    if (fmt_packed)
                        free(fmt);
                    return -1;
                }

                if (!key_len[z->id])
                    key_len[z->id] = strlen(id->key);
                size_t id_len = key_len[z->id];
                kputsn(id->key, id_len, s);
                if (id_len == 2 && id->key[0] == 'G' && id->key[1] == 'T')
                    gt_i = i;
            }
            if ( first ) kputsn("\t.", 2, s);

            // VALUES per sample
            for (j = 0; j < v->n_sample; ++j) {
                kputc_('\t', s);
                first = 1;
                bcf_fmt_t *f = fmt;
                for (i = 0; i < (int)v->n_fmt; i++, f++) {
                    if ( !f->p ) continue;
                    if (!first) kputc_(':', s);
                    first = 0;
                    if (gt_i == i) {
                        if ((ret = bcf_format_gt_v2(h, f,j,s)) < 0) {
                            hts_log_error("Failed to format GT value for sample %d, returned %d", i, ret);
                            errno = EINVAL;
                            if (fmt_packed)
                                free(fmt);
                            return -1;
                        }
                        break;
                    }
                    else if (f->n == 1)
                        bcf_fmt_array1(s, f->type, f->p + j * (size_t)f->size);
                    else
                        bcf_fmt_array(s, f->n, f->type, f->p + j * (size_t)f->size);
                }

                // Simpler loop post GT and at least 1 iteration
                for (i++, f++; i < (int)v->n_fmt; i++, f++) {
                    if ( !f->p ) continue;
                    kputc_(':', s);
                    if (f->n == 1)
                        bcf_fmt_array1(s, f->type, f->p + j * (size_t)f->size);
                    else
                        bcf_fmt_array(s, f->n, f->type, f->p + j * (size_t)f->size);
                }
                if ( first ) kputc_('.', s);
            }
            if (fmt_packed)
                free(fmt);
        }
        else
            for (j=0; j<=v->n_sample; j++)
                kputsn("\t.", 2, s);
    }
    kputc('\n', s);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testq %rsi, %rsi
je 0x38aad
movslq 0x10(%rsi), %rcx
testq %rcx, %rcx
js 0x38ab4
movq %rdi, %r15
cmpl %ecx, 0x4(%rdi)
jle 0x38ab4
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq 0x18(%r15), %rax
movq %rcx, %rdx
shlq $0x4, %rdx
movq (%rax,%rdx), %r13
testq %r13, %r13
je 0x38ab4
movl (%r15), %eax
movl %eax, 0x4c(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x38183
movq 0x28(%r15), %rbx
movq 0x30(%rbx), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
jne 0x38a41
movslq (%r15), %rdi
incq %rdi
movl $0x8, %esi
callq 0x42f0
movq %rax, 0x30(%rbx)
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x38ad9
movq %r15, 0x40(%rsp)
movq %r13, %rdi
callq 0x41c0
movq %rax, %rbp
movq (%r14), %r12
addq %r12, %rax
addq $0x2, %rax
cmpq %r12, %rax
jbe 0x38af2
cmpq %rax, 0x8(%r14)
jae 0x38aff
movq %rax, %rcx
shrq %rcx
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
movq (%r14), %r12
testq %rax, %rax
je 0x38b25
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
jmp 0x38b03
movl 0x10, %ecx
leaq 0x7329e(%rip), %rsi     # 0xabd59
leaq 0x732a2(%rip), %rdx     # 0xabd64
movl $0x1, %edi
xorl %eax, %eax
callq 0x942d
callq 0x4050
movl $0x16, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4050
movl $0x4b, (%rax)
jmp 0x38b25
movq 0x10(%r14), %rax
addq %rax, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x43c0
addq (%r14), %rbp
movq %rbp, (%r14)
movq 0x10(%r14), %rax
movb $0x0, (%rax,%rbp)
movq (%r14), %r12
leaq 0x1(%r12), %rcx
cmpq %rcx, 0x8(%r14)
movq 0x10(%rsp), %rbx
jae 0x38b75
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38b81
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %r12
leaq 0x1(%r12), %rcx
jmp 0x38b79
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x9, (%rax,%r12)
movq (%rbx), %r13
movq (%r14), %rax
addq $0x17, %rax
cmpq %rax, 0x8(%r14)
jae 0x38bcb
movq %rax, %rcx
shrq %rcx
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38c88
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
cmpq $-0x2, %r13
jg 0x38be8
notq %r13
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movb $0x2d, (%rcx,%rax)
jmp 0x38beb
incq %r13
movq %r13, %rax
shrq $0x20, %rax
jne 0x38c04
movl %r13d, %edi
movq %r14, %rsi
callq 0x41065
jmp 0x38c88
movl $0x1, %eax
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
addq %rax, %rax
leaq (%rax,%rax,4), %rax
incl %ecx
cmpq %rax, %r13
jae 0x38c0e
movq 0x10(%r14), %rsi
addq (%r14), %rsi
leal 0x2(%rcx), %edi
leaq 0x6fd23(%rip), %r8      # 0xa8950
movabsq $0x28f5c28f5c28f5c3, %r9 # imm = 0x28F5C28F5C28F5C3
movq %r13, %r10
movq %r13, %rax
shrq $0x2, %rax
mulq %r9
movq %rdx, %r13
shrq $0x2, %r13
imulq $0x64, %r13, %rax
movq %r10, %rdx
subq %rax, %rdx
movl %ecx, %eax
movzwl (%r8,%rdx,2), %edx
movw %dx, (%rsi,%rax)
addl $-0x2, %ecx
cmpq $0x3e7, %r10            # imm = 0x3E7
ja 0x38c37
cmpl $-0x1, %ecx
jne 0x38c78
orb $0x30, %r13b
movb %r13b, (%rsi)
movl %edi, %eax
addq (%r14), %rax
movq %rax, (%r14)
movq 0x10(%r14), %rcx
movb $0x0, (%rcx,%rax)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x38cd9
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
movq 0x10(%rsp), %rsi
je 0x38ce9
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x38ce2
movq 0x10(%r14), %rax
movq 0x10(%rsp), %rsi
movq %rcx, (%r14)
movb $0x9, (%rax,%rdx)
movq 0x78(%rsi), %rax
testq %rax, %rax
leaq 0x7cd4b(%rip), %rbp     # 0xb5a42
cmovneq %rax, %rbp
movq %rbp, %rdi
callq 0x41c0
movq %rax, %r13
movq (%r14), %r12
addq %r12, %rax
addq $0x2, %rax
cmpq %r12, %rax
jbe 0x38d56
cmpq %rax, 0x8(%r14)
jae 0x38d63
movq %rax, %rcx
shrq %rcx
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
movq (%r14), %r12
testq %rax, %rax
je 0x38d8a
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
jmp 0x38d67
callq 0x4050
movl $0x4b, (%rax)
jmp 0x38d8a
movq 0x10(%r14), %rax
addq %rax, %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x43c0
addq (%r14), %r13
movq %r13, (%r14)
movq 0x10(%r14), %rax
movb $0x0, (%rax,%r13)
movq (%r14), %r12
leaq 0x1(%r12), %rcx
cmpq %rcx, 0x8(%r14)
movq 0x10(%rsp), %rbx
jae 0x38dda
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38de6
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %r12
leaq 0x1(%r12), %rcx
jmp 0x38dde
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x9, (%rax,%r12)
cmpw $0x0, 0x1a(%rbx)
je 0x38e67
movq 0x88(%rbx), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x38eb3
movq %r12, %rdi
callq 0x41c0
movq %rax, %r13
movq (%r14), %rdi
addq %rdi, %rax
addq $0x2, %rax
cmpq %rdi, %rax
jbe 0x38ec0
cmpq %rax, 0x8(%r14)
jae 0x38eda
movq %rax, %rcx
shrq %rcx
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38efb
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdi
jmp 0x38ede
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x38ecd
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38efb
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x38ed1
callq 0x4050
movl $0xe, (%rax)
jmp 0x38efb
callq 0x4050
movl $0x4b, (%rax)
jmp 0x38efb
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x2e, (%rax,%rdx)
jmp 0x38efb
movq 0x10(%r14), %rax
addq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x43c0
addq (%r14), %r13
movq %r13, (%r14)
movq 0x10(%r14), %rax
movb $0x0, (%rax,%r13)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x38f4c
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
movq 0x10(%rsp), %r13
je 0x38f5c
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x38f55
movq 0x10(%r14), %rax
movq 0x10(%rsp), %r13
movq %rcx, (%r14)
movb $0x9, (%rax,%rdx)
movzwl 0x1a(%r13), %eax
testl $0xfffe, %eax           # imm = 0xFFFE
je 0x3908e
movl $0x1, %ebx
xorl %ebp, %ebp
cmpq $0x2, %rbx
jb 0x38fcd
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x38fc2
movq %rcx, %r15
shrq %r15
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, %rcx
cmovaq %rbp, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38fcd
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x38fc6
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x2c, (%rax,%rdx)
movq 0x88(%r13), %rax
movq (%rax,%rbx,8), %r12
testq %r12, %r12
je 0x3903b
movq %r12, %rdi
callq 0x41c0
movq %rax, %r13
movq (%r14), %rdi
addq %rdi, %rax
addq $0x2, %rax
cmpq %rdi, %rax
jbe 0x39048
cmpq %rax, 0x8(%r14)
jae 0x39055
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39076
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdi
jmp 0x39059
callq 0x4050
movl $0xe, (%rax)
jmp 0x39076
callq 0x4050
movl $0x4b, (%rax)
jmp 0x39076
movq 0x10(%r14), %rax
addq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x43c0
addq (%r14), %r13
movq %r13, (%r14)
movq 0x10(%r14), %rax
movb $0x0, (%rax,%r13)
incq %rbx
movq 0x10(%rsp), %r13
movzwl 0x1a(%r13), %eax
cmpq %rax, %rbx
jb 0x38f73
jmp 0x390e5
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x390da
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x390e5
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x390de
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x2e, (%rax,%rdx)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x39136
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
movq 0x40(%rsp), %rbp
je 0x39146
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x3913f
movq 0x10(%r14), %rax
movq 0x40(%rsp), %rbp
movq %rcx, (%r14)
movb $0x9, (%rax,%rdx)
movd 0x14(%r13), %xmm0
movd %xmm0, %eax
cmpl %eax, 0x943ba(%rip)     # 0xcd510
jne 0x391a4
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x391b2
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x391bd
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x391b6
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
callq 0x88e98
jmp 0x391bd
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x2e, (%rax,%rdx)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x39209
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39214
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x3920d
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x9, (%rax,%rdx)
cmpl $0x0, 0x68(%r13)
je 0x3938c
jle 0x3940f
xorl %ebx, %ebx
movq 0x70(%r13), %rax
movslq (%rax,%rbx,4), %r13
testq %r13, %r13
js 0x393d8
cmpl 0x4c(%rsp), %r13d
jge 0x393d8
movq 0x10(%rbp), %rax
movq %r13, %r12
shlq $0x4, %r12
cmpq $0x0, (%rax,%r12)
je 0x393d8
testq %rbx, %rbx
je 0x392b8
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x392ad
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x392b8
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x392b1
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x3b, (%rax,%rdx)
movq 0x50(%rsp), %rax
movq (%rax,%r13,8), %rbp
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax,%r12), %r12
testq %rbp, %rbp
jne 0x392e7
movq %r12, %rdi
callq 0x41c0
movq %rax, %rbp
movq 0x50(%rsp), %rax
movq %rbp, (%rax,%r13,8)
movq (%r14), %rdi
leaq (%rdi,%rbp), %rax
addq $0x2, %rax
cmpq %rdi, %rax
jbe 0x39340
cmpq %rax, 0x8(%r14)
movq 0x10(%rsp), %r13
jae 0x39352
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39372
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdi
jmp 0x39356
callq 0x4050
movl $0x4b, (%rax)
movq 0x10(%rsp), %r13
jmp 0x39372
movq 0x10(%r14), %rax
addq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x43c0
addq (%r14), %rbp
movq %rbp, (%r14)
movq 0x10(%r14), %rax
movb $0x0, (%rax,%rbp)
incq %rbx
movslq 0x68(%r13), %rax
cmpq %rax, %rbx
movq 0x40(%rsp), %rbp
jl 0x39227
jmp 0x3940f
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x39404
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3940f
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x39408
movq 0x10(%rsp), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
js 0x3949b
cmpl %eax, 0x4(%rbp)
jle 0x3949b
movq 0x18(%rbp), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %rax
jmp 0x3949d
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x2e, (%rax,%rdx)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x3945b
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39466
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x3945f
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x9, (%rax,%rdx)
cmpw $0x0, 0x18(%r13)
je 0x399f9
movq 0x30(%r13), %rax
testq %rax, %rax
je 0x394d1
movslq 0xc0(%r13), %rcx
addq %rcx, %rax
movslq 0xc4(%r13), %rcx
movslq 0xc8(%r13), %rbx
addq %rcx, %rbx
addq %rax, %rbx
jmp 0x394d3
xorl %eax, %eax
testq %rax, %rax
leaq 0x73468(%rip), %r8      # 0xac90f
cmovneq %rax, %r8
movq 0x10(%rsp), %rax
movq (%rax), %r9
incq %r9
leaq 0x7289c(%rip), %rsi     # 0xabd59
leaq 0x728d4(%rip), %rdx     # 0xabd98
movl $0x1, %edi
movl %r13d, %ecx
jmp 0x39b1d
xorl %ebx, %ebx
testb $0x4, 0xbc(%r13)
jne 0x394e8
cmpq $0x0, 0x20(%r13)
setne %r12b
jmp 0x394eb
xorl %r12d, %r12d
movq 0x90(%r13), %r15
movl $0x1, 0x38(%rsp)
xorl %ecx, %ecx
movl %r12d, 0x1c(%rsp)
testb %r12b, %r12b
movq %rcx, 0x20(%rsp)
je 0x39533
movzbl (%rbx), %eax
andl $0xf, %eax
decl %eax
cmpl $0x3, %eax
ja 0x3956c
leaq 0x71941(%rip), %rcx     # 0xaae60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbq 0x1(%rbx), %rax
addq $0x2, %rbx
jmp 0x3956e
cmpq $0x0, 0x10(%r15)
je 0x3997b
movq %rbx, 0x28(%rsp)
movl (%r15), %eax
movq %r15, %rbx
jmp 0x395e2
movl 0x1(%rbx), %eax
addq $0x5, %rbx
jmp 0x3956e
movq 0x1(%rbx), %rax
addq $0x9, %rbx
jmp 0x3956e
movswq 0x1(%rbx), %rax
addq $0x3, %rbx
jmp 0x3956e
xorl %eax, %eax
movl %eax, 0x60(%rsp)
movzbl (%rbx), %ecx
andl $0xf, %ecx
movl %ecx, 0x64(%rsp)
movzbl (%rbx), %edx
cmpl $0xef, %edx
jbe 0x395b4
movzbl 0x1(%rbx), %edx
andl $0xf, %edx
decl %edx
cmpl $0x3, %edx
ja 0x398b0
leaq 0x718d0(%rip), %rsi     # 0xaae70
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movsbq 0x2(%rbx), %rdx
addq $0x3, %rbx
jmp 0x395ba
incq %rbx
shrl $0x4, %edx
movl %edx, 0x80(%rsp)
leaq 0x93f58(%rip), %rsi     # 0xcd520
movb (%rcx,%rsi), %cl
shll %cl, %edx
movq %rbx, 0x70(%rsp)
movslq %edx, %rcx
addq %rcx, %rbx
movq %rbx, 0x28(%rsp)
leaq 0x60(%rsp), %rbx
testl %eax, %eax
js 0x39aaa
cmpl 0x4c(%rsp), %eax
jge 0x39aaa
movq 0x10(%rbp), %r13
testq %r13, %r13
je 0x399e6
movq %r15, 0x30(%rsp)
movl %eax, %r15d
movq %r15, %rcx
shlq $0x4, %rcx
addq %rcx, %r13
movq (%r13), %rdi
testq %rdi, %rdi
je 0x399e6
movq 0x50(%rsp), %rax
movq (%rax,%r15,8), %rbp
testq %rbp, %rbp
jne 0x3963f
callq 0x41c0
movq %rax, %rbp
movq 0x50(%rsp), %rax
movq %rbp, (%rax,%r15,8)
movq (%r14), %r12
leaq (%r12,%rbp), %rcx
addq $0x3, %rcx
movq 0x10(%r14), %rax
cmpq %rcx, 0x8(%r14)
jae 0x39693
movq %rcx, %rdx
shrq %rdx
movabsq $0x3fffffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rsi, %rcx
movl $0x0, %r15d
cmovbeq %rdx, %r15
addq %rcx, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38ad9
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %r12
addq %rax, %r12
cmpl $0x0, 0x38(%rsp)
movq 0x30(%rsp), %r15
jne 0x396ad
movb $0x3b, (%r12)
incq %r12
incq (%r14)
movq (%r13), %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x43c0
addq %rbp, (%r14)
movl $0x0, 0x38(%rsp)
cmpl $0x0, 0x20(%rbx)
jle 0x39718
movb $0x3d, (%r12,%rbp)
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movl 0x20(%rbx), %esi
cmpl $0x1, %esi
sete %dil
movl 0x1c(%rsp), %r12d
movl %r12d, %r8d
xorb $0x1, %r8b
movslq 0x4(%rbx), %rax
testb %r8b, %dil
movq 0x10(%rsp), %r13
jne 0x39731
movq 0x10(%rbx), %rcx
movq %r14, %rdi
movl %eax, %edx
callq 0x32c74
movq 0x40(%rsp), %rbp
jmp 0x39971
movq 0x10(%rsp), %r13
movq 0x40(%rsp), %rbp
movq 0x28(%rsp), %rbx
movl 0x1c(%rsp), %r12d
jmp 0x39976
cmpl $0x7, %eax
movq 0x40(%rsp), %rbp
je 0x397b7
cmpl $0x5, %eax
jne 0x39814
movd 0x8(%rbx), %xmm0
movd %xmm0, %eax
cmpl %eax, 0x93dbd(%rip)     # 0xcd510
jne 0x398b7
addq $0x2, %rcx
cmpq %rcx, 0x8(%r14)
jae 0x398fb
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
movq 0x28(%rsp), %rbx
je 0x3987c
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
movq 0x30(%rsp), %r15
jmp 0x399ac
movq 0x8(%rbx), %rbx
addq $0x2, %rcx
cmpq %rcx, 0x8(%r14)
jae 0x398c8
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39994
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
movq 0x30(%rsp), %r15
jmp 0x398cc
cmpl $0x3, %eax
jg 0x398d7
movq 0x8(%rbx), %r12
leaq 0x73898(%rip), %rsi     # 0xad0c0
cmpq (%rsi,%rax,8), %r12
jne 0x39909
addq $0x2, %rcx
cmpq %rcx, 0x8(%r14)
movq 0x28(%rsp), %rbx
movl 0x1c(%rsp), %r12d
jae 0x399a8
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
jne 0x3979e
movl $0x0, 0x38(%rsp)
jmp 0x399a1
movl 0x2(%rbx), %edx
addq $0x6, %rbx
jmp 0x395ba
movq 0x2(%rbx), %rdx
addq $0xa, %rbx
jmp 0x395ba
movswq 0x2(%rbx), %rdx
addq $0x4, %rbx
jmp 0x395ba
xorl %edx, %edx
jmp 0x395ba
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
callq 0x88e98
jmp 0x39971
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb %bl, (%rax,%rdx)
jmp 0x39971
cmpl $0x4, %eax
jne 0x39ffa
movq 0x8(%rbx), %rdi
movq %rdi, %rax
negq %rax
jno 0x39969
movl $0x2e, %edi
movq %r14, %rsi
callq 0x334d9
jmp 0x39971
movq 0x10(%r14), %rax
movq 0x28(%rsp), %rbx
jmp 0x399ac
testl %r12d, %r12d
movq 0x28(%rsp), %rbx
jns 0x399c7
addq $0x4, %rcx
cmpq %rcx, 0x8(%r14)
jae 0x399b5
movq %rcx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x399d7
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
movq 0x30(%rsp), %r15
jmp 0x399b9
movq %r14, %rsi
callq 0x3a370
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %rcx
incq %rcx
movq 0x18(%r13), %rdi
movzwl %di, %eax
addq $0x28, %r15
cmpq %rax, %rcx
jb 0x39501
jmp 0x399f2
movl $0x0, 0x38(%rsp)
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %r15
jmp 0x39976
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x2e, (%rax,%rdx)
jmp 0x39976
movq 0x10(%r14), %rax
negl %r12d
leaq 0x1(%rdx), %rcx
movq %rcx, (%r14)
movb $0x2d, (%rax,%rdx)
movl %r12d, %edi
movq %r14, %rsi
callq 0x41065
jmp 0x39727
movl $0x0, 0x38(%rsp)
movl 0x1c(%rsp), %r12d
jmp 0x399a1
leaq 0x72391(%rip), %r8      # 0xabd7e
jmp 0x39acd
cmpl $0x0, 0x38(%rsp)
je 0x39a56
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rdx, 0x8(%r14)
jae 0x39a45
movq %rdx, %rax
shrq %rax
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rdx
cmovbeq %rax, %r15
addq %rdx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39a52
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
jmp 0x39a49
movq 0x10(%r14), %rax
addq %rax, %rcx
movq %rdx, (%r14)
movb $0x2e, (%rcx)
movq 0x18(%r13), %rdi
movq %rdi, %rax
shrq $0x28, %rax
je 0x39bb7
movabsq $0xff00000000, %rax     # imm = 0xFF00000000
testq %rax, %rdi
je 0x39b29
movq 0x48(%r13), %rbx
movl 0xbc(%r13), %eax
movl %eax, 0x1c(%rsp)
testb $0x8, %al
jne 0x39c29
shrq $0x1b, %rdi
andl $0x1fe0, %edi           # imm = 0x1FE0
callq 0x46a0
testq %rax, %rax
jne 0x39c30
jmp 0x38ad9
cmpl 0x4c(%rsp), %eax
leaq 0x722c9(%rip), %rcx     # 0xabd7e
leaq 0x6e96e(%rip), %rdx     # 0xa842a
cmovlq %rcx, %rdx
testl %eax, %eax
leaq 0x7df9a(%rip), %r8      # 0xb7a63
cmovnsq %rdx, %r8
movq 0x10(%rsp), %rsi
movslq 0x10(%rsi), %rcx
testq %rcx, %rcx
js 0x39aee
cmpl %ecx, 0x4(%rbp)
jle 0x39aee
movq 0x18(%rbp), %rdx
shlq $0x4, %rcx
movq (%rdx,%rcx), %rcx
jmp 0x39af0
xorl %ecx, %ecx
testq %rcx, %rcx
leaq 0x72e15(%rip), %r9      # 0xac90f
cmovneq %rcx, %r9
movq (%rsi), %rcx
incq %rcx
movq %rcx, (%rsp)
leaq 0x7224a(%rip), %rsi     # 0xabd59
leaq 0x722c8(%rip), %rdx     # 0xabdde
movl $0x1, %edi
movl %eax, %ecx
xorl %eax, %eax
callq 0x942d
jmp 0x38ace
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movq (%r14), %rcx
movq %rcx, %rax
subq $-0x4, %rax
jae 0x39b7b
cmpq %rax, 0x8(%r14)
jae 0x39b88
movq %rax, %r15
shrq %r15
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
cmovaq %r12, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39ba5
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rcx
jmp 0x39b8c
callq 0x4050
movl $0x4b, (%rax)
jmp 0x39ba5
movq 0x10(%r14), %rax
movw $0x2e09, (%rax,%rcx)    # imm = 0x2E09
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x2(%rax), %rdx
movq %rdx, (%r14)
movb $0x0, 0x2(%rcx,%rax)
movq 0x18(%r13), %rax
shrq $0x28, %rax
incl %ebx
cmpl %eax, %ebx
jb 0x39b31
movq (%r14), %rcx
leaq 0x2(%rcx), %rax
cmpq %rax, 0x8(%r14)
jae 0x39c08
movq %rax, %rcx
shrq %rcx
xorl %ebx, %ebx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x38ade
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rcx
jmp 0x39c0c
movq 0x10(%r14), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movb $0xa, (%rax,%rcx)
movq (%r14), %rax
movq 0x10(%r14), %rcx
movb $0x0, (%rcx,%rax)
xorl %ebx, %ebx
jmp 0x38ade
movq 0x98(%r13), %rax
movq %rax, 0x58(%rsp)
leaq 0x10(%rax), %rdi
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movl $0x1, %r12d
xorl %esi, %esi
testb $0x8, 0x1c(%rsp)
jne 0x39c78
movzbl (%rbx), %eax
andl $0xf, %eax
decl %eax
cmpl $0x3, %eax
ja 0x39ca5
leaq 0x7121c(%rip), %rcx     # 0xaae80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbq 0x1(%rbx), %rax
addq $0x2, %rbx
jmp 0x39ca7
cmpq $0x0, (%rdi)
jne 0x39d16
jmp 0x39ecc
movl 0x1(%rbx), %eax
addq $0x5, %rbx
jmp 0x39ca7
movq 0x1(%rbx), %rax
addq $0x9, %rbx
jmp 0x39ca7
movswq 0x1(%rbx), %rax
addq $0x3, %rbx
jmp 0x39ca7
xorl %eax, %eax
movl %eax, -0x10(%rdi)
movzbl (%rbx), %eax
andl $0xf, %eax
movl %eax, -0x4(%rdi)
movzbl (%rbx), %edx
cmpl $0xef, %edx
jbe 0x39ceb
movzbl 0x1(%rbx), %ecx
andl $0xf, %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x39f0d
leaq 0x711b9(%rip), %rdx     # 0xaae90
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movsbq 0x2(%rbx), %rdx
addq $0x3, %rbx
jmp 0x39cf1
incq %rbx
shrl $0x4, %edx
movl %edx, -0xc(%rdi)
movq %rbx, (%rdi)
leaq 0x93822(%rip), %rcx     # 0xcd520
movb (%rax,%rcx), %cl
shll %cl, %edx
movl %edx, -0x8(%rdi)
movq 0x18(%r13), %rax
shrq $0x28, %rax
imull %edx, %eax
cltq
addq %rax, %rbx
movq %rsi, 0x30(%rsp)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x39d70
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq %rdi, %r13
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
movq %r13, %rdi
testq %rax, %rax
je 0x39d8d
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x39d74
movq 0x10(%r14), %rax
testl %r12d, %r12d
movl $0x9, %esi
movl $0x3a, %r8d
cmovel %r8d, %esi
movq %rcx, (%r14)
movb %sil, (%rax,%rdx)
movq %rbx, 0x38(%rsp)
movslq -0x10(%rdi), %r13
testq %r13, %r13
js 0x39f14
cmpl 0x4c(%rsp), %r13d
jge 0x39f14
movq 0x10(%rbp), %rbx
testq %rbx, %rbx
je 0x39f14
movq %r13, %rax
shlq $0x4, %rax
addq %rax, %rbx
movq (%rbx), %r12
testq %r12, %r12
je 0x39f14
movq %rdi, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq (%rax,%r13,8), %rbp
testq %rbp, %rbp
jne 0x39df4
movq %r12, %rdi
callq 0x41c0
movq %rax, %rbp
movq 0x50(%rsp), %rax
movq %rbp, (%rax,%r13,8)
movq (%r14), %rdi
leaq (%rdi,%rbp), %rax
addq $0x2, %rax
cmpq %rdi, %rax
jbe 0x39e4d
cmpq %rax, 0x8(%r14)
movq 0x10(%rsp), %r13
jae 0x39e5f
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x39e82
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdi
jmp 0x39e63
callq 0x4050
movl $0x4b, (%rax)
movq 0x10(%rsp), %r13
jmp 0x39e82
movq 0x10(%r14), %rax
addq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x43c0
movq (%r14), %rax
addq %rbp, %rax
movq %rax, (%r14)
movq 0x10(%r14), %rcx
movb $0x0, (%rcx,%rax)
xorl %r12d, %r12d
cmpq $0x2, %rbp
jne 0x39eb8
movq (%rbx), %rax
cmpb $0x47, (%rax)
movq 0x40(%rsp), %rbp
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
jne 0x39eb1
cmpb $0x54, 0x1(%rax)
movl 0x20(%rsp), %eax
cmovel %esi, %eax
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rbx
jmp 0x39ecc
movq 0x40(%rsp), %rbp
movq 0x38(%rsp), %rbx
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
incq %rsi
movzbl 0x1c(%r13), %eax
addq $0x20, %rdi
cmpq %rax, %rsi
jb 0x39c49
jmp 0x39f97
movl 0x2(%rbx), %edx
addq $0x6, %rbx
jmp 0x39cf1
movq 0x2(%rbx), %rdx
addq $0xa, %rbx
jmp 0x39cf1
movswq 0x2(%rbx), %rdx
addq $0x4, %rbx
jmp 0x39cf1
xorl %edx, %edx
jmp 0x39cf1
movq 0x10(%rsp), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
js 0x39f35
cmpl %eax, 0x4(%rbp)
jle 0x39f35
movq 0x18(%rbp), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %rax
jmp 0x39f37
xorl %eax, %eax
testq %rax, %rax
leaq 0x729ce(%rip), %r8      # 0xac90f
cmovneq %rax, %r8
movq 0x10(%rsp), %rax
movq (%rax), %r9
incq %r9
leaq 0x71e02(%rip), %rsi     # 0xabd59
leaq 0x71ecd(%rip), %rdx     # 0xabe2b
movl $0x1, %edi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x942d
callq 0x4050
movl $0x16, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testb $0x8, 0x1c(%rsp)
jne 0x38ade
movq 0x58(%rsp), %rdi
callq 0x45c0
jmp 0x38ade
testl %r12d, %r12d
je 0x3a03e
movq (%r14), %rcx
movq %rcx, %rax
subq $-0x4, %rax
jae 0x39fed
cmpq %rax, 0x8(%r14)
jae 0x3a021
movq %rax, %rcx
shrq %rcx
xorl %r15d, %r15d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a03e
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rcx
jmp 0x3a025
callq 0x4050
movl $0x4b, (%rax)
jmp 0x3a03e
movslq 0x10(%r13), %rcx
testq %rcx, %rcx
js 0x3a320
cmpl %ecx, 0x4(%rbp)
jle 0x3a320
movq 0x18(%rbp), %rdx
shlq $0x4, %rcx
movq (%rdx,%rcx), %rcx
jmp 0x3a322
movq 0x10(%r14), %rax
movw $0x2e09, (%rax,%rcx)    # imm = 0x2E09
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x2(%rax), %rdx
movq %rdx, (%r14)
movb $0x0, 0x2(%rcx,%rax)
movabsq $0x10000000000, %rax    # imm = 0x10000000000
cmpq %rax, 0x18(%r13)
jb 0x3a306
xorl %r12d, %r12d
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x3a0a4
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a0af
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x3a0a8
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x9, (%rax,%rdx)
movq 0x18(%r13), %rax
movabsq $0xff00000000, %rcx     # imm = 0xFF00000000
xorl %ebx, %ebx
testq %rcx, %rax
je 0x3a199
movl $0x1, %ecx
movq 0x58(%rsp), %r13
cmpq $0x0, 0x10(%r13)
je 0x3a170
testl %ecx, %ecx
jne 0x3a13b
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x3a130
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a13b
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x3a134
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x3a, (%rax,%rdx)
cmpl %ebx, 0x20(%rsp)
je 0x3a1a2
movl 0x4(%r13), %esi
movl 0xc(%r13), %edx
movslq 0x8(%r13), %rcx
imulq %r12, %rcx
addq 0x10(%r13), %rcx
movq %r14, %rdi
cmpl $0x1, %esi
jne 0x3a169
movl %edx, %esi
movq %rcx, %rdx
callq 0x3aeef
jmp 0x3a16e
callq 0x32c74
xorl %ecx, %ecx
incl %ebx
addq $0x20, %r13
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, %rdx
shrq $0x20, %rdx
movzbl %dl, %edx
cmpl %edx, %ebx
jb 0x3a0d2
testl %ecx, %ecx
sete %bpl
jmp 0x3a1cb
movq 0x58(%rsp), %r13
xorl %ebp, %ebp
jmp 0x3a1cb
movq %rbp, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %r14, %rcx
callq 0x3a47c
testl %eax, %eax
js 0x3a34a
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movb $0x1, %bpl
movl 0x20(%rsp), %ebx
incl %ebx
shrq $0x20, %rax
movzbl %al, %eax
cmpl %eax, %ebx
jae 0x3a289
addq $0x30, %r13
cmpq $0x0, (%r13)
je 0x3a272
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x3a23a
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a245
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x3a23e
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x3a, (%rax,%rdx)
movl -0xc(%r13), %esi
movl -0x4(%r13), %edx
movslq -0x8(%r13), %rcx
imulq %r12, %rcx
addq (%r13), %rcx
movq %r14, %rdi
cmpl $0x1, %esi
jne 0x3a26d
movl %edx, %esi
movq %rcx, %rdx
callq 0x3aeef
jmp 0x3a272
callq 0x32c74
incl %ebx
movq 0x10(%rsp), %rax
movzbl 0x1c(%rax), %eax
addq $0x20, %r13
cmpl %eax, %ebx
jb 0x3a1e0
testb %bpl, %bpl
movq 0x10(%rsp), %r13
movq 0x40(%rsp), %rbp
jne 0x3a2f2
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
cmpq %rcx, 0x8(%r14)
jae 0x3a2e7
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a2f2
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movq (%r14), %rdx
leaq 0x1(%rdx), %rcx
jmp 0x3a2eb
movq 0x10(%r14), %rax
movq %rcx, (%r14)
movb $0x2e, (%rax,%rdx)
incq %r12
movq 0x18(%r13), %rax
shrq $0x28, %rax
cmpq %rax, %r12
jb 0x3a055
testb $0x8, 0x1c(%rsp)
movq 0x58(%rsp), %rdi
jne 0x39bb7
callq 0x45c0
jmp 0x39bb7
xorl %ecx, %ecx
testq %rcx, %rcx
leaq 0x725e3(%rip), %r8      # 0xac90f
cmovneq %rcx, %r8
movq (%r13), %r9
incq %r9
leaq 0x71a1b(%rip), %rsi     # 0xabd59
leaq 0x71ac9(%rip), %rdx     # 0xabe0e
jmp 0x39b16
leaq 0x71a08(%rip), %rsi     # 0xabd59
leaq 0x71b19(%rip), %rdx     # 0xabe71
movl $0x1, %edi
movl 0x20(%rsp), %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x942d
jmp 0x39f6d