// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/htscodecs/htscodecs/tokenise_name3.c
// Function: tok3_decode_names
uint8_t *tok3_decode_names(uint8_t *in, uint32_t sz, uint32_t *out_len) {
    if (sz < 9)
        return NULL;

    int i, o = 9;
    //int ulen   = *(uint32_t *)in;
    int ulen   = (in[0]<<0) | (in[1]<<8) | (in[2]<<16) |
        (((uint32_t)in[3])<<24);

    if (ulen < 0 || ulen >= INT_MAX-1024)
        return NULL;

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    // Speed up fuzzing by blocking excessive sizes
    if (ulen > 100000)
        return NULL;
#endif

    //int nreads = *(uint32_t *)(in+4);
    int nreads = (in[4]<<0) | (in[5]<<8) | (in[6]<<16) | (((uint32_t)in[7])<<24);
    int use_arith = in[8];
    name_context *ctx = create_context(nreads);
    if (!ctx)
        return NULL;

    // Unpack descriptors
    int tnum = -1;
    while (o < sz) {
        uint8_t ttype = in[o++];
        if (ttype & 64) {
            if (o+2 > sz) goto err;
            int j = in[o++]<<4;
            j += in[o++];
            if (ttype & 128) {
                tnum++;
                if (tnum >= MAX_TOKENS)
                    goto err;
                ctx->max_tok = tnum+1;
                memset(&ctx->desc[tnum<<4], 0, 16*sizeof(ctx->desc[tnum]));
            }

            if ((ttype & 15) != 0 && (ttype & 128)) {
                if (tnum < 0) goto err;
                ctx->desc[tnum<<4].buf = malloc(nreads);
                if (!ctx->desc[tnum<<4].buf)
                    goto err;

                ctx->desc[tnum<<4].buf_l = 0;
                ctx->desc[tnum<<4].buf_a = nreads;
                ctx->desc[tnum<<4].buf[0] = ttype&15;
                memset(&ctx->desc[tnum<<4].buf[1], N_MATCH, nreads-1);
            }

            if (tnum < 0) goto err;
            i = (tnum<<4) | (ttype&15);
            if (j >= i)
                goto err;
            if (!ctx->desc[j].buf)
                goto err; // Attempt to copy a non-existent stream

            ctx->desc[i].buf_l = 0;
            ctx->desc[i].buf_a = ctx->desc[j].buf_a;
            if (ctx->desc[i].buf) free(ctx->desc[i].buf);
            ctx->desc[i].buf = malloc(ctx->desc[i].buf_a);
            if (!ctx->desc[i].buf)
                goto err;

            memcpy(ctx->desc[i].buf, ctx->desc[j].buf, ctx->desc[i].buf_a);
            //fprintf(stderr, "Copy ttype %d, i=%d,j=%d, size %d\n", ttype, i, j, (int)ctx->desc[i].buf_a);
            continue;
        }

        //if (ttype == 0)
        if (ttype & 128) {
            tnum++;
            if (tnum >= MAX_TOKENS)
                goto err;
            ctx->max_tok = tnum+1;
            memset(&ctx->desc[tnum<<4], 0, 16*sizeof(ctx->desc[tnum]));
        }

        if ((ttype & 15) != 0 && (ttype & 128)) {
            if (tnum < 0) goto err;
            if (ctx->desc[tnum<<4].buf) free(ctx->desc[tnum<<4].buf);
            ctx->desc[tnum<<4].buf = malloc(nreads);
            if (!ctx->desc[tnum<<4].buf)
                goto err;
            ctx->desc[tnum<<4].buf_l = 0;
            ctx->desc[tnum<<4].buf_a = nreads;
            ctx->desc[tnum<<4].buf[0] = ttype&15;
            memset(&ctx->desc[tnum<<4].buf[1], N_MATCH, nreads-1);
        }

        //fprintf(stderr, "Read %02x\n", c);

        // Load compressed block
        int64_t clen, ulen = uncompressed_size(&in[o], sz-o);
        if (ulen < 0 || ulen >= INT_MAX)
            goto err;
        if (tnum < 0) goto err;
        i = (tnum<<4) | (ttype&15);

        if (i >= MAX_TBLOCKS || i < 0)
            goto err;

        ctx->desc[i].buf_l = 0;
        if (ctx->desc[i].buf) free(ctx->desc[i].buf);
        ctx->desc[i].buf = malloc(ulen);
        if (!ctx->desc[i].buf)
            goto err;

        ctx->desc[i].buf_a = ulen;
        uint64_t usz = ctx->desc[i].buf_a; // convert from size_t for 32-bit sys
        clen = uncompress(use_arith, &in[o], sz-o, ctx->desc[i].buf, &usz);
        ctx->desc[i].buf_a = usz;
        if (clen < 0 || ctx->desc[i].buf_a != ulen)
            goto err;

        // fprintf(stderr, "%d: Decode tnum %d type %d clen %d ulen %d via %d\n",
        //      o, tnum, ttype, (int)clen, (int)ctx->desc[i].buf_a, ctx->desc[i].buf[0]);

        o += clen;

        // Encode tnum 0 type 0 ulen 100000 clen 12530 via 2
        // Encode tnum 0 type 6 ulen 196800 clen 43928 via 3
        // Encode tnum 0 type 7 ulen 203200 clen 17531 via 3
        // Encode tnum 1 type 0 ulen 50800 clen 10 via 1
        // Encode tnum 1 type 1 ulen 3 clen 5 via 0
        // Encode tnum 2 type 0 ulen 50800 clen 10 via 1
        //      
    }

    int ret;
    ulen += 1024; // for easy coding in decode_name.
    uint8_t *out = malloc(ulen);
    if (!out)
        goto err;

    size_t out_sz = 0;
    while ((ret = decode_name(ctx, (char *)out+out_sz, ulen)) > 0) {
        out_sz += ret;
        ulen -= ret;
    }

    if (ret < 0)
        free(out);

    free_context(ctx);

    *out_len = out_sz;
    return ret == 0 ? out : NULL;

 err:
    free_context(ctx);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpl $0x9, %esi
jb 0x63979
movq %rdi, %r13
movzbl 0x3(%rdi), %eax
xorl %r12d, %r12d
shll $0x18, %eax
js 0x6397c
movzwl (%r13), %ecx
movzbl 0x2(%r13), %r15d
shll $0x10, %r15d
orl %ecx, %r15d
orl %eax, %r15d
cmpl $0x7ffffbfe, %r15d      # imm = 0x7FFFFBFE
jg 0x6397c
movq %rdx, %r14
movl %esi, %ebp
movl 0x4(%r13), %ebx
movb 0x8(%r13), %al
movb %al, 0x37(%rsp)
movl %ebx, %edi
callq 0x62bc7
xorl %r12d, %r12d
testq %rax, %rax
je 0x6397c
movq %r13, 0x18(%rsp)
movl %ebp, 0x40(%rsp)
movq %r15, 0x28(%rsp)
movq %r14, 0x68(%rsp)
movq %rax, 0x20(%rsp)
addq $0x20, %rax
movq %rax, 0x38(%rsp)
movslq %ebx, %rax
movq %rax, 0x58(%rsp)
decl %ebx
movslq %ebx, %rax
movq %rax, 0x60(%rsp)
pushq $0x9
popq %r14
pushq $-0x1
popq %rsi
movl 0x40(%rsp), %ecx
cmpl %ecx, %r14d
jae 0x631bb
movslq %r14d, %rax
leaq 0x1(%rax), %r12
movq 0x18(%rsp), %rdx
movzbl (%rdx,%rax), %ebp
testb $0x40, %bpl
jne 0x62e12
testb %bpl, %bpl
js 0x62e52
movq %rsi, 0x10(%rsp)
andl $0xf, %ebp
jmp 0x63036
addl $0x3, %r14d
cmpl %ecx, %r14d
ja 0x6396f
movq 0x18(%rsp), %rcx
movzbl (%rcx,%r12), %ebx
movzbl 0x2(%rcx,%rax), %r12d
testb %bpl, %bpl
js 0x62efb
andl $0xf, %ebp
testl %esi, %esi
js 0x6396f
movl %esi, %r13d
shll $0x4, %r13d
movl %esi, %r15d
jmp 0x62fa1
cmpl $0x7e, %esi
jg 0x6396f
leal 0x1(%rsi), %ebx
leal 0x2(%rsi), %eax
movq 0x20(%rsp), %rcx
movl %eax, 0x14420(%rcx)
movl %ebx, %r14d
shll $0x4, %r14d
movslq %r14d, %rax
imulq $0x28, %rax, %rdi
addq 0x38(%rsp), %rdi
movl $0x280, %edx            # imm = 0x280
movq %rsi, %r15
xorl %esi, %esi
callq 0x4260
andl $0xf, %ebp
je 0x63024
cmpl $-0x1, %r15d
jl 0x6396f
movl %r14d, %eax
imulq $0x28, %rax, %r14
movq 0x38(%rsp), %r15
movq (%r15,%r14), %rdi
callq 0x45c0
movq 0x58(%rsp), %rdi
callq 0x4680
movq %rax, (%r15,%r14)
testq %rax, %rax
je 0x6396f
addq 0x38(%rsp), %r14
andq $0x0, 0x10(%r14)
movq 0x58(%rsp), %rcx
movq %rcx, 0x8(%r14)
movb %bpl, (%rax)
movq (%r14), %rdi
incq %rdi
pushq $0xa
popq %rsi
movq 0x60(%rsp), %rdx
callq 0x4260
jmp 0x63026
cmpl $0x7e, %esi
jg 0x6396f
movl %r12d, 0x10(%rsp)
leal 0x1(%rsi), %r15d
leal 0x2(%rsi), %eax
movq 0x20(%rsp), %rcx
movl %eax, 0x14420(%rcx)
movl %r15d, %r13d
shll $0x4, %r13d
movslq %r13d, %rax
imulq $0x28, %rax, %rdi
addq 0x38(%rsp), %rdi
movl $0x280, %edx            # imm = 0x280
movq %rsi, %r12
xorl %esi, %esi
callq 0x4260
andl $0xf, %ebp
je 0x631ac
cmpl $-0x1, %r12d
movl 0x10(%rsp), %r12d
jl 0x6396f
movq 0x58(%rsp), %rdi
callq 0x4680
movl %r13d, %ecx
imulq $0x28, %rcx, %rcx
movq 0x38(%rsp), %rdx
movq %rax, (%rdx,%rcx)
testq %rax, %rax
je 0x6396f
addq 0x38(%rsp), %rcx
andq $0x0, 0x10(%rcx)
movq 0x58(%rsp), %rdx
movq %rdx, 0x8(%rcx)
movb %bpl, (%rax)
movq (%rcx), %rdi
incq %rdi
pushq $0xa
popq %rsi
movq 0x60(%rsp), %rdx
callq 0x4260
addl %ebp, %r13d
shll $0x4, %ebx
addl %r12d, %ebx
cmpl %r13d, %ebx
jge 0x6396f
movl %ebx, %eax
imulq $0x28, %rax, %r12
movq 0x38(%rsp), %rax
cmpq $0x0, (%rax,%r12)
je 0x6396f
movl %r13d, %eax
imulq $0x28, %rax, %r13
movq 0x38(%rsp), %rbp
andq $0x0, 0x10(%rbp,%r13)
addq %rbp, %r12
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbp,%r13)
movq (%rbp,%r13), %rdi
callq 0x45c0
movq 0x8(%rbp,%r13), %rbx
movq %rbx, %rdi
callq 0x4680
movq %rax, (%rbp,%r13)
testq %rax, %rax
je 0x6396f
movq (%r12), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x43c0
movl %r15d, %esi
jmp 0x62ddd
xorl %ebp, %ebp
movl %ebx, %eax
movq %rax, 0x10(%rsp)
movl 0x40(%rsp), %ecx
movq 0x18(%rsp), %rdx
movq %r12, 0x50(%rsp)
movslq %r12d, %rax
leaq (%rdx,%rax), %r14
movl %ecx, %r12d
subl %eax, %r12d
leaq (%r12,%r14), %rbx
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xc(%rsp), %rdx
callq 0x63d79
cltq
leaq (%rax,%r14), %rdi
incq %rdi
movq %rbx, 0x48(%rsp)
movq %rbx, %rsi
leaq 0x30(%rsp), %rdx
callq 0x63d79
movl 0x30(%rsp), %r15d
cmpq $0x7ffffffe, %r15       # imm = 0x7FFFFFFE
movq 0x10(%rsp), %rax
ja 0x6396f
testl %eax, %eax
js 0x6396f
shll $0x4, %eax
js 0x6396f
orl %ebp, %eax
cmpl $0x7ff, %eax            # imm = 0x7FF
jg 0x6396f
movl %eax, %eax
imulq $0x28, %rax, %r13
movq 0x38(%rsp), %rbx
andq $0x0, 0x10(%rbx,%r13)
movq (%rbx,%r13), %rdi
callq 0x45c0
movq %r15, %rdi
callq 0x4680
movq %rax, (%rbx,%r13)
testq %rax, %rax
je 0x6396f
movq %rax, %rbp
movq %r15, %rbx
addq 0x38(%rsp), %r13
movq %r15, 0x8(%r13)
movq %r14, %rdi
movq 0x48(%rsp), %r15
movq %r15, %rsi
leaq 0x74(%rsp), %rdx
callq 0x63d79
cmpb $0x0, 0x37(%rsp)
je 0x63138
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq 0x30(%rsp), %rdx
callq 0x63d79
movslq %eax, %r15
addq %r15, %r14
subl %r15d, %r12d
movq %r14, %rdi
movl %r12d, %esi
movq %rbp, %rdx
leaq 0xc(%rsp), %rcx
callq 0x4a3c1
jmp 0x63168
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq 0x30(%rsp), %rdx
callq 0x63d79
movslq %eax, %r15
addq %r15, %r14
subl %r15d, %r12d
movq %r14, %rdi
movl %r12d, %esi
movq %rbp, %rdx
leaq 0xc(%rsp), %rcx
callq 0x50993
addl 0x30(%rsp), %r15d
testq %rax, %rax
movl 0xc(%rsp), %ecx
cmoveq %rbx, %rcx
cmpq $0x1, %rax
movl $0x0, %r14d
sbbl %r14d, %r14d
orl %r15d, %r14d
movq %rcx, 0x8(%r13)
testl %r14d, %r14d
movq 0x10(%rsp), %rsi
js 0x6396f
addl 0x50(%rsp), %r14d
cmpl %ebx, %ecx
je 0x62ddd
jmp 0x6396f
xorl %ebp, %ebp
movl %r15d, %esi
movl 0x10(%rsp), %r12d
jmp 0x62e3b
movq 0x28(%rsp), %rdi
addl $0x400, %edi            # imm = 0x400
movq %rdi, %rbx
callq 0x4680
testq %rax, %rax
je 0x6396f
movq %rax, %r12
pushq $-0x1
popq %rdx
movq $0x0, 0x40(%rsp)
movq 0x20(%rsp), %rdi
movq %rbx, 0x28(%rsp)
movq 0x30(%rdi), %rcx
movl %edx, %eax
cmpq 0x28(%rdi), %rcx
jae 0x6320c
movq 0x20(%rdi), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x30(%rdi)
movzbl (%rax,%rcx), %eax
movslq 0x8(%rdi), %r14
leal 0x1(%r14), %ecx
movl %ecx, 0x8(%rdi)
cmpl 0x14424(%rdi), %r14d
jge 0x63995
testl %eax, %eax
js 0x639a5
movl 0x14420(%rdi), %ecx
shll $0x4, %ecx
cmpl %ecx, %eax
jge 0x639a5
movl %eax, %ecx
imulq $0x28, %rcx, %rcx
movq 0x38(%rsp), %r8
movq 0x10(%r8,%rcx), %rdx
leaq 0x4(%rdx), %rsi
cmpq 0x8(%r8,%rcx), %rsi
ja 0x63995
addq 0x38(%rsp), %rcx
movq (%rcx), %r8
movl (%r8,%rdx), %edx
movq %rsi, 0x10(%rcx)
cmpl %edx, %r14d
jb 0x63995
movq 0x40(%rsp), %rcx
leaq (%r12,%rcx), %rsi
movl %r14d, %ecx
subl %edx, %ecx
testl %ecx, %ecx
movl $0x0, %edx
cmovlel %edx, %ecx
movl %ecx, %edx
movq %rdx, 0x48(%rsp)
cmpl $0x5, %eax
movq %rsi, 0x10(%rsp)
jne 0x63346
cmpl %r14d, %ecx
je 0x63995
movq (%rdi), %rax
imulq $0x18, 0x48(%rsp), %r15
movq (%rax,%r15), %rbx
movq %rbx, %rdi
callq 0x41d0
incq %rax
movslq 0x28(%rsp), %rcx
cmpq %rcx, %rax
jae 0x63995
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x4460
movq 0x20(%rsp), %rax
movq (%rax), %r13
imulq $0x18, %r14, %r14
movq %rbp, (%r13,%r14)
movslq 0x8(%r13,%r15), %rax
imulq $0xc, %rax, %rbx
testq %rax, %rax
movl %eax, 0x8(%r13,%r14)
movq %rbx, %rdi
movl $0x600, %eax            # imm = 0x600
cmoveq %rax, %rdi
callq 0x4680
movq %rax, 0x10(%r13,%r14)
testq %rax, %rax
je 0x63995
movq 0x10(%r13,%r15), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x43c0
movq 0x10(%rsp), %rdi
callq 0x41d0
incl %eax
pushq $-0x1
popq %rdx
jmp 0x63945
movb $0x0, (%rsi)
movl $0x600, %edi            # imm = 0x600
callq 0x4680
movq 0x20(%rsp), %rdi
movq (%rdi), %rcx
imulq $0x18, %r14, %rdx
movq %rdx, 0x18(%rsp)
movq %rax, 0x10(%rcx,%rdx)
testq %rax, %rax
je 0x63995
xorl %r14d, %r14d
pushq $0x1
popq %rbp
cmpq $0x80, %rbp
je 0x63995
movslq 0x14420(%rdi), %rax
cmpq %rax, %rbp
jge 0x63995
imulq $0x280, %rbp, %rax      # imm = 0x280
movq 0x38(%rsp), %r9
movq 0x10(%r9,%rax), %rdx
movslq %r14d, %rbx
cmpq 0x8(%r9,%rax), %rdx
jae 0x638d6
addq %r9, %rax
movq (%rax), %rsi
leaq 0x1(%rdx), %r8
movq %r8, 0x10(%rax)
movzbl (%rsi,%rdx), %edx
movq 0x18(%rsp), %rax
andl $0x0, 0x8(%rcx,%rax)
decl %edx
cmpl $0xa, %edx
ja 0x638e0
movq %rbp, %rax
shlq $0x4, %rax
leaq 0x1eda7(%rip), %rsi     # 0x82190
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
orq $0x1, %rax
imulq $0x28, %rax, %rcx
movq 0x10(%r9,%rcx), %rsi
cmpq 0x8(%r9,%rcx), %rsi
jae 0x638cf
movl %ebx, %eax
addq 0x10(%rsp), %rbx
addq %r9, %rcx
movq 0x28(%rsp), %rdx
subl %r14d, %edx
movslq %edx, %r10
xorl %r8d, %r8d
movq %r8, %rdx
movq (%rcx), %r8
leaq 0x1(%rsi), %r9
movq %r9, 0x10(%rcx)
movb (%r8,%rsi), %sil
movb %sil, (%rbx,%rdx)
testb %sil, %sil
je 0x63450
leaq 0x1(%rdx), %r8
cmpq %r10, %r8
jge 0x63450
movq 0x10(%rcx), %rsi
cmpq 0x8(%rcx), %rsi
jb 0x63422
movq (%rdi), %rcx
movq 0x18(%rsp), %rsi
movq 0x10(%rcx,%rsi), %rsi
imulq $0xc, %rbp, %r8
movl $0x1, (%rsi,%r8)
movl %eax, 0x8(%rsi,%r8)
movl %edx, 0x4(%rsi,%r8)
addl %edx, %r14d
jmp 0x637df
imulq $0x18, 0x48(%rsp), %r13
movslq 0x8(%rcx,%r13), %rax
cmpq %rax, %rbp
jge 0x638cf
movl %ebp, %esi
pushq $0x9
popq %rdx
leaq 0xc(%rsp), %rcx
movq %rdi, %r15
callq 0x63e35
testl %eax, %eax
js 0x638cf
movq (%r15), %rax
movq 0x10(%rax,%r13), %rcx
movq %r13, %rsi
imulq $0xc, %rbp, %r13
movl 0x8(%rcx,%r13), %eax
leal (%r14,%rax), %edx
incl %edx
cmpl 0x28(%rsp), %edx
jge 0x638cf
movq %r14, 0x50(%rsp)
movl 0x4(%rcx,%r13), %r14d
addl 0xc(%rsp), %r14d
addq 0x10(%rsp), %rbx
movzbl %al, %edx
movq %rbx, %rdi
movq %rsi, %rbx
movl %r14d, %esi
callq 0x63e6c
addl 0x50(%rsp), %eax
movq (%r15), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rdx
movl $0x3, (%rdx,%r13)
movl %r14d, 0x4(%rdx,%r13)
movq 0x10(%rcx,%rbx), %rsi
movl 0x8(%rsi,%r13), %esi
movl %esi, 0x8(%rdx,%r13)
movl %eax, %r14d
movq %r15, %rdi
jmp 0x637df
movq %r14, %r13
movl %ebp, %esi
pushq $0x4
popq %rdx
leaq 0x30(%rsp), %rcx
movq %rdi, %r14
callq 0x63e35
testl %eax, %eax
js 0x638cf
movq %r14, %rdi
movl %ebp, %esi
pushq $0x3
popq %rdx
leaq 0xc(%rsp), %rcx
callq 0x63dff
testl %eax, %eax
js 0x638cf
movl 0x30(%rsp), %r15d
leal (%r15,%r13), %eax
addl $0x14, %eax
cmpl 0x28(%rsp), %eax
jae 0x638cf
addq 0x10(%rsp), %rbx
movl 0xc(%rsp), %r14d
movzbl %r15b, %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x63e6c
addl %r13d, %eax
movq 0x20(%rsp), %rdi
movq (%rdi), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rdx
imulq $0xc, %rbp, %rsi
movl $0x3, (%rdx,%rsi)
movl %r14d, 0x4(%rdx,%rsi)
movl %r15d, 0x8(%rdx,%rsi)
jmp 0x637c5
incl %r14d
cmpl 0x28(%rsp), %r14d
jge 0x638cf
orq $0x2, %rax
imulq $0x28, %rax, %rax
movq 0x10(%r9,%rax), %rcx
cmpq 0x8(%r9,%rax), %rcx
jae 0x638cf
addq %r9, %rax
movq (%rax), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x10(%rax)
movb (%rdx,%rcx), %al
movq 0x10(%rsp), %rsi
movb %al, (%rsi,%rbx)
movq (%rdi), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rcx,%rax), %rax
imulq $0xc, %rbp, %rdx
movl $0x2, (%rax,%rdx)
movsbl (%rsi,%rbx), %esi
movl %esi, 0x4(%rax,%rdx)
jmp 0x637df
movl %ebp, %esi
pushq $0x7
popq %rdx
leaq 0xc(%rsp), %rcx
callq 0x63dff
testl %eax, %eax
js 0x638cf
leal 0x14(%r14), %eax
cmpl 0x28(%rsp), %eax
jge 0x638cf
addq 0x10(%rsp), %rbx
movq %r14, %r15
movl 0xc(%rsp), %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x63f22
addl %r15d, %eax
movq 0x20(%rsp), %rdi
movq (%rdi), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rdx
imulq $0xc, %rbp, %rsi
movl $0x7, (%rdx,%rsi)
movl %r14d, 0x4(%rdx,%rsi)
jmp 0x637c5
movq %r14, %r8
imulq $0x18, 0x48(%rsp), %r14
movslq 0x8(%rcx,%r14), %rax
cmpq %rax, %rbp
jge 0x638cf
addq %r14, %rcx
movq 0x10(%rcx), %rax
imulq $0xc, %rbp, %r15
movl (%rax,%r15), %edx
decl %edx
cmpl $0x6, %edx
ja 0x638cf
addq %r15, %rax
leaq 0x1eaf7(%rip), %rsi     # 0x821bc
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movslq 0x4(%rax), %rdx
testq %rdx, %rdx
js 0x638cf
leal (%rdx,%r8), %esi
cmpl 0x28(%rsp), %esi
jge 0x638cf
movq %r8, %r13
addq 0x10(%rsp), %rbx
movslq 0x8(%rax), %rsi
addq (%rcx), %rsi
movq %rbx, %rdi
callq 0x43c0
movq 0x20(%rsp), %rdi
movq (%rdi), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rcx,%rax), %rax
movl $0x1, (%rax,%r15)
movl %r13d, 0x8(%rax,%r15)
movq 0x10(%rcx,%r14), %rdx
movl 0x4(%rdx,%r15), %edx
movl %edx, 0x4(%rax,%r15)
addl %r13d, %edx
movl %edx, %r14d
jmp 0x637df
imulq $0x18, 0x48(%rsp), %r15
movslq 0x8(%rcx,%r15), %rax
cmpq %rax, %rbp
jge 0x638cf
movl %ebp, %esi
pushq $0x8
popq %rdx
leaq 0xc(%rsp), %rcx
callq 0x63e35
testl %eax, %eax
js 0x638cf
leal 0x14(%r14), %eax
cmpl 0x28(%rsp), %eax
jge 0x638cf
movq %r14, 0x50(%rsp)
movl 0xc(%rsp), %r14d
movq 0x20(%rsp), %r13
movq (%r13), %rax
movq 0x10(%rax,%r15), %rax
imulq $0xc, %rbp, %r15
addl 0x4(%rax,%r15), %r14d
addq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x63f22
movq %r13, %rdi
addl 0x50(%rsp), %eax
movq (%r13), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rdx
movl $0x7, (%rdx,%r15)
movl %r14d, 0x4(%rdx,%r15)
movl %eax, %r14d
jmp 0x637df
movq 0x18(%rsp), %rax
movq 0x10(%rcx,%rax), %rax
imulq $0xc, %rbp, %rdx
movl $0xb, (%rax,%rdx)
incq %rbp
jmp 0x63378
incl %r8d
cmpl 0x28(%rsp), %r8d
jge 0x638cf
movb 0x4(%rax), %al
movq 0x10(%rsp), %rcx
movb %al, (%rcx,%rbx)
movq (%rdi), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rcx,%rax), %rax
movl $0x2, (%rax,%r15)
movq 0x10(%rcx,%r14), %rdx
movl 0x4(%rdx,%r15), %edx
movl %edx, 0x4(%rax,%r15)
movq %r8, %r14
jmp 0x637df
leal 0x14(%r8), %ecx
cmpl 0x28(%rsp), %ecx
jge 0x638cf
movq %r8, %r13
addq 0x10(%rsp), %rbx
movl 0x4(%rax), %esi
movq %rbx, %rdi
callq 0x63f22
addl %r13d, %eax
movq 0x20(%rsp), %rdi
movq (%rdi), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rdx
movl $0x7, (%rdx,%r15)
movq 0x10(%rcx,%r14), %rsi
movl 0x4(%rsi,%r15), %esi
movl %esi, 0x4(%rdx,%r15)
jmp 0x637c5
movl 0x8(%rax), %ecx
leal (%rcx,%r8), %edx
cmpl 0x28(%rsp), %edx
jge 0x638cf
movq %r8, %r13
addq 0x10(%rsp), %rbx
movl 0x4(%rax), %esi
movzbl %cl, %edx
movq %rbx, %rdi
callq 0x63e6c
addl %r13d, %eax
movq 0x20(%rsp), %rdi
movq (%rdi), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rdx
movl $0x3, (%rdx,%r15)
movq 0x10(%rcx,%r14), %rsi
movq 0x4(%rsi,%r15), %rsi
movq %rsi, 0x4(%rdx,%r15)
jmp 0x637c5
pushq $-0x1
popq %rdx
movl %edx, %eax
jmp 0x63945
movq 0x18(%rsp), %rax
andl $0x0, 0x8(%rcx,%rax)
incl %r14d
pushq $-0x1
popq %rdx
movl %edx, %eax
cmpl 0x28(%rsp), %r14d
jge 0x63945
movq 0x10(%rsp), %rdx
movb $0x0, (%rdx,%rbx)
movq 0x20(%rsp), %rbx
movq (%rbx), %rax
movq 0x18(%rsp), %r15
movq 0x10(%rax,%r15), %rdi
movl %ebp, %ecx
imulq $0xc, %rcx, %rcx
movl $0xc, (%rdi,%rcx)
movq %rdx, (%rax,%r15)
movl %ebp, 0x8(%rax,%r15)
imull $0xc, %ebp, %esi
addl $0xc, %esi
callq 0x4840
movq (%rbx), %rcx
addq %r15, %rcx
addq $0x10, %rcx
testq %rax, %rax
je 0x6395c
movq %rax, (%rcx)
movl %r14d, %eax
jmp 0x6333e
testl %eax, %eax
movq 0x28(%rsp), %rbx
jle 0x6398e
movl %eax, %ecx
addq %rcx, 0x40(%rsp)
subl %eax, %ebx
jmp 0x631e6
cmpq $0x1, (%rcx)
movl $0x0, %eax
sbbl %eax, %eax
orl %r14d, %eax
jmp 0x6333e
movq 0x20(%rsp), %rdi
callq 0x62c80
xorl %r12d, %r12d
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rdi
jns 0x639a5
movq %r12, %rdi
callq 0x45c0
movq 0x20(%rsp), %rdi
xorl %r12d, %r12d
callq 0x62c80
movq 0x68(%rsp), %rax
movq 0x40(%rsp), %rcx
movl %ecx, (%rax)
jmp 0x6397c