// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/htscodecs/htscodecs/tokenise_name3.c
// Function: tok3_encode_names
uint8_t *tok3_encode_names(char *blk, int len, int level, int use_arith,
                           int *out_len, int *last_start_p) {
    int last_start = 0, i, j, nreads;

    if (len < 0) {
        *out_len = 0;
        return NULL;
    }

    // Count lines
    for (nreads = i = 0; i < len; i++)
        if (blk[i] <= '\n') // \n or \0 separated entries
            nreads++;

    name_context *ctx = create_context(nreads);
    if (!ctx)
        return NULL;

    // Construct trie
    int ctr = 0;
    for (i = j = 0; i < len; j=++i) {
        while (i < len && blk[i] > '\n')
            i++;
        if (i >= len)
            break;

        //blk[i] = '\0';
        last_start = i+1;
        if (build_trie(ctx, &blk[j], i-j, ctr++) < 0) {
            free_context(ctx);
            return NULL;
        }
    }
    if (last_start_p)
        *last_start_p = last_start;

    //fprintf(stderr, "Processed %d of %d in block, line %d\n", last_start, len, ctr);

    // Encode name
    for (i = j = 0; i < len; j=++i) {
        while (i < len && (signed char)blk[i] >= ' ') // non-ASCII check
            i++;
        if (i >= len)
            break;

        if (blk[i] != '\0' && blk[i] != '\n') {
            // Names must be 7-bit ASCII printable
            free_context(ctx);
            return NULL;
        }

        blk[i] = '\0';
        // try both 0 and 1 and pick best?
        if (encode_name(ctx, &blk[j], i-j, 1) < 0) {
            free_context(ctx);
            return NULL;
        }
    }

#if 0
    for (i = 0; i < ctx->max_tok*16; i++) {
        char fn[1024];
        if (!ctx->desc[i].buf_l) continue;
        sprintf(fn, "_tok.%02d_%02d.%d", i>>4,i&15,i);
        FILE *fp = fopen(fn, "w");
        fwrite(ctx->desc[i].buf, 1, ctx->desc[i].buf_l, fp);
        fclose(fp);
    }
#endif

    //dump_trie(t_head, 0);

    // FIXME: merge descriptors
    //
    // If we see foo7:1 foo7:12 foo7:7 etc then foo: is constant,
    // but it's encoded as alpha<foo>+dig<7>+char<:> instead of alpha<foo7:>.
    // Any time token type 0 is all match beyond the first location we have
    // a candidate for merging in string form.
    //
    // This saves around .1 to 1.3 percent on varying data sets.
    // Cruder hack is dedicated prefix/suffix matching to short-cut this.


    // Drop N_TYPE blocks if they all contain matches bar the first item,
    // as we can regenerate these from the subsequent blocks types during
    // decode.
    for (i = 0; i < ctx->max_tok*16; i+=16) {
        if (!ctx->desc[i].buf_l) continue;

        int z;
        for (z=1; z<ctx->desc[i].buf_l; z++) {
            if (ctx->desc[i].buf[z] != N_MATCH)
                break;
        }
        if (z == ctx->desc[i].buf_l) {
            int k;
            for (k=1; k<16; k++)
                if (ctx->desc[i+k].buf_l)
                    break;

            if (k < 16) {
                ctx->desc[i].buf_l = 0;
                free(ctx->desc[i].buf);
                ctx->desc[i].buf = NULL;
            }
        }
    }

    // Serialise descriptors
    uint32_t tot_size = 9;
    for (i = 0; i < ctx->max_tok*16; i++) {
        if (!ctx->desc[i].buf_l) continue;

        int tnum = i>>4;
        int ttype = i&15;

        uint64_t out_len = 1.5 * arith_compress_bound(ctx->desc[i].buf_l, 1); // guesswork
        uint8_t *out = malloc(out_len);
        if (!out) {
            free_context(ctx);
            return NULL;
        }

        if (compress(ctx->desc[i].buf, ctx->desc[i].buf_l, i&0xf, level,
                     use_arith, out, &out_len) < 0) {
            free_context(ctx);
            free(out);
            return NULL;
        }

        free(ctx->desc[i].buf);
        ctx->desc[i].buf = out;
        ctx->desc[i].buf_l = out_len;
        ctx->desc[i].tnum = tnum;
        ctx->desc[i].ttype = ttype;

        // Find dups
        int j;
        for (j = 0; j < i; j++) {
            if (!ctx->desc[j].buf)
                continue;
            if (ctx->desc[i].buf_l != ctx->desc[j].buf_l || ctx->desc[i].buf_l <= 4)
                continue;
            if (memcmp(ctx->desc[i].buf, ctx->desc[j].buf, ctx->desc[i].buf_l) == 0)
                break;
        }
        if (j < i) {
            ctx->desc[i].dup_from = j;
            tot_size += 3; // flag, dup_from, ttype
        } else {
            ctx->desc[i].dup_from = -1;
            tot_size += out_len + 1; // ttype
        }
    }

#if 0
    for (i = 0; i < ctx->max_tok*16; i++) {
        char fn[1024];
        if (!ctx->desc[i].buf_l && ctx->desc[i].dup_from == -1) continue;
        sprintf(fn, "_tok.%02d_%02d.%d.comp", i>>4,i&15,i);
        FILE *fp = fopen(fn, "w");
        fwrite(ctx->desc[i].buf, 1, ctx->desc[i].buf_l, fp);
        fclose(fp);
    }
#endif

    // Write
    uint8_t *out = malloc(tot_size+13);
    if (!out) {
        free_context(ctx);
        return NULL;
    }

    uint8_t *cp = out;

    *out_len = tot_size;
//    *(uint32_t *)cp = last_start; cp += 4;
//    *(uint32_t *)cp = nreads;     cp += 4;
    *cp++ = (last_start >>  0) & 0xff;
    *cp++ = (last_start >>  8) & 0xff;
    *cp++ = (last_start >> 16) & 0xff;
    *cp++ = (last_start >> 24) & 0xff;
    *cp++ = (nreads     >>  0) & 0xff;
    *cp++ = (nreads     >>  8) & 0xff;
    *cp++ = (nreads     >> 16) & 0xff;
    *cp++ = (nreads     >> 24) & 0xff;
    *cp++ = use_arith;
    //write(1, &nreads, 4);
    int last_tnum = -1;
    for (i = 0; i < ctx->max_tok*16; i++) {
        if (!ctx->desc[i].buf_l) continue;
        uint8_t ttype8 = ctx->desc[i].ttype;
        if (ctx->desc[i].tnum != last_tnum) {
            ttype8 |= 128;
            last_tnum = ctx->desc[i].tnum;
        }
        if (ctx->desc[i].dup_from >= 0) {
            //fprintf(stderr, "Dup %d from %d, sz %d\n", i, ctx->desc[i].dup_from, ctx->desc[i].buf_l);
            *cp++ = ttype8 | 64;
            *cp++ = ctx->desc[i].dup_from >> 4;
            *cp++ = ctx->desc[i].dup_from & 15;
        } else {
            *cp++ = ttype8;
            memcpy(cp, ctx->desc[i].buf, ctx->desc[i].buf_l);
            cp += ctx->desc[i].buf_l;
        }
    }

    //assert(cp-out == tot_size);

    free_context(ctx);

    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x27e8, %rsp           # imm = 0x27E8
movl %ecx, 0x6c(%rsp)
testl %esi, %esi
js 0x618a6
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movq %r9, 0x48(%rsp)
movl %esi, %r12d
xorl %eax, %eax
xorl %edi, %edi
cmpq %rax, %r12
je 0x615df
xorl %ecx, %ecx
cmpb $0xb, (%r15,%rax)
setl %cl
addl %ecx, %edi
incq %rax
jmp 0x615c9
movq %r8, 0xb8(%rsp)
movl %edi, 0xb4(%rsp)
callq 0x62bc7
movq %rax, %r13
xorl %eax, %eax
testq %r13, %r13
je 0x62ba8
movq $0x0, 0x28(%rsp)
movq %r12, 0x88(%rsp)
movq %r15, 0x78(%rsp)
movl %ebx, 0x80(%rsp)
xorl %ecx, %ecx
movq %r13, (%rsp)
cmpl %r14d, %ecx
movq %rcx, 0xa8(%rsp)
jge 0x618af
movslq %ecx, %r8
movq 0x88(%rsp), %rax
subq %r8, %rax
addq 0x78(%rsp), %r8
xorl %r12d, %r12d
cmpq %r12, %rax
je 0x618af
cmpb $0xb, (%r8,%r12)
jl 0x61660
incq %r12
jmp 0x6164b
movl %r14d, 0x5c(%rsp)
cmpq $0x0, 0x10(%r13)
movq %r8, 0x10(%rsp)
jne 0x61692
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x4300
movq 0x10(%rsp), %r8
movq (%rsp), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x62a8e
movslq %r12d, %r9
movq 0x28(%rsp), %rax
shll $0x8, %eax
movl %eax, 0x20(%rsp)
xorl %r14d, %r14d
movq (%rsp), %r13
movq 0xa8(%rsp), %rcx
movq %r9, 0x50(%rsp)
cmpq %r9, %r14
jae 0x6188b
movq 0x10(%r13), %r10
incl 0x10(%r10)
cmpq %r14, %r12
je 0x61880
movzbl (%r8,%r14), %r15d
cmpl $0xb, %r15d
jb 0x61883
testb %r15b, %r15b
js 0x62a8e
incq %r14
movq %r10, %rcx
xorl %ebp, %ebp
movq (%rcx), %rax
testq %rax, %rax
je 0x6170c
movl 0x14(%rax), %ecx
cmpb %cl, %r15b
je 0x61860
leaq 0x8(%rax), %rcx
movq %rax, %rbp
jmp 0x616ef
movq (%rsp), %rax
movq 0x18(%rax), %rbx
testq %rbx, %rbx
jne 0x61756
movq %r10, %r13
pushq $0x20
popq %rdi
callq 0x4680
movq %rax, %rbx
testq %rax, %rax
je 0x61741
movq $0x18, (%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
movq (%rsp), %rax
movq %rbx, 0x18(%rax)
movq 0x10(%rsp), %r8
movq 0x50(%rsp), %r9
movq %r13, %r10
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x6176b
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
jmp 0x6183b
movq (%rbx), %r13
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
testq %rsi, %rsi
je 0x617b0
movq %rsi, %rax
shlq $0x4, %rax
movq -0x8(%rdi,%rax), %rcx
leaq (%rcx,%r13), %rdx
cmpq $0x100000, %rdx         # imm = 0x100000
jae 0x617b0
addq %rax, %rdi
movq -0x10(%rdi), %rax
movq %rdx, -0x8(%rdi)
testq %rax, %rax
je 0x62a8e
addq %rcx, %rax
jmp 0x6183b
shlq $0x4, %rsi
addq $0x10, %rsi
movq %r10, 0x18(%rsp)
callq 0x4840
testq %rax, %rax
je 0x62a8e
movq %rax, %rcx
movl $0x100000, %eax         # imm = 0x100000
xorl %edx, %edx
divq %r13
movq %rcx, 0x10(%rbx)
movq (%rbx), %rdx
movq 0x8(%rbx), %r13
movq %r13, 0x40(%rsp)
shlq $0x4, %r13
movq %rdx, 0x30(%rsp)
imulq %rdx, %rax
movq %rax, %rdi
movq %rcx, 0x8(%rsp)
callq 0x4680
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %r10
movq 0x50(%rsp), %r9
movq 0x10(%rsp), %r8
movq %rax, (%rcx,%r13)
testq %rax, %rax
je 0x62a8e
addq %r13, %rcx
movq 0x40(%rsp), %rdx
incq %rdx
movq %rdx, 0x8(%rbx)
movq 0x30(%rsp), %rdx
movq %rdx, 0x8(%rcx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x8(%rbp), %rcx
testq %rbp, %rbp
cmoveq %r10, %rcx
movq %rax, (%rcx)
movl 0x20(%rsp), %ecx
orl %r15d, %ecx
movl %ecx, 0x14(%rax)
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl %r15d, %ecx
movl %ecx, 0x14(%rax)
movq %rax, %r10
movq (%rsp), %r13
movq 0xa8(%rsp), %rcx
jmp 0x616c2
movq %r12, %r14
incq %r14
jmp 0x616b5
movq 0x28(%rsp), %rax
incl %eax
movq %rax, 0x28(%rsp)
addl %r12d, %ecx
incl %ecx
movl 0x5c(%rsp), %r14d
jmp 0x61624
andl $0x0, (%r8)
jmp 0x62ba6
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x618bb
movl %ecx, (%rax)
leaq 0x20(%r13), %rax
movq %rax, 0x40(%rsp)
leaq 0x14020(%r13), %rax
movq %rax, 0x90(%rsp)
leaq 0x14220(%r13), %rax
movq %rax, 0x98(%rsp)
movq 0x78(%rsp), %rax
decq %rax
movq %rax, 0xa0(%rsp)
pushq $0x9
popq %rbp
xorl %eax, %eax
movq %rax, 0x70(%rsp)
cmpl %r14d, %eax
jge 0x6261b
movq 0x70(%rsp), %rsi
movslq %esi, %r12
movq %r12, %rax
shlq $0x20, %rax
movq 0x88(%rsp), %rcx
subq %r12, %rcx
movq 0x78(%rsp), %rdx
addq %r12, %rdx
movq %rdx, 0x10(%rsp)
movl %esi, %ebx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x6261b
movq 0x10(%rsp), %rdx
cmpb $0x20, (%rdx,%rsi)
jl 0x61958
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rdx, %rax
incq %rsi
incl %ebx
jmp 0x61930
movq %rsi, 0x48(%rsp)
sarq $0x20, %rax
movq 0x78(%rsp), %rcx
movzbl (%rcx,%rax), %ecx
testl %ecx, %ecx
je 0x61977
cmpl $0xa, %ecx
jne 0x62b9e
movq 0x78(%rsp), %rcx
movb $0x0, (%rcx,%rax)
movslq 0x8(%r13), %rdx
movq %rdx, 0x18(%rsp)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%r13)
movq 0x48(%rsp), %rdx
movslq %edx, %rax
movq %rax, 0x50(%rsp)
movb (%rcx,%r12), %bpl
xorl %eax, %eax
cmpb $0x40, %bpl
sete %al
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax), %r13
negl %eax
leaq (%rax,%rdx), %rcx
cmpl $0x47, %ecx
jl 0x61a07
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x6d, (%r13,%rax)
jne 0x61a1f
cmpb $0x5f, 0x7(%r13)
jne 0x61a1f
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x5f, 0xe(%r13,%rax)
jne 0x61a1f
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x2f, 0x3d(%rax,%r13)
jne 0x61a1f
xorl %ebp, %ebp
movb $0x1, %al
movl %eax, 0x60(%rsp)
pushq $0x3c
jmp 0x61bbd
addq %rdx, %rax
addq $-0x11, %rax
testl %eax, %eax
je 0x61b8c
cmpl $0x24, %ecx
jl 0x61bc9
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x2d, 0x8(%r13,%rax)
jne 0x61bc9
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x2d, 0xd(%rax,%r13)
jne 0x61bc9
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x2d, 0x12(%r13,%rax)
jne 0x61bc9
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x2d, 0x17(%rax,%r13)
jne 0x61bc9
movl %r14d, %r15d
xorl %r14d, %r14d
cmpb $0x3e, %bpl
sete %r14b
callq 0x4510
movq (%rax), %rax
movzbl (%r13,%r14), %ecx
movl %r15d, %r14d
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0x7(%rcx,%r13), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0x9(%rcx,%r13), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0xc(%r13,%rcx), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0xe(%r13,%rcx), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0x11(%rcx,%r13), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0x13(%rcx,%r13), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0x16(%r13,%rcx), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0x18(%r13,%rcx), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
xorl %ecx, %ecx
cmpb $0x3e, %bpl
sete %cl
movzbl 0x23(%rcx,%r13), %ecx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x61bc9
movl $0x0, 0x60(%rsp)
pushq $0x24
popq %rax
movl %eax, %ebp
pushq $0x24
jmp 0x61bbd
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x3a, 0x5(%rax,%r13)
jne 0x61bc9
xorl %eax, %eax
cmpb $0x3e, %bpl
sete %al
cmpb $0x3a, 0xb(%rax,%r13)
jne 0x61bc9
movl $0x0, 0x60(%rsp)
pushq $0x6
popq %rax
movl %eax, %ebp
pushq $0x6
popq %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rbx
jmp 0x61c44
movslq %ebx, %rax
subq %r12, %rax
xorl %ebp, %ebp
cmpq %rbp, %rax
je 0x61be6
movq 0x10(%rsp), %rcx
cmpb $0x21, (%rcx,%rbp)
jl 0x61beb
incq %rbp
jmp 0x61bd1
movq 0x50(%rsp), %rbp
addq 0xa0(%rsp), %r12
xorl %eax, %eax
movq %rbp, %rcx
movq (%rsp), %rbx
addq $-0x1, %rcx
jae 0x61c18
cmpl $0x3, %eax
ja 0x61c18
xorl %edx, %edx
cmpb $0x3a, (%r12,%rbp)
sete %dl
addl %edx, %eax
movq %rcx, %rbp
jmp 0x61bfc
cmpl $0x4, %eax
jne 0x61c32
incq %rbp
movslq %ebp, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x60(%rsp)
jmp 0x61c44
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
movb $0x1, %al
movl %eax, 0x60(%rsp)
movl %r14d, 0x5c(%rsp)
cmpq $0x0, 0x10(%rbx)
jne 0x61c68
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x4300
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x61e14
movq %rbp, 0x28(%rsp)
movq 0x18(%rsp), %rax
shll $0x8, %eax
movl %eax, 0x30(%rsp)
pushq $-0x1
popq %r14
movl %r14d, %ebx
movl %r14d, %esi
xorl %ecx, %ecx
cmpq 0x50(%rsp), %rcx
jae 0x61d31
movq (%rsp), %rax
movq 0x10(%rax), %r12
cmpq 0x50(%rsp), %rcx
je 0x61d24
movq 0x10(%rsp), %rax
movsbq (%rax,%rcx), %r13
cmpq $0xb, %r13
jl 0x61d29
incq %rcx
movq (%r12), %r12
testq %r12, %r12
je 0x61ccf
movl 0x14(%r12), %r15d
cmpb %r15b, %r13b
je 0x61cd7
addq $0x8, %r12
jmp 0x61cb6
movl 0x14, %r15d
movl %r15d, %ebx
shrl $0x8, %ebx
movl %esi, %ebp
movq %rcx, 0x20(%rsp)
callq 0x4510
movl %ebp, %esi
movq (%rax), %rax
cmpl 0x18(%rsp), %ebx
movl %ebx, %ecx
cmovel %r14d, %ecx
movzwl (%rax,%r13,2), %eax
testw $0x2004, %ax            # imm = 0x2004
cmovnel %ecx, %r14d
movq 0x20(%rsp), %rcx
cmpq 0x8(%rsp), %rcx
cmovel %ebx, %esi
movzbl %r15b, %eax
orl 0x30(%rsp), %eax
movl %eax, 0x14(%r12)
jmp 0x61c98
movq 0x50(%rsp), %rcx
incq %rcx
jmp 0x61c85
movq 0x18(%rsp), %rdx
cmpl %edx, %ebx
sete %al
cmpl $0x0, 0x48(%rsp)
sete %cl
orb %al, %cl
cmpl $-0x1, %esi
cmovnel %esi, %r14d
testb %cl, %cl
cmovel %ebx, %r14d
movl %edx, %r15d
subl $0x1, %r15d
movl $0x0, %eax
cmovbl %eax, %r15d
testl %r14d, %r14d
cmovnsl %r14d, %r15d
movq (%rsp), %r13
movq (%r13), %rbx
testb %cl, %cl
je 0x61d84
movl %r15d, 0x30(%rsp)
movq 0x28(%rsp), %rbp
jmp 0x61e2d
movslq %r15d, %rax
imulq $0x18, %rax, %r14
movq (%rbx,%r14), %rdi
callq 0x41d0
cmpq 0x50(%rsp), %rax
movq 0x28(%rsp), %rbp
jne 0x61e0d
movq 0x18(%rsp), %rbx
movl %ebx, %ecx
subl %r15d, %ecx
movq %r13, %rdi
xorl %esi, %esi
pushq $0x5
popq %rdx
callq 0x63b56
movq (%r13), %r15
imulq $0x18, %rbx, %r12
movq 0x10(%rsp), %rax
movq %rax, (%r15,%r12)
movslq 0x8(%r15,%r14), %rax
imulq $0xc, %rax, %rbx
testq %rax, %rax
movl %eax, 0x8(%r15,%r12)
movq %rbx, %rdi
movl $0x600, %eax            # imm = 0x600
cmoveq %rax, %rdi
callq 0x4680
movq %rax, 0x10(%r15,%r12)
testq %rax, %rax
je 0x62b9e
movq 0x10(%r15,%r14), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x43c0
jmp 0x625f0
movl %r15d, 0x30(%rsp)
jmp 0x61e2d
movq 0x18(%rsp), %rax
movl %eax, %ecx
subl $0x1, %ecx
movl $0x0, %eax
cmovbl %eax, %ecx
movl %ecx, 0x30(%rsp)
movq (%rbx), %rbx
movl $0x600, %edi            # imm = 0x600
callq 0x4680
imulq $0x18, 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rbx,%rcx)
testq %rax, %rax
movq (%rsp), %r13
je 0x62b9e
movq 0x18(%rsp), %rax
movl %eax, %ecx
movl 0x30(%rsp), %ebx
subl %ebx, %ecx
movq %r13, %rdi
xorl %esi, %esi
pushq $0x6
popq %rdx
callq 0x63b56
movslq %ebx, %rax
movq %rax, 0x28(%rsp)
cmpl $0x24, %ebp
jne 0x61f30
movl 0x14420(%r13), %eax
cmpl $0x25, %eax
movq 0x40(%rsp), %rbx
jg 0x61ede
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rdi
addq %rbx, %rdi
movl $0x280, %edx            # imm = 0x280
xorl %esi, %esi
callq 0x4260
movslq 0x14420(%r13), %rax
andl $0x0, 0x14020(%r13,%rax,4)
movslq 0x14420(%r13), %rax
andl $0x0, 0x14220(%r13,%rax,4)
movl 0x14420(%r13), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x14420(%r13)
cmpl $0x25, %ecx
jl 0x61e90
pushq $0x10
popq %r14
xorl %r15d, %r15d
cmpq $0x24, %r15
je 0x62015
movq 0x10(%rsp), %r12
movsbl (%r12,%r15), %edx
leaq 0x1(%r15), %rbx
movq %r13, %rdi
movl %ebx, %esi
callq 0x639bd
movsbl (%r12,%r15), %eax
movq (%r13), %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rcx
movl %eax, (%rcx,%r14)
movl $0x2, -0x4(%rcx,%r14)
addq $0xc, %r14
movq %rbx, %r15
jmp 0x61ee5
xorl %edx, %edx
pushq $0x1
popq %r15
cmpb $0x0, 0x60(%rsp)
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r14
jne 0x62021
movl 0x14420(%r13), %eax
cmpl $0x1, %eax
jg 0x61f9a
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rdi
addq %rcx, %rdi
movl $0x280, %edx            # imm = 0x280
xorl %esi, %esi
callq 0x4260
movslq 0x14420(%r13), %rax
andl $0x0, 0x14020(%r13,%rax,4)
movslq 0x14420(%r13), %rax
andl $0x0, 0x14220(%r13,%rax,4)
movl $0x2, 0x14420(%r13)
movl 0x30(%rsp), %eax
cmpl %eax, 0x18(%rsp)
jle 0x61fdf
movq (%r13), %rax
imulq $0x18, 0x28(%rsp), %rcx
cmpl $0x2, 0x8(%rax,%rcx)
jl 0x61fdf
addq %rcx, %rax
movq 0x10(%rax), %rcx
cmpl $0x1, 0xc(%rcx)
jne 0x61fdf
cmpl %ebp, 0x10(%rcx)
jne 0x61fdf
movq (%rax), %rsi
movslq %ebp, %rdx
movq 0x10(%rsp), %rdi
callq 0x44d0
testl %eax, %eax
je 0x6260b
movq %r13, %rdi
pushq $0x1
popq %rsi
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
callq 0x63a29
movq (%r13), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rax,%rcx), %rax
movl %ebp, 0x10(%rax)
andl $0x0, 0x14(%rax)
movl $0x1, 0xc(%rax)
movl %ebp, %edx
pushq $0x2
popq %r15
jmp 0x62021
pushq $0x24
popq %rdx
pushq $0x25
popq %r15
movq 0x48(%rsp), %r14
movl %r14d, %eax
movq %rax, 0x60(%rsp)
cmpl %r14d, %edx
jge 0x62531
movl %edx, 0x20(%rsp)
movslq 0x14420(%r13), %rax
cmpq %rax, %r15
jl 0x62095
cmpl $0x7f, %eax
jg 0x62b9e
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x280, %edx            # imm = 0x280
xorl %esi, %esi
callq 0x4260
movslq 0x14420(%r13), %rax
andl $0x0, 0x14020(%r13,%rax,4)
movslq 0x14420(%r13), %rax
andl $0x0, 0x14220(%r13,%rax,4)
leal 0x1(%r15), %eax
movl %eax, 0x14420(%r13)
movq 0x48(%rsp), %r14
callq 0x4510
movq (%rax), %rax
movl 0x20(%rsp), %r9d
movslq %r9d, %rcx
movq 0x10(%rsp), %rdx
leaq (%rdx,%rcx), %rbx
movzbl (%rdx,%rcx), %edx
movzwl (%rax,%rdx,2), %esi
btl $0xa, %esi
jb 0x62132
movl %r9d, %ecx
cmpb $0x30, %dl
jne 0x62209
cmpl %r14d, %r9d
movl %r14d, %r12d
cmoval %r9d, %r12d
movl 0x30(%rsp), %r10d
movq 0x60(%rsp), %r11
movq 0x10(%rsp), %rdx
addq %rcx, %rdx
xorl %esi, %esi
movl %ecx, %edi
xorl %ebx, %ebx
movq (%rsp), %r13
leaq (%rcx,%rsi), %r8
cmpq %r11, %r8
jae 0x622a0
cmpq $0x8, %rsi
ja 0x6229d
movzbl (%rdx,%rsi), %r8d
movzwl (%rax,%r8,2), %r9d
andl $0x800, %r9d            # imm = 0x800
je 0x6229d
movsbl %r8b, %r8d
imull $0xa, %ebx, %r9d
leal (%r9,%r8), %ebx
addl $-0x30, %ebx
incl %edi
incq %rsi
jmp 0x620ee
incq %rcx
movl %r9d, %ebp
movl %ebp, %r12d
cmpq 0x50(%rsp), %rcx
jge 0x62160
movq 0x10(%rsp), %rsi
movzbl (%rsi,%rcx), %esi
movzwl (%rax,%rsi,2), %esi
leal 0x1(%r12), %ebp
incq %rcx
testw $0x404, %si             # imm = 0x404
jne 0x62138
jmp 0x62163
movl %r14d, %ebp
subl %r9d, %ebp
cmpl $0x1, %ebp
je 0x62213
movl 0x30(%rsp), %eax
cmpl %eax, 0x18(%rsp)
jle 0x621c3
movq (%rsp), %rax
movq (%rax), %rax
imulq $0x18, 0x28(%rsp), %rcx
movslq 0x8(%rax,%rcx), %rdx
cmpq %rdx, %r15
jge 0x621c3
addq %rcx, %rax
movq 0x10(%rax), %rcx
imulq $0xc, %r15, %rdx
cmpl $0x1, (%rcx,%rdx)
jne 0x621c3
addq %rdx, %rcx
cmpl 0x4(%rcx), %ebp
jne 0x621c3
movslq 0x8(%rcx), %rsi
addq (%rax), %rsi
movslq %ebp, %rdx
movq %rbx, %rdi
callq 0x44d0
testl %eax, %eax
je 0x624a1
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x63a29
testl %eax, %eax
js 0x62b9e
movq (%r13), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rax,%rcx), %rax
imulq $0xc, %r15, %rcx
movl %ebp, 0x4(%rax,%rcx)
movl 0x20(%rsp), %edx
movl %edx, 0x8(%rax,%rcx)
movl $0x1, (%rax,%rcx)
jmp 0x62440
btl $0xb, %esi
jb 0x62359
movsbl %dl, %edx
movl 0x30(%rsp), %eax
cmpl %eax, 0x18(%rsp)
movq (%rsp), %r13
jle 0x6225e
movq (%r13), %rax
imulq $0x18, 0x28(%rsp), %rcx
movslq 0x8(%rax,%rcx), %rsi
cmpq %rsi, %r15
jge 0x6225e
addq %rcx, %rax
movq 0x10(%rax), %rax
imulq $0xc, %r15, %rcx
cmpl $0x2, (%rax,%rcx)
jne 0x6225e
addq %rcx, %rax
cmpl %edx, 0x4(%rax)
jne 0x6225e
movq %r13, %rdi
movl %r15d, %esi
callq 0x63a21
jmp 0x62269
movq %r13, %rdi
movl %r15d, %esi
callq 0x639bd
testl %eax, %eax
js 0x62b9e
movsbl (%rbx), %eax
movq (%r13), %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rcx
imulq $0xc, %r15, %rdx
movl %eax, 0x4(%rcx,%rdx)
movl $0x2, (%rcx,%rdx)
movl 0x20(%rsp), %eax
movl %eax, %r12d
jmp 0x62440
movl %edi, %r12d
cmpl %r10d, 0x18(%rsp)
movl 0x20(%rsp), %edi
jle 0x622fe
movq (%r13), %rax
imulq $0x18, 0x28(%rsp), %rcx
movslq 0x8(%rax,%rcx), %rdx
cmpq %rdx, %r15
jge 0x622fe
addq %rcx, %rax
movq 0x10(%rax), %rax
imulq $0xc, %r15, %rdx
cmpl $0x3, (%rax,%rdx)
jne 0x622fe
leaq (%rax,%rdx), %rsi
movl %ebx, %ecx
subl 0x4(%rsi), %ecx
jne 0x62453
movl %r12d, %ebp
subl %edi, %ebp
cmpl %ebp, 0x8(%rsi)
jne 0x62453
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
callq 0x63a21
jmp 0x62328
movl %r12d, %ebp
subl %edi, %ebp
movq %r13, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x63b0b
testl %eax, %eax
js 0x62b9e
movq %r13, %rdi
movl %r15d, %esi
pushq $0x3
popq %rdx
movl %ebx, %ecx
callq 0x63b56
testl %eax, %eax
js 0x62b9e
movq (%r13), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rax,%rcx), %rax
imulq $0xc, %r15, %rcx
movl %ebp, 0x8(%rax,%rcx)
movl %ebx, 0x4(%rax,%rcx)
movl $0x3, (%rax,%rcx)
decl %r12d
jmp 0x62440
cmpl %r14d, %r9d
movl %r14d, %r12d
cmoval %r9d, %r12d
movq 0x10(%rsp), %rdx
addq %rcx, %rdx
xorl %esi, %esi
movl %r9d, %ebp
xorl %ebx, %ebx
movl 0x30(%rsp), %r10d
movq 0x60(%rsp), %r11
leaq (%rcx,%rsi), %rdi
cmpq %r11, %rdi
jae 0x623b3
cmpq $0x8, %rsi
ja 0x623b6
movzbl (%rdx,%rsi), %edi
movzwl (%rax,%rdi,2), %r8d
andl $0x800, %r8d            # imm = 0x800
je 0x623b6
movsbl %dil, %edi
imull $0xa, %ebx, %r8d
leal (%r8,%rdi), %ebx
addl $-0x30, %ebx
incl %ebp
incq %rsi
jmp 0x6237c
movl %r12d, %ebp
cmpl %r10d, 0x18(%rsp)
jle 0x62402
movq (%rsp), %rdx
movq (%rdx), %rdx
imulq $0x18, 0x28(%rsp), %rsi
movslq 0x8(%rdx,%rsi), %rdi
cmpq %rdi, %r15
jge 0x62402
addq %rsi, %rdx
movq 0x10(%rdx), %rsi
imulq $0xc, %r15, %rdi
leaq (%rsi,%rdi), %rdx
movl (%rsi,%rdi), %esi
cmpl $0x7, %esi
je 0x62486
cmpl $0x3, %esi
jne 0x62402
movl %ebp, %esi
subl %r9d, %esi
cmpl %esi, 0x8(%rdx)
je 0x620dc
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
pushq $0x7
popq %rdx
movl %ebx, %ecx
callq 0x63b56
testl %eax, %eax
js 0x62b9e
movq (%r13), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rax,%rcx), %rax
imulq $0xc, %r15, %rcx
movl %ebx, 0x4(%rax,%rcx)
movl $0x7, (%rax,%rcx)
decl %ebp
movl %ebp, %r12d
incq %r15
incl %r12d
movl %r12d, %edx
movq 0x48(%rsp), %r14
jmp 0x62029
movl %r12d, %ebp
subl %edi, %ebp
cmpl $0x100, %ecx            # imm = 0x100
jae 0x6247d
cmpl %ebp, 0x8(%rax,%rdx)
jne 0x6247d
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
pushq $0x9
popq %rdx
callq 0x63aa9
jmp 0x62328
movq (%rsp), %r13
jmp 0x62303
movl %ebx, %ecx
subl 0x4(%rdx), %ecx
jne 0x624b5
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
callq 0x63a21
jmp 0x62416
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
callq 0x63a21
jmp 0x621d7
cmpl $0xff, %ecx
ja 0x624fe
movq 0x90(%rsp), %rax
movl (%rax,%r15,4), %eax
addl $0x5, %eax
movq 0x98(%rsp), %rdx
cmpl (%rdx,%r15,4), %eax
jle 0x624fe
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
pushq $0x8
popq %rdx
callq 0x63aa9
testl %eax, %eax
js 0x62b9e
movq 0x90(%rsp), %rax
jmp 0x62522
movq (%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
pushq $0x7
popq %rdx
movl %ebx, %ecx
callq 0x63b56
testl %eax, %eax
js 0x62b9e
movq 0x98(%rsp), %rax
leaq (%rax,%r15,4), %rax
incl (%rax)
movq (%rsp), %r13
jmp 0x6241e
movl 0x14420(%r13), %eax
cmpl %r15d, %eax
jg 0x6258b
cmpl $0x7f, %eax
jg 0x62b9e
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rdi
addq 0x40(%rsp), %rdi
movl $0x280, %edx            # imm = 0x280
xorl %esi, %esi
callq 0x4260
movslq 0x14420(%r13), %rax
andl $0x0, 0x14020(%r13,%rax,4)
movslq 0x14420(%r13), %rax
andl $0x0, 0x14220(%r13,%rax,4)
leal 0x1(%r15), %eax
movl %eax, 0x14420(%r13)
movq %r13, %rdi
movl %r15d, %esi
pushq $0xc
popq %rdx
callq 0x63bb5
testl %eax, %eax
js 0x62b9e
movq (%r13), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rbx
movq %rcx, (%rax,%rbx)
movl %r15d, 0x8(%rax,%rbx)
movq 0x10(%rax,%rbx), %rdi
incl %r15d
imulq $0xc, %r15, %rsi
callq 0x4840
movq (%r13), %rcx
addq %rbx, %rcx
addq $0x10, %rcx
testq %rax, %rax
je 0x625e2
movq %rax, (%rcx)
movq (%rsp), %r13
jmp 0x625f0
cmpq $0x0, (%rcx)
movq (%rsp), %r13
je 0x62b9e
movq 0x70(%rsp), %rax
movq 0x48(%rsp), %rcx
addl %ecx, %eax
incl %eax
pushq $0x9
popq %rbp
movl 0x5c(%rsp), %r14d
jmp 0x618f7
movq %r13, %rdi
pushq $0x1
popq %rsi
callq 0x63a21
jmp 0x61ff1
xorl %ebx, %ebx
pushq $0x58
popq %r14
movq %r13, %r15
movslq 0x14420(%r13), %rcx
movq %rcx, %rax
shlq $0x4, %rax
cmpq %rax, %rbx
jge 0x626af
imulq $0x28, %rbx, %r12
movq 0x40(%rsp), %rax
movq 0x10(%rax,%r12), %rax
testq %rax, %rax
je 0x6269f
addq 0x40(%rsp), %r12
leaq -0x1(%rax), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x62671
movq (%r12), %rdi
leaq 0x1(%rdx), %rsi
cmpb $0xa, 0x1(%rdi,%rdx)
movq %rsi, %rdx
je 0x62655
cmpq %rsi, %rax
jne 0x6269f
movq %r14, %rax
leaq 0x28(%rax), %rcx
cmpq $0x2d8, %rcx            # imm = 0x2D8
je 0x6269f
cmpq $0x0, (%r15,%rax)
movq %rcx, %rax
je 0x62674
andq $0x0, 0x10(%r12)
movq (%r12), %rdi
callq 0x45c0
andq $0x0, (%r12)
addq $0x10, %rbx
addq $0x280, %r15            # imm = 0x280
jmp 0x62624
movl 0x80(%rsp), %eax
decl %eax
pushq $0x2
popq %rsi
cltd
idivl %esi
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %eax
cmpl $0x4, %eax
pushq $0x4
popq %rdx
cmovll %eax, %edx
imulq $0x16c, %rdx, %rax      # imm = 0x16C
addq %rsp, %rax
addq $0xc0, %rax
movq %rax, 0x98(%rsp)
leaq 0x30(%r13), %rax
movq %rax, 0x90(%rsp)
movq 0x40(%rsp), %r15
shll $0x4, %ecx
movslq %ecx, %rax
cmpq %rax, %r12
jge 0x62aaf
imulq $0x28, %r12, %rax
movq 0x10(%r15,%rax), %rdi
testq %rdi, %rdi
je 0x62a75
movq %rax, %rbx
movq %rbp, 0x28(%rsp)
pushq $0x1
popq %rsi
callq 0x493f4
movl %eax, %eax
cvtsi2sd %rax, %xmm0
mulsd 0x19117(%rip), %xmm0    # 0x7b850
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x14f73(%rip), %xmm0    # 0x776c0
cvttsd2si %xmm0, %rbp
andq %rcx, %rbp
orq %rax, %rbp
movq %rbp, %rdi
callq 0x4680
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x62a8e
addq %r15, %rbx
movq (%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rsp)
movl $0x71c, %edx            # imm = 0x71C
leaq 0xc0(%rsp), %rdi
leaq 0x1fa6a(%rip), %rsi     # 0x82200
callq 0x43c0
cmpl $0x0, 0x6c(%rsp)
je 0x627ad
movl $0xc9, 0x2f4(%rsp)
movq %rbx, 0x80(%rsp)
movl %r12d, %eax
andl $0xf, %eax
imulq $0x1c, %rax, %rsi
movq 0x98(%rsp), %rcx
addq %rcx, %rsi
movl %r12d, %eax
shrl $0x4, %eax
movl %eax, 0x60(%rsp)
movl %r12d, %eax
andl $0xf, %eax
movl %eax, 0x5c(%rsp)
movq %r12, 0x70(%rsp)
movl %r12d, %eax
andl $0xf, %eax
imulq $0x1c, %rax, %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
leal -0x6(%rbp), %eax
movl %eax, 0x48(%rsp)
movq 0x20(%rsp), %rax
leaq 0x6(%rax), %rdx
addq %rbp, %rax
movq %rax, 0x78(%rsp)
xorl %eax, %eax
pushq $0x1
popq %r12
pushq $-0x1
popq %r15
leaq 0x7e0(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rbx
movq %rdx, 0x88(%rsp)
movq %rsi, 0x50(%rsp)
movq %rbp, 0xa0(%rsp)
movq 0x10(%rsp), %rcx
movslq (%rcx), %r13
cmpq %r13, %r12
jg 0x62985
cmpl $0x0, 0x6c(%rsp)
jne 0x62866
movl (%rsi,%r12,4), %ecx
testb $0x4, %cl
je 0x62866
andl $-0x5, %ecx
movl %ecx, (%rsi,%r12,4)
movl (%rsi,%r12,4), %r8d
testb $0x3, %bl
je 0x6287f
movl %r8d, %ecx
andl $0x8, %ecx
je 0x6287f
movq %r15, %r14
jmp 0x6297a
cmpl $0x0, 0x6c(%rsp)
je 0x628a4
movl 0x48(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x30(%rsp), %rdi
movl %ebx, %esi
leaq 0x3c(%rsp), %rcx
movq %rdx, %rbp
callq 0x4947c
jmp 0x628c0
movl 0x48(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x30(%rsp), %rdi
movl %ebx, %esi
leaq 0x3c(%rsp), %rcx
movq %rdx, %rbp
callq 0x4fcbf
testq %rax, %rax
je 0x629b4
movl 0x3c(%rsp), %edx
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq 0x78(%rsp), %rsi
callq 0x63c57
movl %eax, %r14d
movl %eax, %edi
addq %rbx, %rdi
movl 0x3c(%rsp), %ebx
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x4830
addl %ebx, %r14d
movl %r14d, %r14d
xorl %eax, %eax
cmpq %r14, %r15
movq 0x50(%rsp), %rsi
jbe 0x6296a
cmpq %r13, %r12
movq 0x18(%rsp), %rbx
jge 0x62a84
cmpl $0x2001, %r14d          # imm = 0x2001
setae %al
leaq 0x7e0(%rsp), %rcx
movq 0x8(%rsp), %rdi
cmpq %rcx, %rdi
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x6294e
movq %r14, %rdi
callq 0x4680
movq %rax, %rdi
testq %rax, %rax
je 0x62a97
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x43c0
pushq $0x1
popq %rax
movq 0x50(%rsp), %rsi
jmp 0x62972
movq %r15, %r14
movq 0x18(%rsp), %rbx
movq 0x88(%rsp), %rdx
incq %r12
movq %r14, %r15
jmp 0x6283e
testl %eax, %eax
jne 0x6299b
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x43c0
xorl %ebx, %ebx
movq %r15, %rbp
movq 0x40(%rsp), %r15
movq 0x70(%rsp), %r12
movq 0x80(%rsp), %r13
jmp 0x629d0
movb $0x1, %bl
movq 0x40(%rsp), %r15
movq 0x70(%rsp), %r12
movq 0x80(%rsp), %r13
movq 0xa0(%rsp), %rbp
leaq 0x7e0(%rsp), %rax
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x629e7
callq 0x45c0
testb %bl, %bl
jne 0x62a97
movq (%r13), %rdi
callq 0x45c0
movq 0x20(%rsp), %rax
movq %rax, (%r13)
movq %rbp, 0x10(%r13)
movl 0x60(%rsp), %eax
movl %eax, 0x18(%r13)
movl 0x5c(%rsp), %eax
movl %eax, 0x1c(%r13)
movq 0x90(%rsp), %r14
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x62a52
movq -0x10(%r14), %rsi
testq %rsi, %rsi
je 0x62a49
cmpq $0x5, %rbp
jb 0x62a49
cmpq (%r14), %rbp
jne 0x62a49
movq 0x20(%rsp), %rdi
movq %rbp, %rdx
callq 0x44d0
testl %eax, %eax
je 0x62a65
incq %rbx
addq $0x28, %r14
jmp 0x62a1f
orl $-0x1, 0x20(%r13)
movq 0x28(%rsp), %rax
addl %ebp, %eax
incl %eax
movq %rax, %rbp
jmp 0x62a71
movl %ebx, 0x20(%r13)
movq 0x28(%rsp), %rbp
addl $0x3, %ebp
movq (%rsp), %r13
incq %r12
movl 0x14420(%r13), %ecx
jmp 0x626f9
xorl %ebx, %ebx
movq %r14, %rbp
jmp 0x629a0
movq (%rsp), %rdi
jmp 0x62ba1
movq (%rsp), %rdi
callq 0x62c80
movq 0x20(%rsp), %rdi
callq 0x45c0
jmp 0x62ba6
leal 0xd(%rbp), %edi
callq 0x4680
testq %rax, %rax
je 0x62b9e
movq %rax, %rdx
movq 0xb8(%rsp), %rax
movl %ebp, (%rax)
movq 0xa8(%rsp), %rcx
movb %cl, (%rdx)
movb %ch, 0x1(%rdx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rdx)
shrl $0x18, %ecx
movb %cl, 0x3(%rdx)
movl 0xb4(%rsp), %ecx
movb %cl, 0x4(%rdx)
movb %ch, 0x5(%rdx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x6(%rdx)
shrl $0x18, %ecx
movb %cl, 0x7(%rdx)
movq %rdx, %rbx
addq $0x9, %rbx
movl 0x6c(%rsp), %eax
movq %rdx, %r12
movb %al, 0x8(%rdx)
movq %r13, %r14
addq $0x40, %r14
pushq $-0x1
popq %rax
xorl %r15d, %r15d
movslq 0x14420(%r13), %rcx
shlq $0x4, %rcx
cmpq %rcx, %r15
jge 0x62bba
cmpq $0x0, -0x10(%r14)
je 0x62b72
movl -0x8(%r14), %ebp
movl -0x4(%r14), %ecx
movl %ecx, %edx
orb $-0x80, %dl
cmpl %eax, %ebp
movzbl %dl, %eax
cmovel %ecx, %eax
cmpl $0x0, (%r14)
js 0x62b76
orb $0x40, %al
movb %al, (%rbx)
movl (%r14), %eax
shrl $0x4, %eax
movb %al, 0x1(%rbx)
movb (%r14), %al
andb $0xf, %al
movb %al, 0x2(%rbx)
addq $0x3, %rbx
jmp 0x62b8f
movl %eax, %ebp
jmp 0x62b8f
movb %al, (%rbx)
incq %rbx
movq -0x20(%r14), %rsi
movq -0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x43c0
addq -0x10(%r14), %rbx
incq %r15
addq $0x28, %r14
movl %ebp, %eax
movq (%rsp), %r13
jmp 0x62b21
movq %r13, %rdi
callq 0x62c80
xorl %eax, %eax
addq $0x27e8, %rsp           # imm = 0x27E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x62c80
movq %r12, %rax
jmp 0x62ba8