// File: /workspace/github_c_makefile_star2_O1/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 $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
testq %rsi, %rsi
je 0x396ad
movl 0x10(%r15), %eax
jmp 0x396b2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x396d0
movq 0x28(%rsp), %rcx
cmpl %eax, 0x4(%rcx)
jle 0x396d0
movq 0x18(%rcx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq (%rcx,%rax), %r12
jmp 0x396d3
xorl %r12d, %r12d
testq %r12, %r12
je 0x397a4
movq 0x28(%rsp), %r13
movl (%r13), %eax
movl %eax, 0x3c(%rsp)
movq %r15, %rdi
movl $0x3, %esi
callq 0x38e9d
movq 0x28(%r13), %r14
cmpq $0x0, 0x30(%r14)
jne 0x3971f
movslq (%r13), %rdi
incq %rdi
movl $0x8, %esi
callq 0x42f0
movq %rax, 0x30(%r14)
testq %rax, %rax
je 0x3ac8c
movq 0x30(%r14), %rax
movq %rax, 0x40(%rsp)
movq %r12, %rdi
callq 0x41c0
movq %rax, %r13
movq (%rbx), %rcx
addq %rcx, %rax
addq $0x2, %rax
cmpq %rcx, %rax
jbe 0x397c7
cmpq %rax, 0x8(%rbx)
jae 0x39781
movq %rax, %rcx
shrq %rcx
xorl %ebp, %ebp
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %rbp
addq %rax, %rbp
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x4860
testq %rax, %rax
je 0x397d2
movq %rax, 0x10(%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x43c0
addq (%rbx), %r13
movq %r13, (%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r13)
jmp 0x397d2
movl 0x10(%r15), %ecx
leaq 0x755fa(%rip), %rsi     # 0xaeda9
leaq 0x755fe(%rip), %rdx     # 0xaedb4
movl $0x1, %edi
xorl %eax, %eax
callq 0x9774
jmp 0x3ac81
callq 0x4050
movl $0x4b, (%rax)
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39814
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39826
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
movq (%r15), %r12
movq (%rbx), %rax
addq $0x17, %rax
cmpq %rax, 0x8(%rbx)
jae 0x39870
movq %rax, %rcx
shrq %rcx
xorl %r13d, %r13d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r13
addq %rax, %r13
movq 0x10(%rbx), %rdi
movq %r13, %rsi
callq 0x4860
testq %rax, %rax
je 0x3992d
movq %rax, 0x10(%rbx)
movq %r13, 0x8(%rbx)
cmpq $-0x2, %r12
jg 0x3988d
notq %r12
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2d, (%rcx,%rax)
jmp 0x39890
incq %r12
movq %r12, %rax
shrq $0x20, %rax
jne 0x398a9
movl %r12d, %edi
movq %rbx, %rsi
callq 0x41f37
jmp 0x3992d
movl $0x1, %eax
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
addq %rax, %rax
leaq (%rax,%rax,4), %rax
incl %ecx
cmpq %rax, %r12
jae 0x398b3
movq 0x10(%rbx), %rsi
addq (%rbx), %rsi
leal 0x2(%rcx), %edi
leaq 0x7201e(%rip), %r8      # 0xab8f0
movabsq $0x28f5c28f5c28f5c3, %r9 # imm = 0x28F5C28F5C28F5C3
movq %r12, %r10
movq %r12, %rax
shrq $0x2, %rax
mulq %r9
movq %rdx, %r12
shrq $0x2, %r12
imulq $0x64, %r12, %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 0x398dc
cmpl $-0x1, %ecx
jne 0x3991d
orb $0x30, %r12b
movb %r12b, (%rsi)
movl %edi, %eax
addq (%rbx), %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3996f
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39981
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
movq 0x78(%r15), %rax
testq %rax, %rax
leaq 0x7e963(%rip), %r13     # 0xb82f2
cmovneq %rax, %r13
movq %r13, %rdi
callq 0x41c0
movq %rax, %r12
movq (%rbx), %rcx
addq %rcx, %rax
addq $0x2, %rax
cmpq %rcx, %rax
jbe 0x39a0b
cmpq %rax, 0x8(%rbx)
jae 0x399e8
movq %rax, %rcx
shrq %rcx
xorl %ebp, %ebp
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %rbp
addq %rax, %rbp
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x4860
testq %rax, %rax
je 0x39a16
movq %rax, 0x10(%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x43c0
addq (%rbx), %r12
movq %r12, (%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r12)
jmp 0x39a16
callq 0x4050
movl $0x4b, (%rax)
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39a58
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39a6a
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
cmpw $0x0, 0x1a(%r15)
je 0x39b09
movq 0x88(%r15), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x39b5f
movq %r12, %rdi
callq 0x41c0
movq %rax, %r13
movq (%rbx), %rcx
addq %rcx, %rax
addq $0x2, %rax
cmpq %rcx, %rax
jbe 0x39b6c
cmpq %rax, 0x8(%rbx)
jae 0x39ae6
movq %rax, %rcx
shrq %rcx
xorl %ebp, %ebp
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %rbp
addq %rax, %rbp
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x4860
testq %rax, %rax
je 0x39b77
movq %rax, 0x10(%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x43c0
addq (%rbx), %r13
movq %r13, (%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r13)
jmp 0x39b77
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39b4b
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39b77
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2e, (%rcx,%rax)
jmp 0x39b77
callq 0x4050
movl $0xe, (%rax)
jmp 0x39b77
callq 0x4050
movl $0x4b, (%rax)
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39bb9
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39bcb
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
movzwl 0x1a(%r15), %eax
testl $0xfffe, %eax           # imm = 0xFFFE
movq %r15, 0x8(%rsp)
je 0x39d0c
movzwl 0x1a(%r15), %eax
testl $0xfffe, %eax           # imm = 0xFFFE
je 0x39d60
movl $0x1, %r14d
xorl %r15d, %r15d
cmpq $0x2, %r14
jb 0x39c50
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39c3e
movq %rax, %r12
shrq %r12
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
cmovaq %r15, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39c50
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2c, (%rcx,%rax)
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rax
movq (%rax,%r14,8), %r12
testq %r12, %r12
je 0x39c9c
movq %r12, %rdi
callq 0x41c0
movq %rax, %r13
movq (%rbx), %rcx
addq %rcx, %rax
addq $0x2, %rax
cmpq %rcx, %rax
jbe 0x39ca9
cmpq %rax, 0x8(%rbx)
jae 0x39cd4
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
ja 0x39cb6
movq %rax, %rbp
shrq %rbp
jmp 0x39cb8
callq 0x4050
movl $0xe, (%rax)
jmp 0x39cf5
callq 0x4050
movl $0x4b, (%rax)
jmp 0x39cf5
xorl %ebp, %ebp
addq %rax, %rbp
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x4860
testq %rax, %rax
je 0x39cf5
movq %rax, 0x10(%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x43c0
addq (%rbx), %r13
movq %r13, (%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r13)
incq %r14
movq 0x8(%rsp), %rax
movzwl 0x1a(%rax), %eax
cmpq %rax, %r14
jb 0x39bf9
jmp 0x39d60
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39d4e
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39d60
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2e, (%rcx,%rax)
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
movq 0x8(%rsp), %r15
jae 0x39da7
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39db9
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
movd 0x14(%r15), %xmm0
movd %xmm0, %eax
cmpl %eax, 0x95747(%rip)     # 0xcf510
jne 0x39e21
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39e0d
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39e2d
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2e, (%rcx,%rax)
jmp 0x39e2d
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x8aea4
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39e6f
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x39e81
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
cmpl $0x0, 0x68(%r15)
je 0x39ffa
cmpl $0x0, 0x68(%r15)
jle 0x3a04e
xorl %r14d, %r14d
movq 0x70(%r15), %rax
movslq (%rax,%r14,4), %r12
testq %r12, %r12
js 0x3a0d7
cmpl 0x3c(%rsp), %r12d
jge 0x3a0d7
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %r12, %r15
shlq $0x4, %r15
cmpq $0x0, (%rax,%r15)
je 0x3a0d7
testq %r14, %r14
je 0x39f2d
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x39f1b
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r13d
cmovbeq %rcx, %r13
addq %rax, %r13
movq 0x10(%rbx), %rdi
movq %r13, %rsi
callq 0x4860
testq %rax, %rax
je 0x39f2d
movq %rax, 0x10(%rbx)
movq %r13, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x3b, (%rcx,%rax)
movq 0x40(%rsp), %rcx
cmpq $0x0, (%rcx,%r12,8)
jne 0x39f54
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax,%r15), %rdi
callq 0x41c0
movq 0x40(%rsp), %rcx
movq %rax, (%rcx,%r12,8)
movq (%rcx,%r12,8), %r12
movq (%rbx), %rcx
leaq (%r12,%rcx), %rax
addq $0x2, %rax
cmpq %rcx, %rax
jbe 0x39f97
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx,%r15), %r13
cmpq %rax, 0x8(%rbx)
movq 0x8(%rsp), %r15
jae 0x39fc7
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
ja 0x39fa9
movq %rax, %rbp
shrq %rbp
jmp 0x39fab
callq 0x4050
movl $0x4b, (%rax)
movq 0x8(%rsp), %r15
jmp 0x39fe8
xorl %ebp, %ebp
addq %rax, %rbp
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x4860
testq %rax, %rax
je 0x39fe8
movq %rax, 0x10(%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x43c0
addq (%rbx), %r12
movq %r12, (%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r12)
incq %r14
movslq 0x68(%r15), %rax
cmpq %rax, %r14
jl 0x39e9a
jmp 0x3a04e
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3a03c
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a04e
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2e, (%rcx,%rax)
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3a090
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a0a2
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
cmpw $0x0, 0x18(%r15)
je 0x3a73e
movq 0x30(%r15), %rax
testq %rax, %rax
je 0x3a0ed
movslq 0xc0(%r15), %rcx
addq %rcx, %rax
movslq 0xc4(%r15), %rcx
movslq 0xc8(%r15), %r12
addq %rcx, %r12
addq %rax, %r12
jmp 0x3a0f0
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x3ac2b
movl 0x10(%rdx), %eax
jmp 0x3ac30
xorl %r12d, %r12d
testb $0x4, 0xbc(%r15)
jne 0x3a108
cmpq $0x0, 0x20(%r15)
setne %al
movl %eax, 0x30(%rsp)
jmp 0x3a110
movl $0x0, 0x30(%rsp)
cmpw $0x0, 0x18(%r15)
je 0x3a73e
movq 0x90(%r15), %rcx
movl $0x1, %r9d
xorl %edx, %edx
cmpb $0x0, 0x30(%rsp)
je 0x3a167
movzbl (%r12), %eax
andl $0xf, %eax
decl %eax
cmpl $0x3, %eax
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
ja 0x3a1b4
leaq 0x73d62(%rip), %rsi     # 0xadeb4
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
movsbq 0x1(%r12), %rax
addq $0x2, %r12
jmp 0x3a1b6
cmpq $0x0, 0x10(%rcx)
je 0x3a185
movq %rdx, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %rcx, 0x10(%rsp)
movq %rcx, %r12
jmp 0x3a22e
movl $0xa, %ebp
xorl %r13d, %r13d
jmp 0x3a441
movl 0x1(%r12), %eax
addq $0x5, %r12
jmp 0x3a1b6
movq 0x1(%r12), %rax
addq $0x9, %r12
jmp 0x3a1b6
movswq 0x1(%r12), %rax
addq $0x3, %r12
jmp 0x3a1b6
xorl %eax, %eax
movl %eax, 0x50(%rsp)
movzbl (%r12), %eax
andl $0xf, %eax
movl %eax, 0x54(%rsp)
movzbl (%r12), %edx
cmpl $0xef, %edx
jbe 0x3a203
movzbl 0x1(%r12), %ecx
andl $0xf, %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x3a4f0
leaq 0x73cd6(%rip), %rdx     # 0xadec4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movsbq 0x2(%r12), %rdx
addq $0x3, %r12
jmp 0x3a209
incq %r12
shrl $0x4, %edx
movl %edx, 0x70(%rsp)
leaq 0x9530c(%rip), %rcx     # 0xcf520
movb (%rax,%rcx), %cl
shll %cl, %edx
movq %r12, 0x60(%rsp)
movslq %edx, %rax
addq %rax, %r12
movq %r12, 0x20(%rsp)
leaq 0x50(%rsp), %r12
movl (%r12), %ecx
movl %ecx, %eax
testl %ecx, %ecx
setns %dl
cmpl 0x3c(%rsp), %ecx
setl %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x3a25c
movq %rax, %r14
shlq $0x4, %r14
movq 0x28(%rsp), %rdx
addq 0x10(%rdx), %r14
jmp 0x3a25f
xorl %r14d, %r14d
testq %r14, %r14
je 0x3a377
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3a377
movslq %ecx, %r15
movq 0x40(%rsp), %rcx
cmpq $0x0, (%rcx,%r15,8)
jne 0x3a297
movq %r9, %r13
callq 0x41c0
movq %r13, %r9
movq 0x40(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movq (%rcx,%r15,8), %rbp
movq (%rbx), %rax
addq %rbp, %rax
addq $0x3, %rax
cmpq %rax, 0x8(%rbx)
jae 0x3a2f5
movq %r9, 0x48(%rsp)
movq %rax, %rcx
shrq %rcx
xorl %r13d, %r13d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a4a2
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq 0x48(%rsp), %r9
movq 0x10(%rbx), %r13
addq (%rbx), %r13
testl %r9d, %r9d
jne 0x3a30c
movb $0x3b, (%r13)
incq %r13
incq (%rbx)
movq 0x8(%rsp), %r15
movq (%r14), %rsi
movq %r13, %rdi
movq %rbp, %rdx
callq 0x43c0
addq %rbp, (%rbx)
cmpl $0x0, 0x20(%r12)
jle 0x3a427
movb $0x3d, (%r13,%rbp)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
movl 0x20(%r12), %esi
cmpl $0x1, %esi
setne %dl
orb 0x30(%rsp), %dl
movslq 0x4(%r12), %rax
testb $0x1, %dl
je 0x3a468
movq 0x10(%r12), %rcx
movq %rbx, %rdi
movl %eax, %edx
callq 0x3399d
movb $0x1, %r13b
xorl %r9d, %r9d
xorl %ebp, %ebp
jmp 0x3a432
cmpl 0x3c(%rsp), %eax
leaq 0x71048(%rip), %r8      # 0xab3ca
leaq 0x74a45(%rip), %rax     # 0xaedce
cmovlq %rax, %r8
testl %ecx, %ecx
leaq 0x7ff7d(%rip), %rax     # 0xba313
cmovsq %rax, %r8
testq %r15, %r15
je 0x3a3a5
movl 0x10(%r15), %eax
jmp 0x3a3aa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x20(%rsp), %r12
movq %r9, %r14
testl %eax, %eax
js 0x3a3d0
movq 0x28(%rsp), %rdx
cmpl %eax, 0x4(%rdx)
jle 0x3a3d0
movq 0x18(%rdx), %rdx
movl %eax, %eax
shlq $0x4, %rax
movq (%rdx,%rax), %r9
jmp 0x3a3d3
xorl %r9d, %r9d
testq %r9, %r9
leaq 0x75582(%rip), %rax     # 0xaf95f
cmoveq %rax, %r9
movq (%r15), %rax
incq %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movl $0x1, %ebp
movl $0x1, %edi
leaq 0x749aa(%rip), %rsi     # 0xaeda9
leaq 0x74a28(%rip), %rdx     # 0xaee2e
xorl %eax, %eax
callq 0x9774
callq 0x4050
movl $0x16, (%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq %r14, %r9
jmp 0x3a441
movl $0xa, %ebp
xorl %r9d, %r9d
xorl %r13d, %r13d
movq 0x20(%rsp), %r12
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
cmpl $0xa, %ebp
je 0x3a44e
testl %ebp, %ebp
jne 0x3ac97
incq %rdx
movzwl 0x18(%r15), %eax
addq $0x28, %rcx
cmpq %rax, %rdx
jb 0x3a12b
jmp 0x3a739
cmpl $0x7, %eax
je 0x3a4f7
cmpl $0x5, %eax
jne 0x3a564
movd 0x8(%r12), %xmm0
movd %xmm0, %eax
cmpl %eax, 0x95085(%rip)     # 0xcf510
je 0x3a57f
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x8aea4
jmp 0x3a36a
movl $0x1, %ebp
movq 0x8(%rsp), %r15
movq 0x20(%rsp), %r12
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq 0x48(%rsp), %r9
jmp 0x3a441
movl 0x2(%r12), %edx
addq $0x6, %r12
jmp 0x3a209
movq 0x2(%r12), %rdx
addq $0xa, %r12
jmp 0x3a209
movswq 0x2(%r12), %rdx
addq $0x4, %r12
jmp 0x3a209
xorl %edx, %edx
jmp 0x3a209
movq 0x8(%r12), %r14
addq $0x2, %rcx
cmpq %rcx, 0x8(%rbx)
movq 0x20(%rsp), %r12
jae 0x3a54d
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a68f
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq 0x8(%rsp), %r15
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb %r14b, (%rcx,%rax)
jmp 0x3a682
cmpl $0x3, %eax
jg 0x3a5e7
movq 0x8(%r12), %rbp
leaq 0x75b9b(%rip), %rdx     # 0xb0110
cmpq (%rdx,%rax,8), %rbp
jne 0x3a613
addq $0x2, %rcx
cmpq %rcx, 0x8(%rbx)
movq 0x20(%rsp), %r12
jae 0x3a5d0
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a68f
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq 0x8(%rsp), %r15
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2e, (%rcx,%rax)
jmp 0x3a682
cmpl $0x4, %eax
jne 0x3a6ab
movq 0x8(%r12), %rdi
movq %rdi, %rax
negq %rax
jno 0x3a6b6
movl $0x2e, %edi
movq %rbx, %rsi
callq 0x34261
jmp 0x3a36a
testl %ebp, %ebp
movq 0x20(%rsp), %r12
jns 0x3a678
addq $0x4, %rcx
cmpq %rcx, 0x8(%rbx)
jae 0x3a664
movq %rcx, %rax
shrq %rax
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
movl $0x0, %r15d
cmovbeq %rax, %r15
addq %rcx, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a68f
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq 0x8(%rsp), %r15
negl %ebp
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2d, (%rcx,%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x41f37
movb $0x1, %r13b
xorl %r9d, %r9d
xorl %ebp, %ebp
jmp 0x3a437
movb $0x1, %r13b
xorl %ebp, %ebp
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
xorl %r9d, %r9d
jmp 0x3a441
testq %r15, %r15
je 0x3a6c3
movl 0x10(%r15), %ecx
jmp 0x3a6c8
movq %rbx, %rsi
callq 0x3b0d6
jmp 0x3a36a
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq 0x20(%rsp), %r12
testl %ecx, %ecx
js 0x3a6eb
movq 0x28(%rsp), %rdx
cmpl %ecx, 0x4(%rdx)
jle 0x3a6eb
movq 0x18(%rdx), %rdx
movl %ecx, %ecx
shlq $0x4, %rcx
movq (%rdx,%rcx), %r8
jmp 0x3a6ee
xorl %r8d, %r8d
testq %r8, %r8
leaq 0x75267(%rip), %rcx     # 0xaf95f
cmoveq %rcx, %r8
movq (%r15), %r9
incq %r9
movl $0x1, %ebp
movl $0x1, %edi
leaq 0x74696(%rip), %rsi     # 0xaeda9
leaq 0x74744(%rip), %rdx     # 0xaee5e
movl %eax, %ecx
xorl %eax, %eax
callq 0x9774
callq 0x4050
xorl %r9d, %r9d
movl $0x16, (%rax)
xorl %r13d, %r13d
jmp 0x3a437
testl %r9d, %r9d
je 0x3a792
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3a780
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a792
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2e, (%rcx,%rax)
movq 0x18(%r15), %rdi
movq %rdi, %rax
shrq $0x28, %rax
je 0x3b018
movabsq $0xff00000000, %rax     # imm = 0xFF00000000
testq %rax, %rdi
je 0x3a7f1
movq 0x48(%r15), %rsi
movl 0xbc(%r15), %eax
movl %eax, 0x18(%rsp)
testb $0x8, %al
jne 0x3a884
shrq $0x1b, %rdi
andl $0x1fe0, %edi           # imm = 0x1FE0
movq %rsi, %r14
callq 0x46a0
movq %r14, %rsi
movq %rax, 0x30(%rsp)
testq %rax, %rax
jne 0x3a890
jmp 0x3ac8c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movq (%rbx), %rax
subq $-0x4, %rax
jae 0x3a85d
cmpq %rax, 0x8(%rbx)
jae 0x3a83b
movq %rax, %r15
shrq %r15
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
cmovaq %r14, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3a868
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movw $0x2e09, (%rcx,%rax)    # imm = 0x2E09
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x2(%rax), %rdx
movq %rdx, (%rbx)
movb $0x0, 0x2(%rcx,%rax)
jmp 0x3a868
callq 0x4050
movl $0x4b, (%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
shrq $0x28, %rax
incl %ebp
cmpl %eax, %ebp
jb 0x3a7f9
jmp 0x3b018
movq 0x98(%r15), %rax
movq %rax, 0x30(%rsp)
movabsq $0xff00000000, %rax     # imm = 0xFF00000000
testq %rax, 0x18(%r15)
je 0x3acb8
movq 0x30(%rsp), %rax
leaq 0x10(%rax), %r15
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0x1, %r13d
xorl %ebp, %ebp
testb $0x8, 0x18(%rsp)
jne 0x3a986
movzbl (%rsi), %eax
andl $0xf, %eax
decl %eax
cmpl $0x3, %eax
ja 0x3a90c
leaq 0x735fa(%rip), %rcx     # 0xaded4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbq 0x1(%rsi), %rax
addq $0x2, %rsi
jmp 0x3a90e
movl 0x1(%rsi), %eax
addq $0x5, %rsi
jmp 0x3a90e
movq 0x1(%rsi), %rax
addq $0x9, %rsi
jmp 0x3a90e
movswq 0x1(%rsi), %rax
addq $0x3, %rsi
jmp 0x3a90e
xorl %eax, %eax
movl %eax, -0x10(%r15)
movzbl (%rsi), %eax
andl $0xf, %eax
movl %eax, -0x4(%r15)
movzbl (%rsi), %edx
cmpl $0xef, %edx
jbe 0x3a954
movzbl 0x1(%rsi), %ecx
andl $0xf, %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x3ac24
leaq 0x735a4(%rip), %rdx     # 0xadee4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movsbq 0x2(%rsi), %rdx
addq $0x3, %rsi
jmp 0x3a95a
incq %rsi
shrl $0x4, %edx
movl %edx, -0xc(%r15)
movq %rsi, (%r15)
leaq 0x94bb8(%rip), %rcx     # 0xcf520
movb (%rax,%rcx), %cl
shll %cl, %edx
movl %edx, -0x8(%r15)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
shrq $0x28, %rax
imull %edx, %eax
cltq
addq %rax, %rsi
cmpq $0x0, (%r15)
movl %r14d, 0x10(%rsp)
je 0x3aa2a
movq %rsi, 0x20(%rsp)
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3a9df
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r12d
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x3aa00
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
testl %r13d, %r13d
movl $0x9, %eax
movl $0x3a, %ecx
cmovel %ecx, %eax
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rbx)
movb %al, (%rdx,%rcx)
movl -0x10(%r15), %eax
movl %eax, %ecx
testl %eax, %eax
setns %dl
cmpl 0x3c(%rsp), %eax
setl %al
andb %dl, %al
cmpb $0x1, %al
jne 0x3aa37
movq %rcx, %r14
shlq $0x4, %r14
movq 0x28(%rsp), %rax
addq 0x10(%rax), %r14
jmp 0x3aa3a
movl $0xd, %r14d
xorl %eax, %eax
jmp 0x3abcb
xorl %r14d, %r14d
testq %r14, %r14
je 0x3aaf8
movq (%r14), %r13
testq %r13, %r13
je 0x3aaf8
movslq %ecx, %r12
movq 0x40(%rsp), %rcx
cmpq $0x0, (%rcx,%r12,8)
jne 0x3aa6f
movq %r13, %rdi
callq 0x41c0
movq 0x40(%rsp), %rcx
movq %rax, (%rcx,%r12,8)
movq (%rcx,%r12,8), %r12
movq (%rbx), %rcx
leaq (%r12,%rcx), %rax
addq $0x2, %rax
cmpq %rcx, %rax
jbe 0x3ab8c
cmpq %rax, 0x8(%rbx)
jae 0x3aad0
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %esi
cmovbeq %rcx, %rsi
addq %rax, %rsi
movq 0x10(%rbx), %rdi
movq %rsi, 0x48(%rsp)
callq 0x4860
testq %rax, %rax
je 0x3ab97
movq %rax, 0x10(%rbx)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x43c0
movq (%rbx), %rax
addq %r12, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx,%rax)
jmp 0x3ab97
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x3ab07
movl 0x10(%rax), %eax
jmp 0x3ab0c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x3ab2a
movq 0x28(%rsp), %rdx
cmpl %eax, 0x4(%rdx)
jle 0x3ab2a
movq 0x18(%rdx), %rdx
movl %eax, %eax
shlq $0x4, %rax
movq (%rdx,%rax), %r8
jmp 0x3ab2d
xorl %r8d, %r8d
testq %r8, %r8
leaq 0x74e28(%rip), %rax     # 0xaf95f
cmoveq %rax, %r8
movq 0x8(%rsp), %rax
movq (%rax), %r9
incq %r9
xorl %r13d, %r13d
movl $0x1, %r14d
movl $0x1, %edi
leaq 0x7424e(%rip), %rsi     # 0xaeda9
leaq 0x74319(%rip), %rdx     # 0xaee7b
xorl %eax, %eax
callq 0x9774
callq 0x4050
movl $0x16, (%rax)
testb $0x8, 0x18(%rsp)
jne 0x3ab88
movq 0x30(%rsp), %rdi
callq 0x45c0
xorl %r13d, %r13d
xorl %eax, %eax
jmp 0x3abc6
callq 0x4050
movl $0x4b, (%rax)
movb $0x1, %al
xorl %r13d, %r13d
cmpq $0x2, %r12
jne 0x3abc3
movq (%r14), %rcx
cmpb $0x47, (%rcx)
movq 0x20(%rsp), %rsi
jne 0x3abbe
cmpb $0x54, 0x1(%rcx)
movl 0x10(%rsp), %ecx
cmovel %ebp, %ecx
movl %ecx, 0x10(%rsp)
xorl %r14d, %r14d
jmp 0x3abcb
xorl %r14d, %r14d
movq 0x20(%rsp), %rsi
cmpl $0xd, %r14d
je 0x3abda
testl %r14d, %r14d
jne 0x3ad3b
incq %rbp
movq 0x8(%rsp), %rax
movzbl 0x1c(%rax), %eax
addq $0x20, %r15
cmpq %rax, %rbp
movl 0x10(%rsp), %r14d
jb 0x3a8bb
jmp 0x3acab
movl 0x2(%rsi), %edx
addq $0x6, %rsi
jmp 0x3a95a
movq 0x2(%rsi), %rdx
addq $0xa, %rsi
jmp 0x3a95a
movswq 0x2(%rsi), %rdx
addq $0x4, %rsi
jmp 0x3a95a
xorl %edx, %edx
jmp 0x3a95a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rcx
testl %eax, %eax
js 0x3ac4e
cmpl %eax, 0x4(%rcx)
jle 0x3ac4e
movq 0x18(%rcx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq (%rcx,%rax), %rax
jmp 0x3ac50
xorl %eax, %eax
testq %rax, %rax
leaq 0x74d05(%rip), %r8      # 0xaf95f
cmovneq %rax, %r8
movq (%rdx), %r9
incq %r9
leaq 0x7413e(%rip), %rsi     # 0xaeda9
leaq 0x74176(%rip), %rdx     # 0xaede8
movl $0x1, %edi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x9774
callq 0x4050
movl $0x16, (%rax)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x3b081
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb %r13b, %r13b
jne 0x3a792
jmp 0x3b081
testl %r13d, %r13d
sete %al
movq 0x8(%rsp), %r15
jmp 0x3acc2
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movabsq $0x10000000000, %r14    # imm = 0x10000000000
testb %al, %al
jne 0x3ad59
movq (%rbx), %rax
subq $-0x4, %rax
jae 0x3ad4e
cmpq %rax, 0x8(%rbx)
jae 0x3ad19
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x3ad59
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movw $0x2e09, (%rcx,%rax)    # imm = 0x2E09
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x2(%rax), %rdx
movq %rdx, (%rbx)
movb $0x0, 0x2(%rcx,%rax)
jmp 0x3ad59
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb %al, %al
jne 0x3b018
jmp 0x3b081
callq 0x4050
movl $0x4b, (%rax)
cmpq %r14, 0x18(%r15)
movl 0x10(%rsp), %r14d
jb 0x3b007
xorl %r13d, %r13d
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3adb0
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r12d
cmovbeq %rcx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x3adc2
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x9, (%rcx,%rax)
movabsq $0xff00000000, %rax     # imm = 0xFF00000000
testq %rax, 0x18(%r15)
je 0x3aea1
xorl %ebp, %ebp
movl $0x1, %eax
movq 0x30(%rsp), %r12
cmpq $0x0, 0x10(%r12)
je 0x3ae86
testl %eax, %eax
jne 0x3ae49
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3ae37
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3ae49
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x3a, (%rcx,%rax)
cmpl %ebp, %r14d
je 0x3aead
movl 0x4(%r12), %esi
movl 0xc(%r12), %edx
movslq 0x8(%r12), %rcx
imulq %r13, %rcx
addq 0x10(%r12), %rcx
cmpl $0x1, %esi
movq 0x8(%rsp), %r15
movq %rbx, %rdi
jne 0x3ae7f
movl %edx, %esi
movq %rcx, %rdx
callq 0x3bc3f
jmp 0x3ae84
callq 0x3399d
xorl %eax, %eax
incl %ebp
addq $0x20, %r12
movzbl 0x1c(%r15), %ecx
cmpl %ecx, %ebp
jb 0x3ade2
testl %eax, %eax
sete %r14b
jmp 0x3aed0
xorl %ebp, %ebp
movq 0x30(%rsp), %r12
xorl %r14d, %r14d
jmp 0x3aed0
movq 0x28(%rsp), %rdi
movq %r12, %rsi
movl %r13d, %edx
movq %rbx, %rcx
callq 0x3b1e2
movb $0x1, %r14b
testl %eax, %eax
movq 0x8(%rsp), %r15
js 0x3b093
incl %ebp
movzbl 0x1c(%r15), %eax
cmpl %eax, %ebp
jae 0x3af8d
addq $0x30, %r12
cmpq $0x0, (%r12)
je 0x3af7a
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3af33
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3af45
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x3a, (%rcx,%rax)
movl -0xc(%r12), %esi
movl -0x4(%r12), %edx
movslq -0x8(%r12), %rcx
imulq %r13, %rcx
addq (%r12), %rcx
cmpl $0x1, %esi
movq 0x8(%rsp), %r15
movq %rbx, %rdi
jne 0x3af75
movl %edx, %esi
movq %rcx, %rdx
callq 0x3bc3f
jmp 0x3af7a
callq 0x3399d
incl %ebp
movzbl 0x1c(%r15), %eax
addq $0x20, %r12
cmpl %eax, %ebp
jb 0x3aee3
testb %r14b, %r14b
movl 0x10(%rsp), %r14d
jne 0x3afee
movq (%rbx), %rax
incq %rax
cmpq %rax, 0x8(%rbx)
jae 0x3afdc
movq %rax, %rcx
shrq %rcx
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r15d
cmovbeq %rcx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x3afee
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0x2e, (%rcx,%rax)
incq %r13
movq 0x8(%rsp), %r15
movq 0x18(%r15), %rax
shrq $0x28, %rax
cmpq %rax, %r13
jb 0x3ad6b
testb $0x8, 0x18(%rsp)
jne 0x3b018
movq 0x30(%rsp), %rdi
callq 0x45c0
movq (%rbx), %rax
addq $0x2, %rax
cmpq %rax, 0x8(%rbx)
jae 0x3b061
movq %rax, %rcx
shrq %rcx
xorl %r12d, %r12d
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rax
movl $0x0, %r14d
cmovbeq %rcx, %r14
addq %rax, %r14
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x4860
testq %rax, %rax
je 0x3b081
movq %rax, 0x10(%rbx)
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb $0xa, (%rcx,%rax)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx,%rax)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73d0f(%rip), %rsi     # 0xaeda9
leaq 0x73e20(%rip), %rdx     # 0xaeec1
movl $0x1, %edi
movl %ebp, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x9774
callq 0x4050
movl $0x16, (%rax)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb $0x8, 0x18(%rsp)
jne 0x3b081
movq 0x30(%rsp), %rdi
callq 0x45c0
jmp 0x3b081