// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static32x16pr.c
// Function: rans_uncompress_O1_32x16
unsigned char *rans_uncompress_O1_32x16(unsigned char *in,
                                        unsigned int in_size,
                                        unsigned char *out,
                                        unsigned int out_sz) {
    if (in_size < NX*4) // 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, *cp_end = in+in_size, *out_free = NULL;
    unsigned char *c_freq = NULL;
    int i;

    /*
     * Somewhat complex memory layout.
     * With shift==12 (TF_SHIFT_O1) we fill out use both sfb and fb.
     * With shift==10 (...O1_FAST)  we fill out and use s3 only.
     *
     * sfb+fb is larger, therefore we allocate this much memory.
     */
    uint8_t *sfb_ = htscodecs_tls_alloc(256*
                                        ((TOTFREQ_O1+MAGIC2)*sizeof(*sfb_)
                                         +256 * sizeof(fb_t)));
    if (!sfb_)
        return NULL;

    // sfb and fb are consecutive
    uint8_t *sfb[257];
    if ((*cp >> 4) == TF_SHIFT_O1) {
        for (i = 0; i <= 256; i++)
            sfb[i]=  sfb_ + i*(TOTFREQ_O1+MAGIC2);
    } else {
        for (i = 0; i <= 256; i++)
            sfb[i]=  sfb_ + i*(TOTFREQ_O1_FAST+MAGIC2);
    }
    fb_t (*fb)[256] = (fb_t (*)[256]) sfb[256];

    // NOTE: s3 overlaps sfb/fb
    uint32_t (*s3)[TOTFREQ_O1_FAST] = (uint32_t (*)[TOTFREQ_O1_FAST])sfb_;

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

    if (!out)
        goto err;

    //fprintf(stderr, "out_sz=%d\n", out_sz);

    // compressed header? If so uncompress it
    unsigned char *tab_end = NULL;
    unsigned char *c_freq_end = cp_end;
    unsigned int shift = *cp >> 4;
    if (*cp++ & 1) {
        uint32_t u_freq_sz, c_freq_sz;
        cp += var_get_u32(cp, cp_end, &u_freq_sz);
        cp += var_get_u32(cp, cp_end, &c_freq_sz);
        if (c_freq_sz > cp_end - cp)
            goto err;
        tab_end = cp + c_freq_sz;
        if (!(c_freq = rans_uncompress_O0_4x16(cp, c_freq_sz, NULL,u_freq_sz)))
            goto err;
        cp = c_freq;
        c_freq_end = c_freq + u_freq_sz;
    }

    // Decode order-0 symbol list; avoids needing in order-1 tables
    cp += decode_freq1(cp, c_freq_end, shift, NULL, s3, sfb, fb);

    if (tab_end)
        cp = tab_end;
    free(c_freq);
    c_freq = NULL;

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

    RansState R[NX];
    uint8_t *ptr = cp, *ptr_end = in + in_size - 2*NX;
    int z;
    for (z = 0; z < NX; z++) {
        RansDecInit(&R[z], &ptr);
        if (R[z] < RANS_BYTE_L)
            goto err;
    }

    int isz4 = out_sz/NX;
    int i4[NX], l[NX] = {0};
    for (z = 0; z < NX; z++)
        i4[z] = z*isz4;

    const int low_ent = in_size < 0.2 * out_sz;

    // Around 15% faster to specialise for 10/12 than to have one
    // loop with shift as a variable.
    if (shift == TF_SHIFT_O1) {
        // TF_SHIFT_O1 = 12
        const uint32_t mask = ((1u << TF_SHIFT_O1)-1);
        for (; likely(i4[0] < isz4);) {
            for (z = 0; z < NX; z+=4) {
                uint16_t m[4], c[4];

                c[0] = sfb[l[z+0]][m[0] = R[z+0] & mask];
                c[1] = sfb[l[z+1]][m[1] = R[z+1] & mask];
                c[2] = sfb[l[z+2]][m[2] = R[z+2] & mask];
                c[3] = sfb[l[z+3]][m[3] = R[z+3] & mask];

                R[z+0] = fb[l[z+0]][c[0]].f * (R[z+0]>>TF_SHIFT_O1);
                R[z+0] += m[0] - fb[l[z+0]][c[0]].b;

                R[z+1] = fb[l[z+1]][c[1]].f * (R[z+1]>>TF_SHIFT_O1);
                R[z+1] += m[1] - fb[l[z+1]][c[1]].b;

                R[z+2] = fb[l[z+2]][c[2]].f * (R[z+2]>>TF_SHIFT_O1);
                R[z+2] += m[2] - fb[l[z+2]][c[2]].b;

                R[z+3] = fb[l[z+3]][c[3]].f * (R[z+3]>>TF_SHIFT_O1);
                R[z+3] += m[3] - fb[l[z+3]][c[3]].b;

                out[i4[z+0]++] = l[z+0] = c[0];
                out[i4[z+1]++] = l[z+1] = c[1];
                out[i4[z+2]++] = l[z+2] = c[2];
                out[i4[z+3]++] = l[z+3] = c[3];

                if (!low_ent && likely(ptr < ptr_end)) {
                    RansDecRenorm(&R[z+0], &ptr);
                    RansDecRenorm(&R[z+1], &ptr);
                    RansDecRenorm(&R[z+2], &ptr);
                    RansDecRenorm(&R[z+3], &ptr);
                } else {
                    RansDecRenormSafe(&R[z+0], &ptr, ptr_end+2*NX);
                    RansDecRenormSafe(&R[z+1], &ptr, ptr_end+2*NX);
                    RansDecRenormSafe(&R[z+2], &ptr, ptr_end+2*NX);
                    RansDecRenormSafe(&R[z+3], &ptr, ptr_end+2*NX);
                }
            }
        }

        // Remainder
        for (; i4[NX-1] < out_sz; i4[NX-1]++) {
            uint32_t m = R[NX-1] & ((1u<<TF_SHIFT_O1)-1);
            unsigned char c = sfb[l[NX-1]][m];
            out[i4[NX-1]] = c;
            R[NX-1] = fb[l[NX-1]][c].f * (R[NX-1]>>TF_SHIFT_O1) +
                m - fb[l[NX-1]][c].b;
            RansDecRenormSafe(&R[NX-1], &ptr, ptr_end + 2*NX);
            l[NX-1] = c;
        }
    } else {
        // TF_SHIFT_O1 = 10
        const uint32_t mask = ((1u << TF_SHIFT_O1_FAST)-1);
        for (; likely(i4[0] < isz4);) {
            for (z = 0; z < NX; z+=4) {
                // Merged sfb and fb into single s3 lookup.
                // The m[4] array completely vanishes in this method.
                uint32_t S[4] = {
                    s3[l[z+0]][R[z+0] & mask],
                    s3[l[z+1]][R[z+1] & mask],
                    s3[l[z+2]][R[z+2] & mask],
                    s3[l[z+3]][R[z+3] & mask],
                };

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

                uint32_t F[4] = {
                    S[0]>>(TF_SHIFT_O1_FAST+8),
                    S[1]>>(TF_SHIFT_O1_FAST+8),
                    S[2]>>(TF_SHIFT_O1_FAST+8),
                    S[3]>>(TF_SHIFT_O1_FAST+8),
                };
                uint32_t B[4] = {
                    (S[0]>>8) & mask,
                    (S[1]>>8) & mask,
                    (S[2]>>8) & mask,
                    (S[3]>>8) & mask,
                };

                R[z+0] = F[0] * (R[z+0]>>TF_SHIFT_O1_FAST) + B[0];
                R[z+1] = F[1] * (R[z+1]>>TF_SHIFT_O1_FAST) + B[1];
                R[z+2] = F[2] * (R[z+2]>>TF_SHIFT_O1_FAST) + B[2];
                R[z+3] = F[3] * (R[z+3]>>TF_SHIFT_O1_FAST) + B[3];

                if (!low_ent && (ptr < ptr_end)) {
                    // branchless & asm
                    RansDecRenorm(&R[z+0], &ptr);
                    RansDecRenorm(&R[z+1], &ptr);
                    RansDecRenorm(&R[z+2], &ptr);
                    RansDecRenorm(&R[z+3], &ptr);
                } else {
                    // branched, but better when predictable
                    RansDecRenormSafe(&R[z+0], &ptr, ptr_end+2*NX);
                    RansDecRenormSafe(&R[z+1], &ptr, ptr_end+2*NX);
                    RansDecRenormSafe(&R[z+2], &ptr, ptr_end+2*NX);
                    RansDecRenormSafe(&R[z+3], &ptr, ptr_end+2*NX);
                }
            }
        }

        // Remainder
        for (; i4[NX-1] < out_sz; i4[NX-1]++) {
            uint32_t S = s3[l[NX-1]][R[NX-1] & ((1u<<TF_SHIFT_O1_FAST)-1)];
            out[i4[NX-1]] = l[NX-1] = S&0xff;
            R[NX-1] = (S>>(TF_SHIFT_O1_FAST+8)) * (R[NX-1]>>TF_SHIFT_O1_FAST)
                + ((S>>8) & ((1u<<TF_SHIFT_O1_FAST)-1));
            RansDecRenormSafe(&R[NX-1], &ptr, ptr_end + 2*NX);
        }
    }
    //fprintf(stderr, "    1 Decoded %d bytes\n", (int)(ptr-in)); //c-size

    htscodecs_tls_free(sfb_);
    return out;

 err:
    htscodecs_tls_free(sfb_);
    free(out_free);
    free(c_freq);

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xaa0, %rsp            # imm = 0xAA0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0xc16cf
movq $0x0, -0x8(%rbp)
jmp 0xc2889
cmpl $0x7fffffff, -0x24(%rbp) # imm = 0x7FFFFFFF
jb 0xc16e5
movq $0x0, -0x8(%rbp)
jmp 0xc2889
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x14b300, %edi         # imm = 0x14B300
callq 0xce6a0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xc172d
movq $0x0, -0x8(%rbp)
jmp 0xc2889
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
cmpl $0xc, %eax
jne 0xc1775
movl $0x0, -0x4c(%rbp)
cmpl $0x100, -0x4c(%rbp)     # imm = 0x100
jg 0xc1773
movq -0x58(%rbp), %rcx
imull $0x10b3, -0x4c(%rbp), %eax # imm = 0x10B3
cltq
addq %rax, %rcx
movslq -0x4c(%rbp), %rax
movq %rcx, -0x860(%rbp,%rax,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xc1743
jmp 0xc17ae
movl $0x0, -0x4c(%rbp)
cmpl $0x100, -0x4c(%rbp)     # imm = 0x100
jg 0xc17ac
movq -0x58(%rbp), %rcx
imull $0x4b3, -0x4c(%rbp), %eax # imm = 0x4B3
cltq
addq %rax, %rcx
movslq -0x4c(%rbp), %rax
movq %rcx, -0x860(%rbp,%rax,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xc177c
jmp 0xc17ae
movq -0x60(%rbp), %rax
movq %rax, -0x868(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x870(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc17dd
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x4650
movq %rax, -0x20(%rbp)
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc17e9
jmp 0xc2866
movq $0x0, -0x878(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x880(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
movl %eax, -0x884(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc18e8
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x888(%rbp), %rdx
callq 0xc28a0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x88c(%rbp), %rdx
callq 0xc28a0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x88c(%rbp), %eax
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0xc1890
jmp 0xc2866
movq -0x30(%rbp), %rax
movl -0x88c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x878(%rbp)
movq -0x30(%rbp), %rdi
movl -0x88c(%rbp), %esi
movl -0x888(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x8f460
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0xc18cc
jmp 0xc2866
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movl -0x888(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x880(%rbp)
movq -0x30(%rbp), %rdi
movq -0x880(%rbp), %rsi
movl -0x884(%rbp), %edx
movq -0x870(%rbp), %r8
leaq -0x860(%rbp), %r9
movq -0x868(%rbp), %rax
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0xc29f0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x878(%rbp)
je 0xc193e
movq -0x878(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
cmpq $0x80, %rax
jge 0xc1967
jmp 0xc2866
movq -0x30(%rbp), %rax
movq %rax, -0x918(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
addq $-0x40, %rax
movq %rax, -0x920(%rbp)
movl $0x0, -0x924(%rbp)
cmpl $0x20, -0x924(%rbp)
jge 0xc19e7
movslq -0x924(%rbp), %rax
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc09a0
movslq -0x924(%rbp), %rax
cmpl $0x8000, -0x910(%rbp,%rax,4) # imm = 0x8000
jae 0xc19d4
jmp 0xc2866
jmp 0xc19d6
movl -0x924(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x924(%rbp)
jmp 0xc1991
movl -0x24(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x928(%rbp)
leaq -0xa30(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x4250
movl $0x0, -0x924(%rbp)
cmpl $0x20, -0x924(%rbp)
jge 0xc1a45
movl -0x924(%rbp), %ecx
imull -0x928(%rbp), %ecx
movslq -0x924(%rbp), %rax
movl %ecx, -0x9b0(%rbp,%rax,4)
movl -0x924(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x924(%rbp)
jmp 0xc1a10
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
movl -0x24(%rbp), %eax
cvtsi2sd %rax, %xmm2
movsd 0x33adb(%rip), %xmm0    # 0xf5538
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xa34(%rbp)
cmpl $0xc, -0x884(%rbp)
jne 0xc222f
movl $0xfff, -0xa38(%rbp)    # imm = 0xFFF
movl -0x9b0(%rbp), %eax
cmpl -0x928(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc2138
movl $0x0, -0x924(%rbp)
cmpl $0x20, -0x924(%rbp)
jge 0xc2133
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
movslq -0xa30(%rbp,%rax,4), %rax
movq -0x860(%rbp,%rax,8), %rax
movl -0x924(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movw %cx, -0xa40(%rbp)
movzwl %cx, %ecx
movzbl (%rax,%rcx), %eax
movw %ax, -0xa48(%rbp)
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
movslq -0xa30(%rbp,%rax,4), %rax
movq -0x860(%rbp,%rax,8), %rax
movl -0x924(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movw %cx, -0xa3e(%rbp)
movzwl %cx, %ecx
movzbl (%rax,%rcx), %eax
movw %ax, -0xa46(%rbp)
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
movslq -0xa30(%rbp,%rax,4), %rax
movq -0x860(%rbp,%rax,8), %rax
movl -0x924(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movw %cx, -0xa3c(%rbp)
movzwl %cx, %ecx
movzbl (%rax,%rcx), %eax
movw %ax, -0xa44(%rbp)
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
movslq -0xa30(%rbp,%rax,4), %rax
movq -0x860(%rbp,%rax,8), %rax
movl -0x924(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movw %cx, -0xa3a(%rbp)
movzwl %cx, %ecx
movzbl (%rax,%rcx), %eax
movw %ax, -0xa42(%rbp)
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movzwl -0xa48(%rbp), %ecx
movzwl (%rax,%rcx,4), %ecx
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xc, %eax
imull %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
movzwl -0xa40(%rbp), %ecx
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %edx
addl $0x0, %edx
movslq %edx, %rdx
movslq -0xa30(%rbp,%rdx,4), %rdx
shlq $0xa, %rdx
addq %rdx, %rax
movzwl -0xa48(%rbp), %edx
movzwl 0x2(%rax,%rdx,4), %eax
subl %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
addl -0x910(%rbp,%rax,4), %ecx
movl %ecx, -0x910(%rbp,%rax,4)
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movzwl -0xa46(%rbp), %ecx
movzwl (%rax,%rcx,4), %ecx
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xc, %eax
imull %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
movzwl -0xa3e(%rbp), %ecx
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movslq -0xa30(%rbp,%rdx,4), %rdx
shlq $0xa, %rdx
addq %rdx, %rax
movzwl -0xa46(%rbp), %edx
movzwl 0x2(%rax,%rdx,4), %eax
subl %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
addl -0x910(%rbp,%rax,4), %ecx
movl %ecx, -0x910(%rbp,%rax,4)
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movzwl -0xa44(%rbp), %ecx
movzwl (%rax,%rcx,4), %ecx
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xc, %eax
imull %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
movzwl -0xa3c(%rbp), %ecx
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movslq -0xa30(%rbp,%rdx,4), %rdx
shlq $0xa, %rdx
addq %rdx, %rax
movzwl -0xa44(%rbp), %edx
movzwl 0x2(%rax,%rdx,4), %eax
subl %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
addl -0x910(%rbp,%rax,4), %ecx
movl %ecx, -0x910(%rbp,%rax,4)
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movzwl -0xa42(%rbp), %ecx
movzwl (%rax,%rcx,4), %ecx
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xc, %eax
imull %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
movzwl -0xa3a(%rbp), %ecx
movq -0x868(%rbp), %rax
movl -0x924(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rdx
movslq -0xa30(%rbp,%rdx,4), %rdx
shlq $0xa, %rdx
addq %rdx, %rax
movzwl -0xa42(%rbp), %edx
movzwl 0x2(%rax,%rdx,4), %eax
subl %eax, %ecx
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
addl -0x910(%rbp,%rax,4), %ecx
movl %ecx, -0x910(%rbp,%rax,4)
movzwl -0xa48(%rbp), %eax
movl -0x924(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movl %eax, -0xa30(%rbp,%rcx,4)
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rsi
movl -0x9b0(%rbp,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movzwl -0xa46(%rbp), %eax
movl -0x924(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %eax, -0xa30(%rbp,%rcx,4)
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rsi
movl -0x9b0(%rbp,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movzwl -0xa44(%rbp), %eax
movl -0x924(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %eax, -0xa30(%rbp,%rcx,4)
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rsi
movl -0x9b0(%rbp,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movzwl -0xa42(%rbp), %eax
movl -0x924(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl %eax, -0xa30(%rbp,%rcx,4)
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rsi
movl -0x9b0(%rbp,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0xa34(%rbp)
jne 0xc205d
movq -0x918(%rbp), %rax
cmpq -0x920(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc205d
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
jmp 0xc211d
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
jmp 0xc211f
movl -0x924(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x924(%rbp)
jmp 0xc1ab4
jmp 0xc1a8a
jmp 0xc213a
movl -0x934(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xc222a
movl -0x894(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0xa4c(%rbp)
movslq -0x9b4(%rbp), %rax
movq -0x860(%rbp,%rax,8), %rax
movl -0xa4c(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0xa4d(%rbp)
movb -0xa4d(%rbp), %dl
movq -0x20(%rbp), %rax
movslq -0x934(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x868(%rbp), %rax
movslq -0x9b4(%rbp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movzbl -0xa4d(%rbp), %ecx
movzwl (%rax,%rcx,4), %eax
movl -0x894(%rbp), %ecx
shrl $0xc, %ecx
imull %ecx, %eax
addl -0xa4c(%rbp), %eax
movq -0x868(%rbp), %rcx
movslq -0x9b4(%rbp), %rdx
shlq $0xa, %rdx
addq %rdx, %rcx
movzbl -0xa4d(%rbp), %edx
movzwl 0x2(%rcx,%rdx,4), %ecx
subl %ecx, %eax
movl %eax, -0x894(%rbp)
leaq -0x910(%rbp), %rdi
addq $0x7c, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movzbl -0xa4d(%rbp), %eax
movl %eax, -0x9b4(%rbp)
movl -0x934(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x934(%rbp)
jmp 0xc213a
jmp 0xc2853
movl $0x3ff, -0xa54(%rbp)    # imm = 0x3FF
movl -0x9b0(%rbp), %eax
cmpl -0x928(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc2791
movl $0x0, -0x924(%rbp)
cmpl $0x20, -0x924(%rbp)
jge 0xc278c
movq -0x870(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x924(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xa70(%rbp)
movq -0x870(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x924(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xa6c(%rbp)
movq -0x870(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x924(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xa68(%rbp)
movq -0x870(%rbp), %rax
movl -0x924(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movslq -0xa30(%rbp,%rcx,4), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x924(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl -0x910(%rbp,%rcx,4), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xa64(%rbp)
movl -0xa70(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0x924(%rbp), %edx
addl $0x0, %edx
movslq %edx, %rsi
movl -0x9b0(%rbp,%rsi,4), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %edx, %rdx
movb %al, (%rcx,%rdx)
movzbl %al, %ecx
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
movl %ecx, -0xa30(%rbp,%rax,4)
movl -0xa6c(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0x924(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rsi
movl -0x9b0(%rbp,%rsi,4), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %edx, %rdx
movb %al, (%rcx,%rdx)
movzbl %al, %ecx
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
movl %ecx, -0xa30(%rbp,%rax,4)
movl -0xa68(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0x924(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rsi
movl -0x9b0(%rbp,%rsi,4), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %edx, %rdx
movb %al, (%rcx,%rdx)
movzbl %al, %ecx
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
movl %ecx, -0xa30(%rbp,%rax,4)
movl -0xa64(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0x924(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rsi
movl -0x9b0(%rbp,%rsi,4), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, -0x9b0(%rbp,%rsi,4)
movslq %edx, %rdx
movb %al, (%rcx,%rdx)
movzbl %al, %ecx
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
movl %ecx, -0xa30(%rbp,%rax,4)
movl -0xa70(%rbp), %eax
shrl $0x12, %eax
movl %eax, -0xa80(%rbp)
movl -0xa6c(%rbp), %eax
shrl $0x12, %eax
movl %eax, -0xa7c(%rbp)
movl -0xa68(%rbp), %eax
shrl $0x12, %eax
movl %eax, -0xa78(%rbp)
movl -0xa64(%rbp), %eax
shrl $0x12, %eax
movl %eax, -0xa74(%rbp)
movl -0xa70(%rbp), %eax
shrl $0x8, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0xa90(%rbp)
movl -0xa6c(%rbp), %eax
shrl $0x8, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0xa8c(%rbp)
movl -0xa68(%rbp), %eax
shrl $0x8, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0xa88(%rbp)
movl -0xa64(%rbp), %eax
shrl $0x8, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0xa84(%rbp)
movl -0xa80(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xa, %eax
imull %eax, %ecx
addl -0xa90(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
movl -0xa7c(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xa, %eax
imull %eax, %ecx
addl -0xa8c(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
movl -0xa78(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xa, %eax
imull %eax, %ecx
addl -0xa88(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
movl -0xa74(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
movl -0x910(%rbp,%rax,4), %eax
shrl $0xa, %eax
imull %eax, %ecx
addl -0xa84(%rbp), %ecx
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
movl %ecx, -0x910(%rbp,%rax,4)
cmpl $0x0, -0xa34(%rbp)
jne 0xc26b6
movq -0x918(%rbp), %rax
cmpq -0x920(%rbp), %rax
jae 0xc26b6
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq -0x918(%rbp), %rsi
callq 0xc0a20
jmp 0xc2776
movl -0x924(%rbp), %eax
addl $0x0, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movl -0x924(%rbp), %eax
addl $0x1, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movl -0x924(%rbp), %eax
addl $0x2, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movl -0x924(%rbp), %eax
addl $0x3, %eax
cltq
leaq -0x910(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
jmp 0xc2778
movl -0x924(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x924(%rbp)
jmp 0xc2263
jmp 0xc2239
jmp 0xc2793
movl -0x934(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xc2851
movq -0x870(%rbp), %rax
movslq -0x9b4(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x894(%rbp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xa94(%rbp)
movl -0xa94(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x9b4(%rbp)
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x934(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xa94(%rbp), %eax
shrl $0x12, %eax
movl -0x894(%rbp), %ecx
shrl $0xa, %ecx
imull %ecx, %eax
movl -0xa94(%rbp), %ecx
shrl $0x8, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
addl %ecx, %eax
movl %eax, -0x894(%rbp)
leaq -0x910(%rbp), %rdi
addq $0x7c, %rdi
movq -0x920(%rbp), %rdx
addq $0x40, %rdx
leaq -0x918(%rbp), %rsi
callq 0xc0a90
movl -0x934(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x934(%rbp)
jmp 0xc2793
jmp 0xc2853
movq -0x58(%rbp), %rdi
callq 0xce8f0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc2889
movq -0x58(%rbp), %rdi
callq 0xce8f0
movq -0x40(%rbp), %rdi
callq 0x45a0
movq -0x48(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xaa0, %rsp            # imm = 0xAA0
popq %rbp
retq
nopw %cs:(%rax,%rax)