// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static32x16pr_avx2.c
// Function: rans_uncompress_O0_32x16_avx2
unsigned char *rans_uncompress_O0_32x16_avx2(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] __attribute__((aligned(32))); // 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] __attribute__((aligned(32)));
    for (z = 0; z < NX; z++) {
        RansDecInit(&R[z], &cp);
        if (R[z] < RANS_BYTE_L)
            goto err;
    }

    uint16_t *sp = (uint16_t *)cp;
    uint8_t overflow[64+64] = {0};
    cp_end -= 64;

    // Protect against running off the end of in buffer.
    // We copy it to a worst-case local buffer when near the end.
    if ((uint8_t *)sp > cp_end) {
        memmove(overflow, sp, cp_end+64 - (uint8_t *)sp);
        sp = (uint16_t *)overflow;
        cp_end = overflow + sizeof(overflow) - 64;
    }

    int out_end = (out_sz&~(NX-1));
    const uint32_t mask = (1u << TF_SHIFT)-1;

    __m256i maskv  = _mm256_set1_epi32(mask); // set mask in all lanes
    LOAD(Rv, R);

    for (i=0; i < out_end; i+=NX) {
        //for (z = 0; z < NX; z++)
        //  m[z] = R[z] & mask;
        __m256i masked1 = _mm256_and_si256(Rv1, maskv);
	__m256i masked2 = _mm256_and_si256(Rv2, maskv);
        __m256i masked3 = _mm256_and_si256(Rv3, maskv);
        __m256i masked4 = _mm256_and_si256(Rv4, maskv);

	//  S[z] = s3[m[z]];
	__m256i Sv1 = _mm256_i32gather_epi32x((int *)s3, masked1, sizeof(*s3));
        __m256i Sv2 = _mm256_i32gather_epi32x((int *)s3, masked2, sizeof(*s3));
        __m256i Sv3 = _mm256_i32gather_epi32x((int *)s3, masked3, sizeof(*s3));
        __m256i Sv4 = _mm256_i32gather_epi32x((int *)s3, masked4, sizeof(*s3));

        //  f[z] = S[z]>>(TF_SHIFT+8);
        __m256i fv1 = _mm256_srli_epi32(Sv1, TF_SHIFT+8);
        __m256i fv2 = _mm256_srli_epi32(Sv2, TF_SHIFT+8);

        //  b[z] = (S[z]>>8) & mask;
        __m256i bv1 = _mm256_and_si256(_mm256_srli_epi32(Sv1, 8), maskv);
        __m256i bv2 = _mm256_and_si256(_mm256_srli_epi32(Sv2, 8), maskv);

        //  s[z] = S[z] & 0xff;
        __m256i sv1 = _mm256_and_si256(Sv1, _mm256_set1_epi32(0xff));
        __m256i sv2 = _mm256_and_si256(Sv2, _mm256_set1_epi32(0xff));

        //  R[z] = f[z] * (R[z] >> TF_SHIFT) + b[z];
        Rv1 = _mm256_add_epi32(
                  _mm256_mullo_epi32(
                      _mm256_srli_epi32(Rv1,TF_SHIFT), fv1), bv1);
        Rv2 = _mm256_add_epi32(
                  _mm256_mullo_epi32(
                      _mm256_srli_epi32(Rv2,TF_SHIFT), fv2), bv2);

        // Tricky one:  out[i+z] = s[z];
        //             ---h---g ---f---e  ---d---c ---b---a
        //             ---p---o ---n---m  ---l---k ---j---i
        // packs_epi32 -p-o-n-m -h-g-f-e  -l-k-j-i -d-c-b-a
        // permute4x64 -p-o-n-m -l-k-j-i  -h-g-f-e -d-c-b-a
        // packs_epi16 ponmlkji ponmlkji  hgfedcba hgfedcba
        sv1 = _mm256_packus_epi32(sv1, sv2);
        sv1 = _mm256_permute4x64_epi64(sv1, 0xd8);

        // Protect against running off the end of in buffer.
        // We copy it to a worst-case local buffer when near the end.
        if ((uint8_t *)sp > cp_end) {
            memmove(overflow, sp, cp_end+64 - (uint8_t *)sp);
            sp = (uint16_t *)overflow;
            cp_end = overflow + sizeof(overflow) - 64;
        }

        __m256i Vv1 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        sv1 = _mm256_packus_epi16(sv1, sv1);

        // c =  R[z] < RANS_BYTE_L;

// The lack of unsigned comparisons means we have to jump through hoops.
// in AVX2 land the second version comes out best (and first in SSE land).

//#define _mm256_cmplt_epu32_imm(a,b) _mm256_andnot_si256(_mm256_cmpeq_epi32(_mm256_max_epu32((a),_mm256_set1_epi32(b)), (a)), _mm256_set1_epi32(-1));

#define _mm256_cmplt_epu32_imm(a,b) _mm256_cmpgt_epi32(_mm256_set1_epi32((b)-0x80000000), _mm256_xor_si256((a), _mm256_set1_epi32(0x80000000)))

        __m256i renorm_mask1, renorm_mask2;
        renorm_mask1 = _mm256_cmplt_epu32_imm(Rv1, RANS_BYTE_L);
        renorm_mask2 = _mm256_cmplt_epu32_imm(Rv2, RANS_BYTE_L);

        // y = (R[z] << 16) | V[z];
        unsigned int imask1 = _mm256_movemask_ps((__m256)renorm_mask1);
        __m256i idx1 = _mm256_load_si256((const __m256i*)permute[imask1]);
        __m256i Yv1 = _mm256_slli_epi32(Rv1, 16);
        Vv1 = _mm256_permutevar8x32_epi32(Vv1, idx1);
        __m256i Yv2 = _mm256_slli_epi32(Rv2, 16);

        // Shuffle the renorm values to correct lanes and incr sp pointer
        unsigned int imask2 = _mm256_movemask_ps((__m256)renorm_mask2);
        sp += _mm_popcnt_u32(imask1);

        __m256i idx2 = _mm256_load_si256((const __m256i*)permute[imask2]);
        __m256i Vv2 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        sp += _mm_popcnt_u32(imask2);

        Yv1 = _mm256_or_si256(Yv1, Vv1);
        Vv2 = _mm256_permutevar8x32_epi32(Vv2, idx2);
        Yv2 = _mm256_or_si256(Yv2, Vv2);

        // R[z] = c ? Y[z] : R[z];
        Rv1 = _mm256_blendv_epi8(Rv1, Yv1, renorm_mask1);
        Rv2 = _mm256_blendv_epi8(Rv2, Yv2, renorm_mask2);

        // ------------------------------------------------------------
        //  f[z] = S[z]>>(TF_SHIFT+8);
        __m256i fv3 = _mm256_srli_epi32(Sv3, TF_SHIFT+8);
        __m256i fv4 = _mm256_srli_epi32(Sv4, TF_SHIFT+8);

        //  b[z] = (S[z]>>8) & mask;
        __m256i bv3 = _mm256_and_si256(_mm256_srli_epi32(Sv3, 8), maskv);
        __m256i bv4 = _mm256_and_si256(_mm256_srli_epi32(Sv4, 8), maskv);

        //  s[z] = S[z] & 0xff;
        __m256i sv3 = _mm256_and_si256(Sv3, _mm256_set1_epi32(0xff));
        __m256i sv4 = _mm256_and_si256(Sv4, _mm256_set1_epi32(0xff));

        //  R[z] = f[z] * (R[z] >> TF_SHIFT) + b[z];
        Rv3 = _mm256_add_epi32(_mm256_mullo_epi32(_mm256_srli_epi32(Rv3,TF_SHIFT),fv3),bv3);
        Rv4 = _mm256_add_epi32(_mm256_mullo_epi32(_mm256_srli_epi32(Rv4,TF_SHIFT),fv4),bv4);

        // Tricky one:  out[i+z] = s[z];
        //             ---h---g ---f---e  ---d---c ---b---a
        //             ---p---o ---n---m  ---l---k ---j---i
        // packs_epi32 -p-o-n-m -h-g-f-e  -l-k-j-i -d-c-b-a
        // permute4x64 -p-o-n-m -l-k-j-i  -h-g-f-e -d-c-b-a
        // packs_epi16 ponmlkji ponmlkji  hgfedcba hgfedcba
        sv3 = _mm256_packus_epi32(sv3, sv4);
        sv3 = _mm256_permute4x64_epi64(sv3, 0xd8);

        // c =  R[z] < RANS_BYTE_L;
        __m256i renorm_mask3, renorm_mask4;
        renorm_mask3 = _mm256_cmplt_epu32_imm(Rv3, RANS_BYTE_L);
        sv3 = _mm256_packus_epi16(sv3, sv3);
        renorm_mask4 = _mm256_cmplt_epu32_imm(Rv4, RANS_BYTE_L);

        // y = (R[z] << 16) | V[z];
        __m256i Vv3 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));

        *(uint64_t *)&out[i+0]  = _mm256_extract_epi64(sv1, 0);
        *(uint64_t *)&out[i+8]  = _mm256_extract_epi64(sv1, 2);
        *(uint64_t *)&out[i+16] = _mm256_extract_epi64(sv3, 0);
        *(uint64_t *)&out[i+24] = _mm256_extract_epi64(sv3, 2);

        __m256i Yv3 = _mm256_slli_epi32(Rv3, 16);
        unsigned int imask3 = _mm256_movemask_ps((__m256)renorm_mask3);
        __m256i idx3 = _mm256_load_si256((const __m256i*)permute[imask3]);

        // Shuffle the renorm values to correct lanes and incr sp pointer
        Vv3 = _mm256_permutevar8x32_epi32(Vv3, idx3);
        __m256i Yv4 = _mm256_slli_epi32(Rv4, 16);
        unsigned int imask4 = _mm256_movemask_ps((__m256)renorm_mask4);
        sp += _mm_popcnt_u32(imask3);

        __m256i idx4 = _mm256_load_si256((const __m256i*)permute[imask4]);
        __m256i Vv4 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));

        //Vv = _mm256_and_si256(Vv, renorm_mask);  (blend does the AND anyway)
        Yv3 = _mm256_or_si256(Yv3, Vv3);
        Vv4 = _mm256_permutevar8x32_epi32(Vv4, idx4);
        Yv4 = _mm256_or_si256(Yv4, Vv4);
        sp += _mm_popcnt_u32(imask4);

        // R[z] = c ? Y[z] : R[z];
        Rv3 = _mm256_blendv_epi8(Rv3, Yv3, renorm_mask3);
        Rv4 = _mm256_blendv_epi8(Rv4, Yv4, renorm_mask4);
    }

    STORE(Rv, R);
    //_mm256_store_si256((__m256i *)&R[0], Rv1);
    //_mm256_store_si256((__m256i *)&R[8], Rv2);
    //_mm256_store_si256((__m256i *)&R[16], Rv3);
    //_mm256_store_si256((__m256i *)&R[24], Rv4);

    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
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x6220, %rsp           # imm = 0x6220
movq %rdi, 0x4b70(%rsp)
movl %esi, 0x4b6c(%rsp)
movq %rdx, 0x4b60(%rsp)
movl %ecx, 0x4b5c(%rsp)
cmpl $0x10, 0x4b6c(%rsp)
jae 0x9a168
movq $0x0, 0x4b78(%rsp)
jmp 0x9c334
cmpl $0x7fffffff, 0x4b5c(%rsp) # imm = 0x7FFFFFFF
jb 0x9a186
movq $0x0, 0x4b78(%rsp)
jmp 0x9c334
movq 0x4b70(%rsp), %rax
movq %rax, 0x4b50(%rsp)
movq $0x0, 0x4b48(%rsp)
movq 0x4b70(%rsp), %rax
movl 0x4b6c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x4b40(%rsp)
cmpq $0x0, 0x4b60(%rsp)
jne 0x9a1e5
movl 0x4b5c(%rsp), %eax
movl %eax, %edi
callq 0x4650
movq %rax, 0x4b60(%rsp)
movq %rax, 0x4b48(%rsp)
cmpq $0x0, 0x4b60(%rsp)
jne 0x9a201
movq $0x0, 0x4b78(%rsp)
jmp 0x9c334
leaq 0x720(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x4250
movq 0x4b50(%rsp), %rdi
movq 0x4b40(%rsp), %rsi
leaq 0x720(%rsp), %rdx
leaq 0x71c(%rsp), %rcx
callq 0x9c350
movl %eax, 0x718(%rsp)
cmpl $0x0, 0x718(%rsp)
jne 0x9a250
jmp 0x9c31b
movl 0x718(%rsp), %ecx
movq 0x4b50(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x4b50(%rsp)
leaq 0x720(%rsp), %rdi
movl 0x71c(%rsp), %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x9c440
leaq 0x720(%rsp), %rdi
leaq 0xb20(%rsp), %rdx
movl $0xc, %esi
callq 0x9c4c0
cmpl $0x0, %eax
je 0x9a2aa
jmp 0x9c31b
movq 0x4b40(%rsp), %rax
movq 0x4b50(%rsp), %rcx
subq %rcx, %rax
cmpq $0x80, %rax
jge 0x9a2ca
jmp 0x9c31b
movl $0x0, 0x714(%rsp)
cmpl $0x20, 0x714(%rsp)
jge 0x9a332
movslq 0x714(%rsp), %rax
leaq 0x680(%rsp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq 0x4b50(%rsp), %rsi
callq 0x9c5a0
movslq 0x714(%rsp), %rax
cmpl $0x8000, 0x680(%rsp,%rax,4) # imm = 0x8000
jae 0x9a31d
jmp 0x9c31b
jmp 0x9a31f
movl 0x714(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x714(%rsp)
jmp 0x9a2d5
movq 0x4b50(%rsp), %rax
movq %rax, 0x678(%rsp)
leaq 0x5f0(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x4250
movq 0x4b40(%rsp), %rax
addq $-0x40, %rax
movq %rax, 0x4b40(%rsp)
movq 0x678(%rsp), %rax
cmpq 0x4b40(%rsp), %rax
jbe 0x9a3d2
leaq 0x5f0(%rsp), %rdi
movq 0x678(%rsp), %rsi
movq 0x4b40(%rsp), %rdx
addq $0x40, %rdx
movq 0x678(%rsp), %rax
subq %rax, %rdx
callq 0x4810
leaq 0x5f0(%rsp), %rax
movq %rax, 0x678(%rsp)
leaq 0x5f0(%rsp), %rax
addq $0x80, %rax
addq $-0x40, %rax
movq %rax, 0x4b40(%rsp)
movl 0x4b5c(%rsp), %eax
andl $-0x20, %eax
movl %eax, 0x5ec(%rsp)
movl $0xfff, 0x5e8(%rsp) # imm = 0xFFF
movl $0xfff, 0x56fc(%rsp) # imm = 0xFFF
movl 0x56fc(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl %eax, 0x573c(%rsp)
movl %eax, 0x5738(%rsp)
movl %eax, 0x5734(%rsp)
movl %eax, 0x5730(%rsp)
movl %eax, 0x572c(%rsp)
movl %eax, 0x5728(%rsp)
movl %eax, 0x5724(%rsp)
movl %eax, 0x5720(%rsp)
movl 0x5724(%rsp), %edx
movl 0x5728(%rsp), %ecx
movl 0x572c(%rsp), %eax
movl 0x5734(%rsp), %r8d
movl 0x5738(%rsp), %edi
movl 0x573c(%rsp), %esi
vmovd 0x5730(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm1
vmovd 0x5720(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm2
vmovaps %xmm2, %xmm0
vinserti128 $0x1, %xmm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x5700(%rsp)
vmovdqa 0x5700(%rsp), %ymm0
vmovdqa %ymm0, 0x5c0(%rsp)
leaq 0x680(%rsp), %rax
movq %rax, 0x4bb8(%rsp)
movq 0x4bb8(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x5a0(%rsp)
leaq 0x680(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x4bb0(%rsp)
movq 0x4bb0(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x580(%rsp)
leaq 0x680(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x4ba8(%rsp)
movq 0x4ba8(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x560(%rsp)
leaq 0x680(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x4ba0(%rsp)
movq 0x4ba0(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x540(%rsp)
movl $0x0, 0x4b3c(%rsp)
movl 0x4b3c(%rsp), %eax
cmpl 0x5ec(%rsp), %eax
jge 0x9c1bb
vmovaps 0x5a0(%rsp), %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4fc0(%rsp)
vmovaps %ymm0, 0x4fa0(%rsp)
vmovaps 0x4fc0(%rsp), %ymm0
vmovaps 0x4fa0(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x520(%rsp)
vmovaps 0x580(%rsp), %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4f80(%rsp)
vmovaps %ymm0, 0x4f60(%rsp)
vmovaps 0x4f80(%rsp), %ymm0
vmovaps 0x4f60(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x500(%rsp)
vmovaps 0x560(%rsp), %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4f40(%rsp)
vmovaps %ymm0, 0x4f20(%rsp)
vmovaps 0x4f40(%rsp), %ymm0
vmovaps 0x4f20(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x4e0(%rsp)
vmovaps 0x540(%rsp), %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4f00(%rsp)
vmovaps %ymm0, 0x4ee0(%rsp)
vmovaps 0x4f00(%rsp), %ymm0
vmovaps 0x4ee0(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x4c0(%rsp)
vmovaps 0x520(%rsp), %ymm0
leaq 0xb20(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x4, %esi
movl %esi, 0x30(%rsp)
callq 0x9c620
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %esi
vmovaps %ymm0, 0x4a0(%rsp)
vmovaps 0x500(%rsp), %ymm0
callq 0x9c620
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %esi
vmovaps %ymm0, 0x480(%rsp)
vmovaps 0x4e0(%rsp), %ymm0
callq 0x9c620
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %esi
vmovaps %ymm0, 0x460(%rsp)
vmovaps 0x4c0(%rsp), %ymm0
callq 0x9c620
vmovaps %ymm0, 0x440(%rsp)
vmovaps 0x4a0(%rsp), %ymm0
vmovaps %ymm0, 0x5aa0(%rsp)
movl $0x14, 0x5a9c(%rsp)
vmovaps 0x5aa0(%rsp), %ymm0
vmovd 0x5a9c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm0
vmovaps %ymm0, 0x420(%rsp)
vmovaps 0x480(%rsp), %ymm0
vmovaps %ymm0, 0x5a60(%rsp)
movl $0x14, 0x5a5c(%rsp)
vmovaps 0x5a60(%rsp), %ymm0
vmovd 0x5a5c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm0
vmovaps %ymm0, 0x400(%rsp)
vmovaps 0x4a0(%rsp), %ymm0
vmovaps %ymm0, 0x5a20(%rsp)
movl $0x8, 0x5a1c(%rsp)
vmovaps 0x5a20(%rsp), %ymm0
vmovd 0x5a1c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4ec0(%rsp)
vmovaps %ymm0, 0x4ea0(%rsp)
vmovaps 0x4ec0(%rsp), %ymm0
vmovaps 0x4ea0(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x3e0(%rsp)
vmovaps 0x480(%rsp), %ymm0
vmovaps %ymm0, 0x59e0(%rsp)
movl $0x8, 0x59dc(%rsp)
vmovaps 0x59e0(%rsp), %ymm0
vmovd 0x59dc(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4e80(%rsp)
vmovaps %ymm0, 0x4e60(%rsp)
vmovaps 0x4e80(%rsp), %ymm0
vmovaps 0x4e60(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x3c0(%rsp)
vmovaps 0x4a0(%rsp), %ymm1
movl $0xff, 0x569c(%rsp)
movl 0x569c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl %eax, 0x56f8(%rsp)
movl %eax, 0x56f4(%rsp)
movl %eax, 0x56f0(%rsp)
movl %eax, 0x56ec(%rsp)
movl %eax, 0x56e8(%rsp)
movl %eax, 0x56e4(%rsp)
movl %eax, 0x56e0(%rsp)
movl %eax, 0x56dc(%rsp)
movl 0x56e0(%rsp), %r8d
movl 0x56e4(%rsp), %edi
movl 0x56e8(%rsp), %esi
movl 0x56f0(%rsp), %edx
movl 0x56f4(%rsp), %ecx
movl 0x56f8(%rsp), %eax
vmovd 0x56dc(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x56ec(%rsp), %xmm2
vpinsrd $0x1, %edx, %xmm2, %xmm2
vpinsrd $0x2, %ecx, %xmm2, %xmm2
vpinsrd $0x3, %eax, %xmm2, %xmm2
vmovdqa %xmm2, 0x56b0(%rsp)
vmovdqa %xmm0, 0x56a0(%rsp)
vmovaps 0x56a0(%rsp), %ymm0
vmovaps %ymm1, 0x4e40(%rsp)
vmovaps %ymm0, 0x4e20(%rsp)
vmovaps 0x4e40(%rsp), %ymm0
vmovaps 0x4e20(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x3a0(%rsp)
vmovaps 0x480(%rsp), %ymm1
movl $0xff, 0x563c(%rsp)
movl 0x563c(%rsp), %eax
movl %eax, 0x38(%rsp)
movl %eax, 0x5698(%rsp)
movl %eax, 0x5694(%rsp)
movl %eax, 0x5690(%rsp)
movl %eax, 0x568c(%rsp)
movl %eax, 0x5688(%rsp)
movl %eax, 0x5684(%rsp)
movl %eax, 0x5680(%rsp)
movl %eax, 0x567c(%rsp)
movl 0x5680(%rsp), %r8d
movl 0x5684(%rsp), %edi
movl 0x5688(%rsp), %esi
movl 0x5690(%rsp), %edx
movl 0x5694(%rsp), %ecx
movl 0x5698(%rsp), %eax
vmovd 0x567c(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x568c(%rsp), %xmm2
vpinsrd $0x1, %edx, %xmm2, %xmm2
vpinsrd $0x2, %ecx, %xmm2, %xmm2
vpinsrd $0x3, %eax, %xmm2, %xmm2
vmovdqa %xmm2, 0x5650(%rsp)
vmovdqa %xmm0, 0x5640(%rsp)
vmovaps 0x5640(%rsp), %ymm0
vmovaps %ymm1, 0x4e00(%rsp)
vmovaps %ymm0, 0x4de0(%rsp)
vmovaps 0x4e00(%rsp), %ymm0
vmovaps 0x4de0(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x380(%rsp)
vmovaps 0x5a0(%rsp), %ymm0
vmovaps %ymm0, 0x59a0(%rsp)
movl $0xc, 0x599c(%rsp)
vmovaps 0x59a0(%rsp), %ymm0
vmovd 0x599c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x420(%rsp), %ymm0
vmovaps %ymm1, 0x5d20(%rsp)
vmovaps %ymm0, 0x5d00(%rsp)
vmovaps 0x5d20(%rsp), %ymm0
vmovaps 0x5d00(%rsp), %ymm1
vpmulld %ymm1, %ymm0, %ymm1
vmovaps 0x3e0(%rsp), %ymm0
vmovaps %ymm1, 0x5e20(%rsp)
vmovaps %ymm0, 0x5e00(%rsp)
vmovaps 0x5e20(%rsp), %ymm0
vmovaps 0x5e00(%rsp), %ymm1
vpaddd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x5a0(%rsp)
vmovaps 0x580(%rsp), %ymm0
vmovaps %ymm0, 0x5960(%rsp)
movl $0xc, 0x595c(%rsp)
vmovaps 0x5960(%rsp), %ymm0
vmovd 0x595c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x400(%rsp), %ymm0
vmovaps %ymm1, 0x5ce0(%rsp)
vmovaps %ymm0, 0x5cc0(%rsp)
vmovaps 0x5ce0(%rsp), %ymm0
vmovaps 0x5cc0(%rsp), %ymm1
vpmulld %ymm1, %ymm0, %ymm1
vmovaps 0x3c0(%rsp), %ymm0
vmovaps %ymm1, 0x5de0(%rsp)
vmovaps %ymm0, 0x5dc0(%rsp)
vmovaps 0x5de0(%rsp), %ymm0
vmovaps 0x5dc0(%rsp), %ymm1
vpaddd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x580(%rsp)
vmovaps 0x3a0(%rsp), %ymm1
vmovaps 0x380(%rsp), %ymm0
vmovaps %ymm1, 0x57a0(%rsp)
vmovaps %ymm0, 0x5780(%rsp)
vmovaps 0x57a0(%rsp), %ymm0
vmovaps 0x5780(%rsp), %ymm1
vpackusdw %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x3a0(%rsp)
vmovaps 0x3a0(%rsp), %ymm0
vpermq $0xd8, %ymm0, %ymm0     # ymm0 = ymm0[0,2,1,3]
vmovdqa %ymm0, 0x3a0(%rsp)
movq 0x678(%rsp), %rax
cmpq 0x4b40(%rsp), %rax
jbe 0x9ac79
leaq 0x5f0(%rsp), %rdi
movq 0x678(%rsp), %rsi
movq 0x4b40(%rsp), %rdx
addq $0x40, %rdx
movq 0x678(%rsp), %rax
subq %rax, %rdx
vzeroupper
callq 0x4810
leaq 0x5f0(%rsp), %rax
movq %rax, 0x678(%rsp)
leaq 0x5f0(%rsp), %rax
addq $0x80, %rax
addq $-0x40, %rax
movq %rax, 0x4b40(%rsp)
movq 0x678(%rsp), %rax
movq %rax, 0x4bd8(%rsp)
movq 0x4bd8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x5f70(%rsp)
vpmovzxwd 0x5f70(%rsp), %ymm0
vmovaps %ymm0, 0x360(%rsp)
vmovaps 0x3a0(%rsp), %ymm0
vmovaps %ymm0, 0x5fe0(%rsp)
vmovaps %ymm0, 0x5fc0(%rsp)
vmovaps 0x5fe0(%rsp), %ymm0
vmovaps 0x5fc0(%rsp), %ymm1
vpackuswb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x3a0(%rsp)
movl $0x80008000, 0x55dc(%rsp) # imm = 0x80008000
movl 0x55dc(%rsp), %eax
movl %eax, (%rsp)
movl %eax, 0x5638(%rsp)
movl %eax, 0x5634(%rsp)
movl %eax, 0x5630(%rsp)
movl %eax, 0x562c(%rsp)
movl %eax, 0x5628(%rsp)
movl %eax, 0x5624(%rsp)
movl %eax, 0x5620(%rsp)
movl %eax, 0x561c(%rsp)
movl 0x5620(%rsp), %r8d
movl 0x5624(%rsp), %edi
movl 0x5628(%rsp), %esi
movl 0x5630(%rsp), %edx
movl 0x5634(%rsp), %ecx
movl 0x5638(%rsp), %eax
vmovd 0x561c(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x562c(%rsp), %xmm1
vpinsrd $0x1, %edx, %xmm1, %xmm1
vpinsrd $0x2, %ecx, %xmm1, %xmm1
vpinsrd $0x3, %eax, %xmm1, %xmm1
vmovdqa %xmm1, 0x55f0(%rsp)
vmovdqa %xmm0, 0x55e0(%rsp)
vmovaps 0x55e0(%rsp), %ymm1
vmovaps 0x5a0(%rsp), %ymm2
movl $0x80000000, 0x557c(%rsp) # imm = 0x80000000
movl 0x557c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl %eax, 0x55d8(%rsp)
movl %eax, 0x55d4(%rsp)
movl %eax, 0x55d0(%rsp)
movl %eax, 0x55cc(%rsp)
movl %eax, 0x55c8(%rsp)
movl %eax, 0x55c4(%rsp)
movl %eax, 0x55c0(%rsp)
movl %eax, 0x55bc(%rsp)
movl 0x55c0(%rsp), %r8d
movl 0x55c4(%rsp), %edi
movl 0x55c8(%rsp), %esi
movl 0x55d0(%rsp), %edx
movl 0x55d4(%rsp), %ecx
movl 0x55d8(%rsp), %eax
vmovd 0x55bc(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x55cc(%rsp), %xmm3
vpinsrd $0x1, %edx, %xmm3, %xmm3
vpinsrd $0x2, %ecx, %xmm3, %xmm3
vpinsrd $0x3, %eax, %xmm3, %xmm3
vmovdqa %xmm3, 0x5590(%rsp)
vmovdqa %xmm0, 0x5580(%rsp)
vmovaps 0x5580(%rsp), %ymm0
vmovaps %ymm2, 0x60e0(%rsp)
vmovaps %ymm0, 0x60c0(%rsp)
vmovaps 0x60e0(%rsp), %ymm0
vmovaps 0x60c0(%rsp), %ymm2
vpxor %ymm2, %ymm0, %ymm0
vmovaps %ymm1, 0x50c0(%rsp)
vmovaps %ymm0, 0x50a0(%rsp)
vmovaps 0x50c0(%rsp), %ymm0
vmovaps 0x50a0(%rsp), %ymm1
vpcmpgtd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x340(%rsp)
movl $0x80008000, 0x551c(%rsp) # imm = 0x80008000
movl 0x551c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl %eax, 0x5578(%rsp)
movl %eax, 0x5574(%rsp)
movl %eax, 0x5570(%rsp)
movl %eax, 0x556c(%rsp)
movl %eax, 0x5568(%rsp)
movl %eax, 0x5564(%rsp)
movl %eax, 0x5560(%rsp)
movl %eax, 0x555c(%rsp)
movl 0x5560(%rsp), %r8d
movl 0x5564(%rsp), %edi
movl 0x5568(%rsp), %esi
movl 0x5570(%rsp), %edx
movl 0x5574(%rsp), %ecx
movl 0x5578(%rsp), %eax
vmovd 0x555c(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x556c(%rsp), %xmm1
vpinsrd $0x1, %edx, %xmm1, %xmm1
vpinsrd $0x2, %ecx, %xmm1, %xmm1
vpinsrd $0x3, %eax, %xmm1, %xmm1
vmovdqa %xmm1, 0x5530(%rsp)
vmovdqa %xmm0, 0x5520(%rsp)
vmovaps 0x5520(%rsp), %ymm1
vmovaps 0x580(%rsp), %ymm2
movl $0x80000000, 0x54bc(%rsp) # imm = 0x80000000
movl 0x54bc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl %eax, 0x5518(%rsp)
movl %eax, 0x5514(%rsp)
movl %eax, 0x5510(%rsp)
movl %eax, 0x550c(%rsp)
movl %eax, 0x5508(%rsp)
movl %eax, 0x5504(%rsp)
movl %eax, 0x5500(%rsp)
movl %eax, 0x54fc(%rsp)
movl 0x5500(%rsp), %r8d
movl 0x5504(%rsp), %edi
movl 0x5508(%rsp), %esi
movl 0x5510(%rsp), %edx
movl 0x5514(%rsp), %ecx
movl 0x5518(%rsp), %eax
vmovd 0x54fc(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x550c(%rsp), %xmm3
vpinsrd $0x1, %edx, %xmm3, %xmm3
vpinsrd $0x2, %ecx, %xmm3, %xmm3
vpinsrd $0x3, %eax, %xmm3, %xmm3
vmovdqa %xmm3, 0x54d0(%rsp)
vmovdqa %xmm0, 0x54c0(%rsp)
vmovaps 0x54c0(%rsp), %ymm0
vmovaps %ymm2, 0x60a0(%rsp)
vmovaps %ymm0, 0x6080(%rsp)
vmovaps 0x60a0(%rsp), %ymm0
vmovaps 0x6080(%rsp), %ymm2
vpxor %ymm2, %ymm0, %ymm0
vmovaps %ymm1, 0x5080(%rsp)
vmovaps %ymm0, 0x5060(%rsp)
vmovaps 0x5080(%rsp), %ymm0
vmovaps 0x5060(%rsp), %ymm1
vpcmpgtd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x320(%rsp)
vmovaps 0x340(%rsp), %ymm0
vmovaps %ymm0, 0x5140(%rsp)
vmovaps 0x5140(%rsp), %ymm0
vmovmskps %ymm0, %eax
movl %eax, 0x31c(%rsp)
movl 0x31c(%rsp), %eax
movl %eax, %edx
shlq $0x5, %rdx
leaq 0x74ad0(%rip), %rax     # 0x10fbe0
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x4b98(%rsp)
movq 0x4b98(%rsp), %rcx
vmovaps (%rcx), %ymm0
vmovaps %ymm0, 0x2e0(%rsp)
vmovaps 0x5a0(%rsp), %ymm0
vmovaps %ymm0, 0x61e0(%rsp)
movl $0x10, 0x61dc(%rsp)
vmovaps 0x61e0(%rsp), %ymm0
vmovd 0x61dc(%rsp), %xmm1
vpslld %xmm1, %ymm0, %ymm0
vmovaps %ymm0, 0x2c0(%rsp)
vmovaps 0x360(%rsp), %ymm1
vmovaps 0x2e0(%rsp), %ymm0
vmovaps %ymm1, 0x5240(%rsp)
vmovaps %ymm0, 0x5220(%rsp)
vmovaps 0x5240(%rsp), %ymm1
vmovaps 0x5220(%rsp), %ymm0
vpermd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x360(%rsp)
vmovaps 0x580(%rsp), %ymm0
vmovaps %ymm0, 0x61a0(%rsp)
movl $0x10, 0x619c(%rsp)
vmovaps 0x61a0(%rsp), %ymm0
vmovd 0x619c(%rsp), %xmm1
vpslld %xmm1, %ymm0, %ymm0
vmovaps %ymm0, 0x2a0(%rsp)
vmovaps 0x320(%rsp), %ymm0
vmovaps %ymm0, 0x5120(%rsp)
vmovaps 0x5120(%rsp), %ymm0
vmovmskps %ymm0, %ecx
movl %ecx, 0x29c(%rsp)
movl 0x31c(%rsp), %ecx
movl %ecx, 0x57d8(%rsp)
popcntl 0x57d8(%rsp), %edx
movq 0x678(%rsp), %rcx
leaq (%rcx,%rdx,2), %rcx
movq %rcx, 0x678(%rsp)
movl 0x29c(%rsp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x4b90(%rsp)
movq 0x4b90(%rsp), %rax
vmovaps (%rax), %ymm0
vmovaps %ymm0, 0x260(%rsp)
movq 0x678(%rsp), %rax
movq %rax, 0x4bd0(%rsp)
movq 0x4bd0(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x5f60(%rsp)
vpmovzxwd 0x5f60(%rsp), %ymm0
vmovaps %ymm0, 0x240(%rsp)
movl 0x29c(%rsp), %eax
movl %eax, 0x57d4(%rsp)
popcntl 0x57d4(%rsp), %ecx
movq 0x678(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x678(%rsp)
vmovaps 0x2c0(%rsp), %ymm1
vmovaps 0x360(%rsp), %ymm0
vmovaps %ymm1, 0x4cc0(%rsp)
vmovaps %ymm0, 0x4ca0(%rsp)
vmovaps 0x4cc0(%rsp), %ymm0
vmovaps 0x4ca0(%rsp), %ymm1
vpor %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x2c0(%rsp)
vmovaps 0x240(%rsp), %ymm1
vmovaps 0x260(%rsp), %ymm0
vmovaps %ymm1, 0x5200(%rsp)
vmovaps %ymm0, 0x51e0(%rsp)
vmovaps 0x5200(%rsp), %ymm1
vmovaps 0x51e0(%rsp), %ymm0
vpermd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x240(%rsp)
vmovaps 0x2a0(%rsp), %ymm1
vmovaps 0x240(%rsp), %ymm0
vmovaps %ymm1, 0x4c80(%rsp)
vmovaps %ymm0, 0x4c60(%rsp)
vmovaps 0x4c80(%rsp), %ymm0
vmovaps 0x4c60(%rsp), %ymm1
vpor %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x2a0(%rsp)
vmovaps 0x5a0(%rsp), %ymm2
vmovaps 0x2c0(%rsp), %ymm1
vmovaps 0x340(%rsp), %ymm0
vmovaps %ymm2, 0x5c20(%rsp)
vmovaps %ymm1, 0x5c00(%rsp)
vmovaps %ymm0, 0x5be0(%rsp)
vmovaps 0x5c20(%rsp), %ymm0
vmovaps 0x5c00(%rsp), %ymm1
vmovaps 0x5be0(%rsp), %ymm2
vpblendvb %ymm2, %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x5a0(%rsp)
vmovaps 0x580(%rsp), %ymm2
vmovaps 0x2a0(%rsp), %ymm1
vmovaps 0x320(%rsp), %ymm0
vmovaps %ymm2, 0x5bc0(%rsp)
vmovaps %ymm1, 0x5ba0(%rsp)
vmovaps %ymm0, 0x5b80(%rsp)
vmovaps 0x5bc0(%rsp), %ymm0
vmovaps 0x5ba0(%rsp), %ymm1
vmovaps 0x5b80(%rsp), %ymm2
vpblendvb %ymm2, %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x580(%rsp)
vmovaps 0x460(%rsp), %ymm0
vmovaps %ymm0, 0x5920(%rsp)
movl $0x14, 0x591c(%rsp)
vmovaps 0x5920(%rsp), %ymm0
vmovd 0x591c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm0
vmovaps %ymm0, 0x220(%rsp)
vmovaps 0x440(%rsp), %ymm0
vmovaps %ymm0, 0x58e0(%rsp)
movl $0x14, 0x58dc(%rsp)
vmovaps 0x58e0(%rsp), %ymm0
vmovd 0x58dc(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm0
vmovaps %ymm0, 0x200(%rsp)
vmovaps 0x460(%rsp), %ymm0
vmovaps %ymm0, 0x58a0(%rsp)
movl $0x8, 0x589c(%rsp)
vmovaps 0x58a0(%rsp), %ymm0
vmovd 0x589c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4dc0(%rsp)
vmovaps %ymm0, 0x4da0(%rsp)
vmovaps 0x4dc0(%rsp), %ymm0
vmovaps 0x4da0(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x1e0(%rsp)
vmovaps 0x440(%rsp), %ymm0
vmovaps %ymm0, 0x5860(%rsp)
movl $0x8, 0x585c(%rsp)
vmovaps 0x5860(%rsp), %ymm0
vmovd 0x585c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x5c0(%rsp), %ymm0
vmovaps %ymm1, 0x4d80(%rsp)
vmovaps %ymm0, 0x4d60(%rsp)
vmovaps 0x4d80(%rsp), %ymm0
vmovaps 0x4d60(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x1c0(%rsp)
vmovaps 0x460(%rsp), %ymm1
movl $0xff, 0x545c(%rsp)
movl 0x545c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x54b8(%rsp)
movl %eax, 0x54b4(%rsp)
movl %eax, 0x54b0(%rsp)
movl %eax, 0x54ac(%rsp)
movl %eax, 0x54a8(%rsp)
movl %eax, 0x54a4(%rsp)
movl %eax, 0x54a0(%rsp)
movl %eax, 0x549c(%rsp)
movl 0x54a0(%rsp), %r8d
movl 0x54a4(%rsp), %edi
movl 0x54a8(%rsp), %esi
movl 0x54b0(%rsp), %edx
movl 0x54b4(%rsp), %ecx
movl 0x54b8(%rsp), %eax
vmovd 0x549c(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x54ac(%rsp), %xmm2
vpinsrd $0x1, %edx, %xmm2, %xmm2
vpinsrd $0x2, %ecx, %xmm2, %xmm2
vpinsrd $0x3, %eax, %xmm2, %xmm2
vmovdqa %xmm2, 0x5470(%rsp)
vmovdqa %xmm0, 0x5460(%rsp)
vmovaps 0x5460(%rsp), %ymm0
vmovaps %ymm1, 0x4d40(%rsp)
vmovaps %ymm0, 0x4d20(%rsp)
vmovaps 0x4d40(%rsp), %ymm0
vmovaps 0x4d20(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x1a0(%rsp)
vmovaps 0x440(%rsp), %ymm1
movl $0xff, 0x53fc(%rsp)
movl 0x53fc(%rsp), %eax
movl %eax, 0x14(%rsp)
movl %eax, 0x5458(%rsp)
movl %eax, 0x5454(%rsp)
movl %eax, 0x5450(%rsp)
movl %eax, 0x544c(%rsp)
movl %eax, 0x5448(%rsp)
movl %eax, 0x5444(%rsp)
movl %eax, 0x5440(%rsp)
movl %eax, 0x543c(%rsp)
movl 0x5440(%rsp), %r8d
movl 0x5444(%rsp), %edi
movl 0x5448(%rsp), %esi
movl 0x5450(%rsp), %edx
movl 0x5454(%rsp), %ecx
movl 0x5458(%rsp), %eax
vmovd 0x543c(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x544c(%rsp), %xmm2
vpinsrd $0x1, %edx, %xmm2, %xmm2
vpinsrd $0x2, %ecx, %xmm2, %xmm2
vpinsrd $0x3, %eax, %xmm2, %xmm2
vmovdqa %xmm2, 0x5410(%rsp)
vmovdqa %xmm0, 0x5400(%rsp)
vmovaps 0x5400(%rsp), %ymm0
vmovaps %ymm1, 0x4d00(%rsp)
vmovaps %ymm0, 0x4ce0(%rsp)
vmovaps 0x4d00(%rsp), %ymm0
vmovaps 0x4ce0(%rsp), %ymm1
vpand %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x180(%rsp)
vmovaps 0x560(%rsp), %ymm0
vmovaps %ymm0, 0x5820(%rsp)
movl $0xc, 0x581c(%rsp)
vmovaps 0x5820(%rsp), %ymm0
vmovd 0x581c(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x220(%rsp), %ymm0
vmovaps %ymm1, 0x5ca0(%rsp)
vmovaps %ymm0, 0x5c80(%rsp)
vmovaps 0x5ca0(%rsp), %ymm0
vmovaps 0x5c80(%rsp), %ymm1
vpmulld %ymm1, %ymm0, %ymm1
vmovaps 0x1e0(%rsp), %ymm0
vmovaps %ymm1, 0x5da0(%rsp)
vmovaps %ymm0, 0x5d80(%rsp)
vmovaps 0x5da0(%rsp), %ymm0
vmovaps 0x5d80(%rsp), %ymm1
vpaddd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x560(%rsp)
vmovaps 0x540(%rsp), %ymm0
vmovaps %ymm0, 0x57e0(%rsp)
movl $0xc, 0x57dc(%rsp)
vmovaps 0x57e0(%rsp), %ymm0
vmovd 0x57dc(%rsp), %xmm1
vpsrld %xmm1, %ymm0, %ymm1
vmovaps 0x200(%rsp), %ymm0
vmovaps %ymm1, 0x5c60(%rsp)
vmovaps %ymm0, 0x5c40(%rsp)
vmovaps 0x5c60(%rsp), %ymm0
vmovaps 0x5c40(%rsp), %ymm1
vpmulld %ymm1, %ymm0, %ymm1
vmovaps 0x1c0(%rsp), %ymm0
vmovaps %ymm1, 0x5d60(%rsp)
vmovaps %ymm0, 0x5d40(%rsp)
vmovaps 0x5d60(%rsp), %ymm0
vmovaps 0x5d40(%rsp), %ymm1
vpaddd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x540(%rsp)
vmovaps 0x1a0(%rsp), %ymm1
vmovaps 0x180(%rsp), %ymm0
vmovaps %ymm1, 0x5760(%rsp)
vmovaps %ymm0, 0x5740(%rsp)
vmovaps 0x5760(%rsp), %ymm0
vmovaps 0x5740(%rsp), %ymm1
vpackusdw %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x1a0(%rsp)
vmovaps 0x1a0(%rsp), %ymm0
vpermq $0xd8, %ymm0, %ymm0     # ymm0 = ymm0[0,2,1,3]
vmovaps %ymm0, 0x1a0(%rsp)
movl $0x80008000, 0x539c(%rsp) # imm = 0x80008000
movl 0x539c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl %eax, 0x53f8(%rsp)
movl %eax, 0x53f4(%rsp)
movl %eax, 0x53f0(%rsp)
movl %eax, 0x53ec(%rsp)
movl %eax, 0x53e8(%rsp)
movl %eax, 0x53e4(%rsp)
movl %eax, 0x53e0(%rsp)
movl %eax, 0x53dc(%rsp)
movl 0x53e0(%rsp), %r8d
movl 0x53e4(%rsp), %edi
movl 0x53e8(%rsp), %esi
movl 0x53f0(%rsp), %edx
movl 0x53f4(%rsp), %ecx
movl 0x53f8(%rsp), %eax
vmovd 0x53dc(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x53ec(%rsp), %xmm1
vpinsrd $0x1, %edx, %xmm1, %xmm1
vpinsrd $0x2, %ecx, %xmm1, %xmm1
vpinsrd $0x3, %eax, %xmm1, %xmm1
vmovdqa %xmm1, 0x53b0(%rsp)
vmovdqa %xmm0, 0x53a0(%rsp)
vmovaps 0x53a0(%rsp), %ymm1
vmovaps 0x560(%rsp), %ymm2
movl $0x80000000, 0x533c(%rsp) # imm = 0x80000000
movl 0x533c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl %eax, 0x5398(%rsp)
movl %eax, 0x5394(%rsp)
movl %eax, 0x5390(%rsp)
movl %eax, 0x538c(%rsp)
movl %eax, 0x5388(%rsp)
movl %eax, 0x5384(%rsp)
movl %eax, 0x5380(%rsp)
movl %eax, 0x537c(%rsp)
movl 0x5380(%rsp), %r8d
movl 0x5384(%rsp), %edi
movl 0x5388(%rsp), %esi
movl 0x5390(%rsp), %edx
movl 0x5394(%rsp), %ecx
movl 0x5398(%rsp), %eax
vmovd 0x537c(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x538c(%rsp), %xmm3
vpinsrd $0x1, %edx, %xmm3, %xmm3
vpinsrd $0x2, %ecx, %xmm3, %xmm3
vpinsrd $0x3, %eax, %xmm3, %xmm3
vmovdqa %xmm3, 0x5350(%rsp)
vmovdqa %xmm0, 0x5340(%rsp)
vmovaps 0x5340(%rsp), %ymm0
vmovaps %ymm2, 0x6060(%rsp)
vmovaps %ymm0, 0x6040(%rsp)
vmovaps 0x6060(%rsp), %ymm0
vmovaps 0x6040(%rsp), %ymm2
vpxor %ymm2, %ymm0, %ymm0
vmovaps %ymm1, 0x5040(%rsp)
vmovaps %ymm0, 0x5020(%rsp)
vmovaps 0x5040(%rsp), %ymm0
vmovaps 0x5020(%rsp), %ymm1
vpcmpgtd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x160(%rsp)
vmovaps 0x1a0(%rsp), %ymm0
vmovaps %ymm0, 0x5fa0(%rsp)
vmovaps %ymm0, 0x5f80(%rsp)
vmovaps 0x5fa0(%rsp), %ymm0
vmovaps 0x5f80(%rsp), %ymm1
vpackuswb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x1a0(%rsp)
movl $0x80008000, 0x52dc(%rsp) # imm = 0x80008000
movl 0x52dc(%rsp), %eax
movl %eax, 0x20(%rsp)
movl %eax, 0x5338(%rsp)
movl %eax, 0x5334(%rsp)
movl %eax, 0x5330(%rsp)
movl %eax, 0x532c(%rsp)
movl %eax, 0x5328(%rsp)
movl %eax, 0x5324(%rsp)
movl %eax, 0x5320(%rsp)
movl %eax, 0x531c(%rsp)
movl 0x5320(%rsp), %r8d
movl 0x5324(%rsp), %edi
movl 0x5328(%rsp), %esi
movl 0x5330(%rsp), %edx
movl 0x5334(%rsp), %ecx
movl 0x5338(%rsp), %eax
vmovd 0x531c(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x532c(%rsp), %xmm1
vpinsrd $0x1, %edx, %xmm1, %xmm1
vpinsrd $0x2, %ecx, %xmm1, %xmm1
vpinsrd $0x3, %eax, %xmm1, %xmm1
vmovdqa %xmm1, 0x52f0(%rsp)
vmovdqa %xmm0, 0x52e0(%rsp)
vmovaps 0x52e0(%rsp), %ymm1
vmovaps 0x540(%rsp), %ymm2
movl $0x80000000, 0x527c(%rsp) # imm = 0x80000000
movl 0x527c(%rsp), %eax
movl %eax, 0x24(%rsp)
movl %eax, 0x52d8(%rsp)
movl %eax, 0x52d4(%rsp)
movl %eax, 0x52d0(%rsp)
movl %eax, 0x52cc(%rsp)
movl %eax, 0x52c8(%rsp)
movl %eax, 0x52c4(%rsp)
movl %eax, 0x52c0(%rsp)
movl %eax, 0x52bc(%rsp)
movl 0x52c0(%rsp), %r8d
movl 0x52c4(%rsp), %edi
movl 0x52c8(%rsp), %esi
movl 0x52d0(%rsp), %edx
movl 0x52d4(%rsp), %ecx
movl 0x52d8(%rsp), %eax
vmovd 0x52bc(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x52cc(%rsp), %xmm3
vpinsrd $0x1, %edx, %xmm3, %xmm3
vpinsrd $0x2, %ecx, %xmm3, %xmm3
vpinsrd $0x3, %eax, %xmm3, %xmm3
vmovdqa %xmm3, 0x5290(%rsp)
vmovdqa %xmm0, 0x5280(%rsp)
vmovaps 0x5280(%rsp), %ymm0
vmovaps %ymm2, 0x6020(%rsp)
vmovaps %ymm0, 0x6000(%rsp)
vmovaps 0x6020(%rsp), %ymm0
vmovaps 0x6000(%rsp), %ymm2
vpxor %ymm2, %ymm0, %ymm0
vmovaps %ymm1, 0x5000(%rsp)
vmovaps %ymm0, 0x4fe0(%rsp)
vmovaps 0x5000(%rsp), %ymm0
vmovaps 0x4fe0(%rsp), %ymm1
vpcmpgtd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x140(%rsp)
movq 0x678(%rsp), %rax
movq %rax, 0x4bc8(%rsp)
movq 0x4bc8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x5f50(%rsp)
vpmovzxwd 0x5f50(%rsp), %ymm0
vmovaps %ymm0, 0x120(%rsp)
movq 0x3a0(%rsp), %rdx
movq 0x4b60(%rsp), %rax
movslq 0x4b3c(%rsp), %rcx
movq %rdx, (%rax,%rcx)
movq 0x3b0(%rsp), %rdx
movq 0x4b60(%rsp), %rcx
movslq 0x4b3c(%rsp), %rax
movq %rdx, 0x8(%rax,%rcx)
movq 0x1a0(%rsp), %rdx
movq 0x4b60(%rsp), %rcx
movslq 0x4b3c(%rsp), %rax
movq %rdx, 0x10(%rax,%rcx)
movq 0x1b0(%rsp), %rdx
movq 0x4b60(%rsp), %rax
movl 0x4b3c(%rsp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx)
vmovdqa 0x560(%rsp), %ymm0
vmovdqa %ymm0, 0x6160(%rsp)
movl $0x10, 0x615c(%rsp)
vmovdqa 0x6160(%rsp), %ymm0
movl 0x615c(%rsp), %eax
vmovd %eax, %xmm1
vpslld %xmm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x100(%rsp)
vmovdqa 0x160(%rsp), %ymm0
vmovaps %ymm0, 0x5100(%rsp)
vmovaps 0x5100(%rsp), %ymm0
vmovmskps %ymm0, %eax
movl %eax, 0xfc(%rsp)
movl 0xfc(%rsp), %eax
movl %eax, %ecx
leaq 0x73d4b(%rip), %rax     # 0x10fbe0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x4b88(%rsp)
movq 0x4b88(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0xc0(%rsp)
vmovdqa 0x120(%rsp), %ymm1
vmovdqa 0xc0(%rsp), %ymm0
vmovdqa %ymm1, 0x51c0(%rsp)
vmovdqa %ymm0, 0x51a0(%rsp)
vmovdqa 0x51c0(%rsp), %ymm1
vmovdqa 0x51a0(%rsp), %ymm0
vpermd %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x120(%rsp)
vmovdqa 0x540(%rsp), %ymm0
vmovdqa %ymm0, 0x6120(%rsp)
movl $0x10, 0x611c(%rsp)
vmovdqa 0x6120(%rsp), %ymm0
movl 0x611c(%rsp), %eax
vmovd %eax, %xmm1
vpslld %xmm1, %ymm0, %ymm0
vmovdqa %ymm0, 0xa0(%rsp)
vmovdqa 0x140(%rsp), %ymm0
vmovaps %ymm0, 0x50e0(%rsp)
vmovaps 0x50e0(%rsp), %ymm0
vmovmskps %ymm0, %eax
movl %eax, 0x9c(%rsp)
movl 0xfc(%rsp), %eax
movl %eax, 0x57d0(%rsp)
movl 0x57d0(%rsp), %eax
popcntl %eax, %ecx
movq 0x678(%rsp), %rax
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x678(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, %ecx
leaq 0x73c3d(%rip), %rax     # 0x10fbe0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x4b80(%rsp)
movq 0x4b80(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x60(%rsp)
movq 0x678(%rsp), %rax
movq %rax, 0x4bc0(%rsp)
movq 0x4bc0(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x5f40(%rsp)
vmovdqa 0x5f40(%rsp), %xmm0
vpmovzxwd %xmm0, %ymm0    # ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa 0x100(%rsp), %ymm1
vmovdqa 0x120(%rsp), %ymm0
vmovdqa %ymm1, 0x4c40(%rsp)
vmovdqa %ymm0, 0x4c20(%rsp)
vmovdqa 0x4c40(%rsp), %ymm0
vpor 0x4c20(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x100(%rsp)
vmovdqa 0x40(%rsp), %ymm1
vmovdqa 0x60(%rsp), %ymm0
vmovdqa %ymm1, 0x5180(%rsp)
vmovdqa %ymm0, 0x5160(%rsp)
vmovdqa 0x5180(%rsp), %ymm1
vmovdqa 0x5160(%rsp), %ymm0
vpermd %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa 0xa0(%rsp), %ymm1
vmovdqa 0x40(%rsp), %ymm0
vmovdqa %ymm1, 0x4c00(%rsp)
vmovdqa %ymm0, 0x4be0(%rsp)
vmovdqa 0x4c00(%rsp), %ymm0
vpor 0x4be0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0xa0(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x57cc(%rsp)
movl 0x57cc(%rsp), %eax
popcntl %eax, %ecx
movq 0x678(%rsp), %rax
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x678(%rsp)
vmovdqa 0x560(%rsp), %ymm2
vmovdqa 0x100(%rsp), %ymm1
vmovdqa 0x160(%rsp), %ymm0
vmovdqa %ymm2, 0x5b60(%rsp)
vmovdqa %ymm1, 0x5b40(%rsp)
vmovdqa %ymm0, 0x5b20(%rsp)
vmovdqa 0x5b60(%rsp), %ymm0
vmovdqa 0x5b40(%rsp), %ymm1
vmovdqa 0x5b20(%rsp), %ymm2
vpblendvb %ymm2, %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x560(%rsp)
vmovdqa 0x540(%rsp), %ymm2
vmovdqa 0xa0(%rsp), %ymm1
vmovdqa 0x140(%rsp), %ymm0
vmovdqa %ymm2, 0x5b00(%rsp)
vmovdqa %ymm1, 0x5ae0(%rsp)
vmovdqa %ymm0, 0x5ac0(%rsp)
vmovdqa 0x5b00(%rsp), %ymm0
vmovdqa 0x5ae0(%rsp), %ymm1
vmovdqa 0x5ac0(%rsp), %ymm2
vpblendvb %ymm2, %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x540(%rsp)
movl 0x4b3c(%rsp), %eax
addl $0x20, %eax
movl %eax, 0x4b3c(%rsp)
jmp 0x9a56d
leaq 0x680(%rsp), %rax
vmovdqa 0x5a0(%rsp), %ymm0
movq %rax, 0x5f38(%rsp)
vmovdqa %ymm0, 0x5f00(%rsp)
vmovdqa 0x5f00(%rsp), %ymm0
movq 0x5f38(%rsp), %rax
vmovdqa %ymm0, (%rax)
leaq 0x680(%rsp), %rax
addq $0x20, %rax
vmovdqa 0x580(%rsp), %ymm0
movq %rax, 0x5ef8(%rsp)
vmovdqa %ymm0, 0x5ec0(%rsp)
vmovdqa 0x5ec0(%rsp), %ymm0
movq 0x5ef8(%rsp), %rax
vmovdqa %ymm0, (%rax)
leaq 0x680(%rsp), %rax
addq $0x40, %rax
vmovdqa 0x560(%rsp), %ymm0
movq %rax, 0x5eb8(%rsp)
vmovdqa %ymm0, 0x5e80(%rsp)
vmovdqa 0x5e80(%rsp), %ymm0
movq 0x5eb8(%rsp), %rax
vmovdqa %ymm0, (%rax)
leaq 0x680(%rsp), %rax
addq $0x60, %rax
vmovdqa 0x540(%rsp), %ymm0
movq %rax, 0x5e78(%rsp)
vmovdqa %ymm0, 0x5e40(%rsp)
vmovdqa 0x5e40(%rsp), %ymm0
movq 0x5e78(%rsp), %rax
vmovdqa %ymm0, (%rax)
movl 0x4b5c(%rsp), %eax
andl $0x1f, %eax
movl %eax, 0x714(%rsp)
movl 0x714(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x714(%rsp)
cmpl $0x0, %eax
jle 0x9c309
movslq 0x714(%rsp), %rax
movl 0x680(%rsp,%rax,4), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, %eax
movl 0xb20(%rsp,%rax,4), %eax
movb %al, %dl
movq 0x4b60(%rsp), %rax
movl 0x5ec(%rsp), %ecx
addl 0x714(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x9c2b4
movq 0x4b60(%rsp), %rax
movq %rax, 0x4b78(%rsp)
jmp 0x9c334
movq 0x4b48(%rsp), %rdi
callq 0x45a0
movq $0x0, 0x4b78(%rsp)
movq 0x4b78(%rsp), %rax
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)