// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/htscodecs/htscodecs/rANS_static32x16pr.c
// Function: rans_uncompress_O0_32x16
unsigned char *rans_uncompress_O0_32x16(unsigned char *in,
                                        unsigned int in_size,
                                        unsigned char *out,
                                        unsigned int out_sz) {
    if (in_size < 16) // 4-states at least
        return NULL;

    if (out_sz >= INT_MAX)
        return NULL; // protect against some overflow cases

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    if (out_sz > 100000)
        return NULL;
#endif

    /* Load in the static tables */
    unsigned char *cp = in, *out_free = NULL;
    unsigned char *cp_end = in + in_size;
    int i;
    uint32_t s3[TOTFREQ]; // For TF_SHIFT <= 12

    if (!out)
        out_free = out = malloc(out_sz);
    if (!out)
        return NULL;

    // Precompute reverse lookup of frequency.
    uint32_t F[256] = {0}, fsum;
    int fsz = decode_freq(cp, cp_end, F, &fsum);
    if (!fsz)
        goto err;
    cp += fsz;

    normalise_freq_shift(F, fsum, TOTFREQ);

    // Build symbols; fixme, do as part of decode, see the _d variant
    if (rans_F_to_s3(F, TF_SHIFT, s3))
        goto err;

    if (cp_end - cp < NX * 4)
        goto err;

    int z;
    RansState R[NX];
    for (z = 0; z < NX; z++) {
        RansDecInit(&R[z], &cp);
        if (R[z] < RANS_BYTE_L)
            goto err;
    }

    int out_end = (out_sz&~(NX-1));
    const uint32_t mask = (1u << TF_SHIFT)-1;
    cp_end -= NX*2; // worst case for renorm bytes

    // assume NX is divisible by 4
    assert(NX%4==0);

    // Unsafe loop with no ptr overflow checking within loop itself
    for (i=0; likely(i < out_end && cp < cp_end); i+=NX) {
        for (z = 0; z < NX; z+=4) {
            uint32_t S[4];
            S[0] = s3[R[z+0] & mask];
            S[1] = s3[R[z+1] & mask];
            S[2] = s3[R[z+2] & mask];
            S[3] = s3[R[z+3] & mask];

            R[z+0] = (S[0]>>(TF_SHIFT+8)) * (R[z+0] >> TF_SHIFT)
                + ((S[0]>>8) & mask);
            R[z+1] = (S[1]>>(TF_SHIFT+8)) * (R[z+1] >> TF_SHIFT)
                + ((S[1]>>8) & mask);
            R[z+2] = (S[2]>>(TF_SHIFT+8)) * (R[z+2] >> TF_SHIFT)
                + ((S[2]>>8) & mask);
            R[z+3] = (S[3]>>(TF_SHIFT+8)) * (R[z+3] >> TF_SHIFT)
                + ((S[3]>>8) & mask);

            out[i+z+0] = S[0];
            out[i+z+1] = S[1];
            out[i+z+2] = S[2];
            out[i+z+3] = S[3];

            RansDecRenorm(&R[z+0], &cp);
            RansDecRenorm(&R[z+1], &cp);
            RansDecRenorm(&R[z+2], &cp);
            RansDecRenorm(&R[z+3], &cp);

            if (NX%8==0) {
                z += 4;
                S[0] = s3[R[z+0] & mask];
                S[1] = s3[R[z+1] & mask];
                S[2] = s3[R[z+2] & mask];
                S[3] = s3[R[z+3] & mask];

                R[z+0] = (S[0]>>(TF_SHIFT+8)) * (R[z+0] >> TF_SHIFT)
                    + ((S[0]>>8) & mask);
                R[z+1] = (S[1]>>(TF_SHIFT+8)) * (R[z+1] >> TF_SHIFT)
                    + ((S[1]>>8) & mask);
                R[z+2] = (S[2]>>(TF_SHIFT+8)) * (R[z+2] >> TF_SHIFT)
                    + ((S[2]>>8) & mask);
                R[z+3] = (S[3]>>(TF_SHIFT+8)) * (R[z+3] >> TF_SHIFT)
                    + ((S[3]>>8) & mask);

                out[i+z+0] = S[0];
                out[i+z+1] = S[1];
                out[i+z+2] = S[2];
                out[i+z+3] = S[3];

                RansDecRenorm(&R[z+0], &cp);
                RansDecRenorm(&R[z+1], &cp);
                RansDecRenorm(&R[z+2], &cp);
                RansDecRenorm(&R[z+3], &cp);
            }
        }
    }

    // Safe loop
    for (; i < out_end; i+=NX) {
        for (z = 0; z < NX; z+=4) {
            uint32_t S[4];
            S[0] = s3[R[z+0] & mask];
            S[1] = s3[R[z+1] & mask];
            S[2] = s3[R[z+2] & mask];
            S[3] = s3[R[z+3] & mask];

            R[z+0] = (S[0]>>(TF_SHIFT+8)) * (R[z+0] >> TF_SHIFT)
                + ((S[0]>>8) & mask);
            R[z+1] = (S[1]>>(TF_SHIFT+8)) * (R[z+1] >> TF_SHIFT)
                + ((S[1]>>8) & mask);
            R[z+2] = (S[2]>>(TF_SHIFT+8)) * (R[z+2] >> TF_SHIFT)
                + ((S[2]>>8) & mask);
            R[z+3] = (S[3]>>(TF_SHIFT+8)) * (R[z+3] >> TF_SHIFT)
                + ((S[3]>>8) & mask);

            out[i+z+0] = S[0];
            out[i+z+1] = S[1];
            out[i+z+2] = S[2];
            out[i+z+3] = S[3];

            RansDecRenormSafe(&R[z+0], &cp, cp_end+NX*2);
            RansDecRenormSafe(&R[z+1], &cp, cp_end+NX*2);
            RansDecRenormSafe(&R[z+2], &cp, cp_end+NX*2);
            RansDecRenormSafe(&R[z+3], &cp, cp_end+NX*2);
        }
    }

    for (z = out_sz & (NX-1); z-- > 0; )
        out[out_end + z] = s3[R[z] & mask];

    //fprintf(stderr, "    0 Decoded %d bytes\n", (int)(cp-in)); //c-size

    return out;

 err:
    free(out_free);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x44b8, %rsp           # imm = 0x44B8
movl %ecx, %ebx
cmpl $0x10, %esi
setb %al
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
setae %cl
orb %al, %cl
jne 0x78594
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r15
testq %rdx, %rdx
je 0x77d76
xorl %eax, %eax
jmp 0x77d80
movl %ebx, %edi
callq 0x4680
movq %rax, %r13
xorl %r12d, %r12d
testq %r13, %r13
je 0x78594
movq %rax, 0x10(%rsp)
movl %ebp, %eax
movq %rax, 0x8(%rsp)
leaq (%r15,%rax), %r14
leaq 0xb0(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x4260
testl %ebp, %ebp
je 0x77f39
leaq 0x1(%r15), %rax
movzbl (%r15), %ecx
xorl %edx, %edx
cmpl $0x4, %ebp
jb 0x77e16
xorl %r12d, %r12d
xorl %edx, %edx
movl %ecx, %esi
movl $0x1, 0xb0(%rsp,%rsi,4)
testl %edx, %edx
je 0x77def
cmpl $0xfe, %ecx
jg 0x77e73
decl %edx
incl %ecx
jmp 0x77e09
movl %ecx, %edx
incl %edx
movzbl (%rax), %ecx
cmpl %ecx, %edx
jne 0x77e04
movzbl 0x1(%rax), %edx
addq $0x2, %rax
jmp 0x77e09
incq %rax
xorl %edx, %edx
testl %ecx, %ecx
je 0x77e16
leaq 0x2(%rax), %rsi
cmpq %r14, %rsi
jb 0x77dcc
testl %ecx, %ecx
je 0x77e6d
xorl %r12d, %r12d
movl %ecx, %esi
movl $0x1, 0xb0(%rsp,%rsi,4)
cmpq %r14, %rax
jae 0x77e73
testl %edx, %edx
je 0x77e41
cmpl $0xfe, %ecx
jg 0x77e73
decl %edx
incl %ecx
jmp 0x77e64
movl %ecx, %edi
incl %edi
movzbl (%rax), %ecx
leaq 0x1(%rax), %rsi
xorl %edx, %edx
cmpl %ecx, %edi
jne 0x77e61
cmpq %r14, %rsi
jae 0x77e73
movzbl 0x1(%rax), %edx
addq $0x2, %rax
jmp 0x77e64
movq %rsi, %rax
testl %ecx, %ecx
je 0x77e6d
cmpq %r14, %rax
jb 0x77e1d
subl %r15d, %eax
movslq %eax, %r12
addq %r15, %r12
xorl %ecx, %ecx
xorl %eax, %eax
cmpl $0x0, 0xb0(%rsp,%rcx,4)
je 0x77efc
movq %r14, %rdx
subq %r12, %rdx
cmpq $0x6, %rdx
jl 0x77ec9
xorl %edi, %edi
xorl %edx, %edx
movzbl (%r12,%rdi), %r8d
movl %edx, %esi
shll $0x7, %esi
movl %r8d, %edx
andl $0x7f, %edx
orl %esi, %edx
leaq 0x1(%rdi), %rsi
testb %r8b, %r8b
jns 0x77eb7
cmpl $0x5, %edi
movq %rsi, %rdi
jne 0x77e94
addq %r12, %rsi
movl %edx, 0xb0(%rsp,%rcx,4)
subl %r12d, %esi
movslq %esi, %rdx
jmp 0x77ef2
cmpq %r14, %r12
jae 0x77ee5
movsbl (%r12), %edx
testl %edx, %edx
js 0x77f0e
movl %edx, 0xb0(%rsp,%rcx,4)
movl $0x1, %edx
jmp 0x77ef2
movl $0x0, 0xb0(%rsp,%rcx,4)
xorl %edx, %edx
addq %rdx, %r12
addl 0xb0(%rsp,%rcx,4), %eax
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x77e7a
jmp 0x77f34
xorl %edx, %edx
movq %r12, %rsi
movzbl (%rsi), %edi
incq %rsi
movl %edx, %r8d
shll $0x7, %r8d
movl %edi, %edx
andl $0x7f, %edx
orl %r8d, %edx
testb %dil, %dil
jns 0x77eba
cmpq %r14, %rsi
jb 0x77f13
jmp 0x77eba
subl %r15d, %r12d
jmp 0x77f39
testl %r12d, %r12d
je 0x7858a
movslq %r12d, %rdx
testl $0xffffefff, %eax       # imm = 0xFFFFEFFF
je 0x77f79
xorl %ecx, %ecx
cmpl $0xfff, %eax            # imm = 0xFFF
ja 0x77f65
xorl %ecx, %ecx
leal (%rax,%rax), %esi
incl %ecx
cmpl $0x800, %eax            # imm = 0x800
movl %esi, %eax
jb 0x77f57
xorl %eax, %eax
shll %cl, 0xb0(%rsp,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x77f67
addq %rdx, %r15
xorl %eax, %eax
xorl %ecx, %ecx
movl 0xb0(%rsp,%rax,4), %esi
movl $0x1000, %edi           # imm = 0x1000
subl %ecx, %edi
leal -0x1(%rsi), %r8d
cmpl %edi, %r8d
jae 0x77fb8
testl %esi, %esi
je 0x77fb8
movl %esi, %edi
shll $0x14, %edi
addl %eax, %edi
movslq %ecx, %rcx
movl %edi, 0x4b0(%rsp,%rcx,4)
incl %ecx
addl $0x100, %edi            # imm = 0x100
decl %esi
jne 0x77fa2
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x77f80
cmpl $0x1000, %ecx           # imm = 0x1000
jne 0x7858a
movq 0x8(%rsp), %rax
subq %rdx, %rax
cmpq $0x80, %rax
jl 0x7858a
xorl %eax, %eax
movl (%r15,%rax), %ecx
movl %ecx, 0x20(%rsp,%rax)
cmpl $0x8000, %ecx           # imm = 0x8000
jb 0x7858a
addq $0x4, %rax
cmpq $0x80, %rax
jne 0x77fe5
movl %ebx, %ecx
andl $0x7fffffe0, %ecx       # imm = 0x7FFFFFE0
addq %rax, %r15
xorl %edi, %edi
movl %ecx, %eax
movq %rax, 0x10(%rsp)
testl %ecx, %ecx
movq %r14, 0x8(%rsp)
movq %rbx, 0xa8(%rsp)
movq %rcx, 0x18(%rsp)
je 0x78367
leaq -0x40(%r14), %r8
cmpq %r8, %r15
jae 0x78362
movq %r13, 0xa0(%rsp)
leaq 0x7(%r13), %r9
xorl %edi, %edi
movl $0xfff, %r10d           # imm = 0xFFF
movq $-0x8, %r11
movl 0x40(%rsp,%r11,4), %r14d
movl 0x44(%rsp,%r11,4), %esi
movl %r14d, %eax
andl %r10d, %eax
movl 0x4b0(%rsp,%rax,4), %eax
movl %esi, %ecx
andl %r10d, %ecx
movl 0x4b0(%rsp,%rcx,4), %edx
movl 0x48(%rsp,%r11,4), %r13d
movl %r13d, %ecx
andl %r10d, %ecx
movl 0x4b0(%rsp,%rcx,4), %ebp
movl 0x4c(%rsp,%r11,4), %ebx
movl %ebx, %ecx
andl %r10d, %ecx
movl 0x4b0(%rsp,%rcx,4), %r12d
movl %eax, %ecx
shrl $0x14, %ecx
shrl $0xc, %r14d
imull %ecx, %r14d
movl %eax, %ecx
shrl $0x8, %ecx
andl %r10d, %ecx
addl %r14d, %ecx
movl %ecx, 0x40(%rsp,%r11,4)
movl %edx, %r14d
shrl $0x14, %r14d
shrl $0xc, %esi
imull %r14d, %esi
movl %edx, %r14d
shrl $0x8, %r14d
andl %r10d, %r14d
addl %esi, %r14d
movl %r14d, 0x44(%rsp,%r11,4)
movl %ebp, %esi
shrl $0x14, %esi
shrl $0xc, %r13d
imull %esi, %r13d
movl %ebp, %esi
shrl $0x8, %esi
andl %r10d, %esi
addl %r13d, %esi
movl %esi, 0x48(%rsp,%r11,4)
movl %r12d, %r13d
shrl $0x14, %r13d
shrl $0xc, %ebx
imull %r13d, %ebx
movl %r12d, %r13d
shrl $0x8, %r13d
andl %r10d, %r13d
addl %ebx, %r13d
movl %r13d, 0x4c(%rsp,%r11,4)
movb %al, 0x1(%r9,%r11)
movb %dl, 0x2(%r9,%r11)
movb %bpl, 0x3(%r9,%r11)
movb %r12b, 0x4(%r9,%r11)
movzwl (%r15), %eax
movl %ecx, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %ecx           # imm = 0x8000
cmovbl %edx, %ecx
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %ecx, 0x40(%rsp,%r11,4)
movzwl (%r15), %eax
movl %r14d, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %r14d          # imm = 0x8000
cmovbl %edx, %r14d
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %r14d, 0x44(%rsp,%r11,4)
movzwl (%r15), %eax
movl %esi, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %esi           # imm = 0x8000
cmovbl %edx, %esi
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %esi, 0x48(%rsp,%r11,4)
movzwl (%r15), %eax
movl %r13d, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %r13d          # imm = 0x8000
cmovbl %edx, %r13d
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %r13d, 0x4c(%rsp,%r11,4)
movl 0x50(%rsp,%r11,4), %r14d
movl 0x54(%rsp,%r11,4), %esi
movl %r14d, %eax
andl %r10d, %eax
movl 0x4b0(%rsp,%rax,4), %eax
movl %esi, %ecx
andl %r10d, %ecx
movl 0x4b0(%rsp,%rcx,4), %edx
movl 0x58(%rsp,%r11,4), %ebx
movl %ebx, %ecx
andl %r10d, %ecx
movl 0x4b0(%rsp,%rcx,4), %ebp
movl 0x5c(%rsp,%r11,4), %ecx
movl %ecx, %r12d
andl %r10d, %r12d
movl 0x4b0(%rsp,%r12,4), %r12d
movl %eax, %r13d
shrl $0x14, %r13d
shrl $0xc, %r14d
imull %r13d, %r14d
movl %eax, %r13d
shrl $0x8, %r13d
andl %r10d, %r13d
addl %r14d, %r13d
movl %r13d, 0x50(%rsp,%r11,4)
movl %edx, %r14d
shrl $0x14, %r14d
shrl $0xc, %esi
imull %r14d, %esi
movl %edx, %r14d
shrl $0x8, %r14d
andl %r10d, %r14d
addl %esi, %r14d
movl %r14d, 0x54(%rsp,%r11,4)
movl %ebp, %esi
shrl $0x14, %esi
shrl $0xc, %ebx
imull %esi, %ebx
movl %ebp, %esi
shrl $0x8, %esi
andl %r10d, %esi
addl %ebx, %esi
movl %esi, 0x58(%rsp,%r11,4)
movl %r12d, %esi
shrl $0x14, %esi
shrl $0xc, %ecx
imull %esi, %ecx
movl %r12d, %esi
shrl $0x8, %esi
andl %r10d, %esi
addl %ecx, %esi
movl %esi, 0x5c(%rsp,%r11,4)
movb %al, 0x5(%r9,%r11)
movb %dl, 0x6(%r9,%r11)
movb %bpl, 0x7(%r9,%r11)
movb %r12b, 0x8(%r9,%r11)
movl 0x50(%rsp,%r11,4), %ecx
movl 0x54(%rsp,%r11,4), %esi
movzwl (%r15), %eax
movl %ecx, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %ecx           # imm = 0x8000
cmovbl %edx, %ecx
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %ecx, 0x50(%rsp,%r11,4)
movzwl (%r15), %eax
movl %esi, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %esi           # imm = 0x8000
cmovbl %edx, %esi
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %esi, 0x54(%rsp,%r11,4)
movl 0x58(%rsp,%r11,4), %ecx
movzwl (%r15), %eax
movl %ecx, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %ecx           # imm = 0x8000
cmovbl %edx, %ecx
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %ecx, 0x58(%rsp,%r11,4)
movl 0x5c(%rsp,%r11,4), %ecx
movzwl (%r15), %eax
movl %ecx, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %ecx           # imm = 0x8000
cmovbl %edx, %ecx
leaq 0x2(%r15), %rax
cmovbq %rax, %r15
movl %ecx, 0x5c(%rsp,%r11,4)
addq $0x8, %r11
cmpq $0x18, %r11
jb 0x7805b
addq $0x20, %rdi
cmpq 0x10(%rsp), %rdi
jae 0x7835a
addq $0x20, %r9
cmpq %r8, %r15
jb 0x78054
movq 0xa0(%rsp), %r13
movq 0x18(%rsp), %rcx
cmpl %ecx, %edi
jae 0x7854e
movl %edi, %eax
leaq (%rax,%r13), %rdx
addq $0x3, %rdx
movl $0xfff, %edi            # imm = 0xFFF
movq $-0x4, %r8
movl 0x30(%rsp,%r8,4), %r14d
movl 0x34(%rsp,%r8,4), %esi
movl %r14d, %ecx
andl %edi, %ecx
movl 0x4b0(%rsp,%rcx,4), %r10d
movl %esi, %ecx
andl %edi, %ecx
movl 0x4b0(%rsp,%rcx,4), %r11d
movl 0x38(%rsp,%r8,4), %ebx
movl %ebx, %ecx
andl %edi, %ecx
movl 0x4b0(%rsp,%rcx,4), %ebp
movl 0x3c(%rsp,%r8,4), %ecx
movl %ecx, %r9d
andl %edi, %r9d
movl 0x4b0(%rsp,%r9,4), %r12d
movl %r10d, %r9d
shrl $0x14, %r9d
shrl $0xc, %r14d
imull %r9d, %r14d
movl %r10d, %r9d
shrl $0x8, %r9d
andl %edi, %r9d
addl %r14d, %r9d
movl %r9d, 0x30(%rsp,%r8,4)
movl %r11d, %r14d
shrl $0x14, %r14d
shrl $0xc, %esi
imull %r14d, %esi
movl %r11d, %r14d
shrl $0x8, %r14d
andl %edi, %r14d
addl %esi, %r14d
movl %r14d, 0x34(%rsp,%r8,4)
movl %ebp, %esi
shrl $0x14, %esi
shrl $0xc, %ebx
imull %esi, %ebx
movl %ebp, %esi
shrl $0x8, %esi
andl %edi, %esi
addl %ebx, %esi
movl %esi, 0x38(%rsp,%r8,4)
movl %r12d, %esi
shrl $0x14, %esi
shrl $0xc, %ecx
imull %esi, %ecx
movl %r12d, %esi
shrl $0x8, %esi
andl %edi, %esi
addl %ecx, %esi
movl %esi, 0x3c(%rsp,%r8,4)
movb %r10b, 0x1(%rdx,%r8)
movb %r11b, 0x2(%rdx,%r8)
movb %bpl, 0x3(%rdx,%r8)
movb %r12b, 0x4(%rdx,%r8)
cmpl $0x7fff, %r9d           # imm = 0x7FFF
jbe 0x78464
movq 0x8(%rsp), %r10
jmp 0x78491
leaq 0x1(%r15), %rcx
movq 0x8(%rsp), %r10
cmpq %r10, %rcx
jae 0x78491
movzbl (%r15), %ecx
movzbl 0x1(%r15), %esi
shll $0x8, %esi
shll $0x10, %r9d
orl %ecx, %r9d
orl %esi, %r9d
addq $0x2, %r15
movl %r9d, 0x30(%rsp,%r8,4)
movl 0x34(%rsp,%r8,4), %ecx
cmpl $0x7fff, %ecx           # imm = 0x7FFF
ja 0x784c5
leaq 0x1(%r15), %rsi
cmpq %r10, %rsi
jae 0x784c5
movzbl (%r15), %esi
movzbl 0x1(%r15), %r9d
shll $0x8, %r9d
shll $0x10, %ecx
orl %esi, %ecx
orl %r9d, %ecx
addq $0x2, %r15
movl %ecx, 0x34(%rsp,%r8,4)
movl 0x38(%rsp,%r8,4), %ecx
cmpl $0x7fff, %ecx           # imm = 0x7FFF
ja 0x784f9
leaq 0x1(%r15), %rsi
cmpq %r10, %rsi
jae 0x784f9
movzbl (%r15), %esi
movzbl 0x1(%r15), %r9d
shll $0x8, %r9d
shll $0x10, %ecx
orl %esi, %ecx
orl %r9d, %ecx
addq $0x2, %r15
movl %ecx, 0x38(%rsp,%r8,4)
movl 0x3c(%rsp,%r8,4), %ecx
cmpl $0x7fff, %ecx           # imm = 0x7FFF
ja 0x7852d
leaq 0x1(%r15), %rsi
cmpq %r10, %rsi
jae 0x7852d
movzbl (%r15), %esi
movzbl 0x1(%r15), %r9d
shll $0x8, %r9d
shll $0x10, %ecx
orl %esi, %ecx
orl %r9d, %ecx
addq $0x2, %r15
movl %ecx, 0x3c(%rsp,%r8,4)
addq $0x4, %r8
cmpq $0x1c, %r8
jb 0x78385
addq $0x20, %rax
addq $0x20, %rdx
cmpq 0x10(%rsp), %rax
jb 0x7837e
movq 0xa8(%rsp), %rdx
testb $0x1f, %dl
je 0x78597
andl $0x1f, %edx
incq %rdx
movq 0x18(%rsp), %rsi
addq %r13, %rsi
movl $0xfff, %eax            # imm = 0xFFF
movl 0x18(%rsp,%rdx,4), %ecx
andl %eax, %ecx
movb 0x4b0(%rsp,%rcx,4), %cl
movb %cl, -0x2(%rsi,%rdx)
decq %rdx
cmpq $0x1, %rdx
jg 0x7856e
jmp 0x78597
movq 0x10(%rsp), %rdi
callq 0x45c0
xorl %r13d, %r13d
movq %r13, %rax
addq $0x44b8, %rsp           # imm = 0x44B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq