// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static32x16pr_sse4.c
// Function: rans_uncompress_O0_32x16_sse4
unsigned char *rans_uncompress_O0_32x16_sse4(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;

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

    __m128i maskv  = _mm_set1_epi32(mask); // set mask in all lanes
    LOAD128(Rv, R);

    uint8_t overflow[72+64] = {0};
    for (i=0; i < out_end; i+=NX) {
        //for (z = 0; z < NX; z++)
        //  m[z] = R[z] & mask;
        __m128i masked1 = _mm_and_si128(Rv1, maskv);
        __m128i masked2 = _mm_and_si128(Rv2, maskv);
        __m128i masked3 = _mm_and_si128(Rv3, maskv);
        __m128i masked4 = _mm_and_si128(Rv4, maskv);

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

        //  f[z] = S[z]>>(TF_SHIFT+8);
        __m128i fv1 = _mm_srli_epi32(Sv1, TF_SHIFT+8);
        __m128i fv2 = _mm_srli_epi32(Sv2, TF_SHIFT+8);
        __m128i fv3 = _mm_srli_epi32(Sv3, TF_SHIFT+8);
        __m128i fv4 = _mm_srli_epi32(Sv4, TF_SHIFT+8);

        //  b[z] = (S[z]>>8) & mask;
        __m128i bv1 = _mm_and_si128(_mm_srli_epi32(Sv1, 8), maskv);
        __m128i bv2 = _mm_and_si128(_mm_srli_epi32(Sv2, 8), maskv);
        __m128i bv3 = _mm_and_si128(_mm_srli_epi32(Sv3, 8), maskv);
        __m128i bv4 = _mm_and_si128(_mm_srli_epi32(Sv4, 8), maskv);

        //  s[z] = S[z] & 0xff;
        __m128i sv1 = _mm_and_si128(Sv1, _mm_set1_epi32(0xff));
        __m128i sv2 = _mm_and_si128(Sv2, _mm_set1_epi32(0xff));
        __m128i sv3 = _mm_and_si128(Sv3, _mm_set1_epi32(0xff));
        __m128i sv4 = _mm_and_si128(Sv4, _mm_set1_epi32(0xff));

        //  R[z] = f[z] * (R[z] >> TF_SHIFT) + b[z];
        Rv1 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv1,TF_SHIFT), fv1), bv1);
        Rv2 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv2,TF_SHIFT), fv2), bv2);
        Rv3 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv3,TF_SHIFT), fv3), bv3);
        Rv4 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv4,TF_SHIFT), fv4), bv4);

        // Tricky one:  out[i+z] = s[z];
        //             ---d---c ---b---a  sv1
        //             ---h---g ---f---e  sv2
        // packs_epi32 -h-g-f-e -d-c-b-a  sv1(2)
        // packs_epi16 ponmlkji hgfedcba  sv1(2) / sv3(4)
        sv1 = _mm_packus_epi32(sv1, sv2);
        sv3 = _mm_packus_epi32(sv3, sv4);
        sv1 = _mm_packus_epi16(sv1, sv3);

        // c =  R[z] < RANS_BYTE_L;
        // A little tricky as we only have signed comparisons.
        // See https://stackoverflow.com/questions/32945410/sse2-intrinsics-comparing-unsigned-integers

#define _mm_cmplt_epu32_imm(a,b) _mm_andnot_si128(_mm_cmpeq_epi32(_mm_max_epu32((a),_mm_set1_epi32(b)), (a)), _mm_set1_epi32(-1));

//#define _mm_cmplt_epu32_imm(a,b) _mm_cmpgt_epi32(_mm_set1_epi32((b)-0x80000000), _mm_xor_si128((a), _mm_set1_epi32(0x80000000)))

        __m128i renorm_mask1, renorm_mask2, renorm_mask3, renorm_mask4;
        renorm_mask1 = _mm_cmplt_epu32_imm(Rv1, RANS_BYTE_L);
        renorm_mask2 = _mm_cmplt_epu32_imm(Rv2, RANS_BYTE_L);
        renorm_mask3 = _mm_cmplt_epu32_imm(Rv3, RANS_BYTE_L);
        renorm_mask4 = _mm_cmplt_epu32_imm(Rv4, RANS_BYTE_L);

//#define P(A,B,C,D) ((A)+((B)<<2) + ((C)<<4) + ((D)<<6))
#define P(A,B,C,D)                              \
        { A+0,A+1,A+2,A+3,                      \
          B+0,B+1,B+2,B+3,                      \
          C+0,C+1,C+2,C+3,                      \
          D+0,D+1,D+2,D+3}
#ifdef _
#undef _
#endif
#define _ 0x80
        uint8_t pidx[16][16] = {
            P(_,_,_,_),
            P(0,_,_,_),
            P(_,0,_,_),
            P(0,4,_,_),

            P(_,_,0,_),
            P(0,_,4,_),
            P(_,0,4,_),
            P(0,4,8,_),

            P(_,_,_,0),
            P(0,_,_,4),
            P(_,0,_,4),
            P(0,4,_,8),

            P(_,_,0,4),
            P(0,_,4,8),
            P(_,0,4,8),
            P(0,4,8,12),
        };
#undef _

        // Protect against running off the end of in buffer.
        // We copy it to a worst-case local buffer when near the end.
        // 72 = 7*8(imask1..7) + 16;  worse case for 8th _mm_loadu_si128 call.
        // An extra 64 bytes is to avoid triggering this multiple times
        // after we swap sp/cp_end over.
        if ((uint8_t *)sp+72 > cp_end) {
            memmove(overflow, sp, cp_end - (uint8_t *)sp);
            sp = (uint16_t *)overflow;
            cp_end = (uint8_t *)overflow + sizeof(overflow);
        }

        // Shuffle the renorm values to correct lanes and incr sp pointer
        __m128i Vv1 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask1 = _mm_movemask_ps((__m128)renorm_mask1);
        Vv1 = _mm_shuffle_epi8(Vv1, _mm_load_si128((__m128i*)pidx[imask1]));
        sp += _mm_popcnt_u32(imask1);

        __m128i Vv2 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask2 = _mm_movemask_ps((__m128)renorm_mask2);
        sp += _mm_popcnt_u32(imask2);
        Vv2 = _mm_shuffle_epi8(Vv2, _mm_load_si128((__m128i*)pidx[imask2]));

        __m128i Vv3 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask3 = _mm_movemask_ps((__m128)renorm_mask3);
        Vv3 = _mm_shuffle_epi8(Vv3, _mm_load_si128((__m128i*)pidx[imask3]));
        sp += _mm_popcnt_u32(imask3);

        __m128i Vv4 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask4 = _mm_movemask_ps((__m128)renorm_mask4);
        sp += _mm_popcnt_u32(imask4);
        Vv4 = _mm_shuffle_epi8(Vv4, _mm_load_si128((__m128i*)pidx[imask4]));

        __m128i Yv1 = _mm_slli_epi32(Rv1, 16);
        __m128i Yv2 = _mm_slli_epi32(Rv2, 16);
        __m128i Yv3 = _mm_slli_epi32(Rv3, 16);
        __m128i Yv4 = _mm_slli_epi32(Rv4, 16);

        // y = (R[z] << 16) | V[z];
        Yv1 = _mm_or_si128(Yv1, Vv1);
        Yv2 = _mm_or_si128(Yv2, Vv2);
        Yv3 = _mm_or_si128(Yv3, Vv3);
        Yv4 = _mm_or_si128(Yv4, Vv4);

        // R[z] = c ? Y[z] : R[z];
        Rv1 = _mm_blendv_epi8(Rv1, Yv1, renorm_mask1);
        Rv2 = _mm_blendv_epi8(Rv2, Yv2, renorm_mask2);
        Rv3 = _mm_blendv_epi8(Rv3, Yv3, renorm_mask3);
        Rv4 = _mm_blendv_epi8(Rv4, Yv4, renorm_mask4);

        // ------------------------------------------------------------

        //  m[z] = R[z] & mask;
        __m128i masked5 = _mm_and_si128(Rv5, maskv);
        __m128i masked6 = _mm_and_si128(Rv6, maskv);
        __m128i masked7 = _mm_and_si128(Rv7, maskv);
        __m128i masked8 = _mm_and_si128(Rv8, maskv);

        //  S[z] = s3[m[z]];
        __m128i Sv5 = _mm_i32gather_epi32x((int *)s3, masked5, sizeof(*s3));
        __m128i Sv6 = _mm_i32gather_epi32x((int *)s3, masked6, sizeof(*s3));
        __m128i Sv7 = _mm_i32gather_epi32x((int *)s3, masked7, sizeof(*s3));
        __m128i Sv8 = _mm_i32gather_epi32x((int *)s3, masked8, sizeof(*s3));

        //  f[z] = S[z]>>(TF_SHIFT+8);
        __m128i fv5 = _mm_srli_epi32(Sv5, TF_SHIFT+8);
        __m128i fv6 = _mm_srli_epi32(Sv6, TF_SHIFT+8);
        __m128i fv7 = _mm_srli_epi32(Sv7, TF_SHIFT+8);
        __m128i fv8 = _mm_srli_epi32(Sv8, TF_SHIFT+8);

        //  b[z] = (S[z]>>8) & mask;
        __m128i bv5 = _mm_and_si128(_mm_srli_epi32(Sv5, 8), maskv);
        __m128i bv6 = _mm_and_si128(_mm_srli_epi32(Sv6, 8), maskv);
        __m128i bv7 = _mm_and_si128(_mm_srli_epi32(Sv7, 8), maskv);
        __m128i bv8 = _mm_and_si128(_mm_srli_epi32(Sv8, 8), maskv);

        //  s[z] = S[z] & 0xff;
        __m128i sv5 = _mm_and_si128(Sv5, _mm_set1_epi32(0xff));
        __m128i sv6 = _mm_and_si128(Sv6, _mm_set1_epi32(0xff));
        __m128i sv7 = _mm_and_si128(Sv7, _mm_set1_epi32(0xff));
        __m128i sv8 = _mm_and_si128(Sv8, _mm_set1_epi32(0xff));

        //  R[z] = f[z] * (R[z] >> TF_SHIFT) + b[z];
        Rv5 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv5,TF_SHIFT), fv5), bv5);
        Rv6 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv6,TF_SHIFT), fv6), bv6);
        Rv7 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv7,TF_SHIFT), fv7), bv7);
        Rv8 = _mm_add_epi32(
                  _mm_mullo_epi32(
                      _mm_srli_epi32(Rv8,TF_SHIFT), fv8), bv8);

        // Tricky one:  out[i+z] = s[z];
        //             ---d---c ---b---a  sv1
        //             ---h---g ---f---e  sv2
        // packs_epi32 -h-g-f-e -d-c-b-a  sv1(2)
        // packs_epi16 ponmlkji hgfedcba  sv1(2) / sv3(4)
        sv5 = _mm_packus_epi32(sv5, sv6);
        sv7 = _mm_packus_epi32(sv7, sv8);
        sv5 = _mm_packus_epi16(sv5, sv7);

        // c =  R[z] < RANS_BYTE_L;
        __m128i renorm_mask5, renorm_mask6, renorm_mask7, renorm_mask8;
        renorm_mask5 = _mm_cmplt_epu32_imm(Rv5, RANS_BYTE_L);
        renorm_mask6 = _mm_cmplt_epu32_imm(Rv6, RANS_BYTE_L);
        renorm_mask7 = _mm_cmplt_epu32_imm(Rv7, RANS_BYTE_L);
        renorm_mask8 = _mm_cmplt_epu32_imm(Rv8, RANS_BYTE_L);
        
        // Shuffle the renorm values to correct lanes and incr sp pointer
        __m128i Vv5 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask5 = _mm_movemask_ps((__m128)renorm_mask5);
        Vv5 = _mm_shuffle_epi8(Vv5, _mm_load_si128((__m128i*)pidx[imask5]));
        sp += _mm_popcnt_u32(imask5);

        __m128i Vv6 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask6 = _mm_movemask_ps((__m128)renorm_mask6);
        sp += _mm_popcnt_u32(imask6);
        Vv6 = _mm_shuffle_epi8(Vv6, _mm_load_si128((__m128i*)pidx[imask6]));

        __m128i Vv7 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask7 = _mm_movemask_ps((__m128)renorm_mask7);
        Vv7 = _mm_shuffle_epi8(Vv7, _mm_load_si128((__m128i*)pidx[imask7]));
        sp += _mm_popcnt_u32(imask7);

        __m128i Vv8 = _mm_cvtepu16_epi32(_mm_loadu_si128((__m128i *)sp));
        unsigned int imask8 = _mm_movemask_ps((__m128)renorm_mask8);
        sp += _mm_popcnt_u32(imask8);
        Vv8 = _mm_shuffle_epi8(Vv8, _mm_load_si128((__m128i*)pidx[imask8]));

        __m128i Yv5 = _mm_slli_epi32(Rv5, 16);
        __m128i Yv6 = _mm_slli_epi32(Rv6, 16);
        __m128i Yv7 = _mm_slli_epi32(Rv7, 16);
        __m128i Yv8 = _mm_slli_epi32(Rv8, 16);

        // y = (R[z] << 16) | V[z];
        Yv5 = _mm_or_si128(Yv5, Vv5);
        Yv6 = _mm_or_si128(Yv6, Vv6);
        Yv7 = _mm_or_si128(Yv7, Vv7);
        Yv8 = _mm_or_si128(Yv8, Vv8);

        // R[z] = c ? Y[z] : R[z];
        Rv5 = _mm_blendv_epi8(Rv5, Yv5, renorm_mask5);
        Rv6 = _mm_blendv_epi8(Rv6, Yv6, renorm_mask6);
        Rv7 = _mm_blendv_epi8(Rv7, Yv7, renorm_mask7);
        Rv8 = _mm_blendv_epi8(Rv8, Yv8, renorm_mask8);

        // Maybe just a store128 instead?
        _mm_storeu_si128((__m128i *)&out[i+ 0], sv1);
        _mm_storeu_si128((__m128i *)&out[i+16], sv5);
//      *(uint64_t *)&out[i+ 0] = _mm_extract_epi64(sv1, 0);
//      *(uint64_t *)&out[i+ 8] = _mm_extract_epi64(sv1, 1);
//      *(uint64_t *)&out[i+16] = _mm_extract_epi64(sv5, 0);
//      *(uint64_t *)&out[i+24] = _mm_extract_epi64(sv5, 1);
    }

    STORE128(Rv, R);

    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 $0x62c0, %rsp           # imm = 0x62C0
movq %rdi, 0x4bb8(%rsp)
movl %esi, 0x4bb4(%rsp)
movq %rdx, 0x4ba8(%rsp)
movl %ecx, 0x4ba4(%rsp)
cmpl $0x10, 0x4bb4(%rsp)
jae 0xb1558
movq $0x0, 0x4bc0(%rsp)
jmp 0xb4810
cmpl $0x7fffffff, 0x4ba4(%rsp) # imm = 0x7FFFFFFF
jb 0xb1576
movq $0x0, 0x4bc0(%rsp)
jmp 0xb4810
movq 0x4bb8(%rsp), %rax
movq %rax, 0x4b98(%rsp)
movq $0x0, 0x4b90(%rsp)
movq 0x4bb8(%rsp), %rax
movl 0x4bb4(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x4b88(%rsp)
cmpq $0x0, 0x4ba8(%rsp)
jne 0xb15d5
movl 0x4ba4(%rsp), %eax
movl %eax, %edi
callq 0x4650
movq %rax, 0x4ba8(%rsp)
movq %rax, 0x4b90(%rsp)
cmpq $0x0, 0x4ba8(%rsp)
jne 0xb15f1
movq $0x0, 0x4bc0(%rsp)
jmp 0xb4810
leaq 0x780(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x4250
movq 0x4b98(%rsp), %rdi
movq 0x4b88(%rsp), %rsi
leaq 0x780(%rsp), %rdx
leaq 0x77c(%rsp), %rcx
callq 0xb4820
movl %eax, 0x778(%rsp)
cmpl $0x0, 0x778(%rsp)
jne 0xb1640
jmp 0xb47f7
movl 0x778(%rsp), %ecx
movq 0x4b98(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x4b98(%rsp)
leaq 0x780(%rsp), %rdi
movl 0x77c(%rsp), %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0xb4910
leaq 0x780(%rsp), %rdi
leaq 0xb80(%rsp), %rdx
movl $0xc, %esi
callq 0xb4990
cmpl $0x0, %eax
je 0xb169a
jmp 0xb47f7
movq 0x4b88(%rsp), %rax
movq 0x4b98(%rsp), %rcx
subq %rcx, %rax
cmpq $0x80, %rax
jge 0xb16ba
jmp 0xb47f7
movl $0x0, 0x774(%rsp)
cmpl $0x20, 0x774(%rsp)
jge 0xb1722
movslq 0x774(%rsp), %rax
leaq 0x6e0(%rsp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
leaq 0x4b98(%rsp), %rsi
callq 0xb4a70
movslq 0x774(%rsp), %rax
cmpl $0x8000, 0x6e0(%rsp,%rax,4) # imm = 0x8000
jae 0xb170d
jmp 0xb47f7
jmp 0xb170f
movl 0x774(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x774(%rsp)
jmp 0xb16c5
movq 0x4b98(%rsp), %rax
movq %rax, 0x6d8(%rsp)
movl 0x4ba4(%rsp), %eax
andl $-0x20, %eax
movl %eax, 0x6d4(%rsp)
movl $0xfff, 0x6d0(%rsp) # imm = 0xFFF
movl $0xfff, 0x4c2c(%rsp) # imm = 0xFFF
movl 0x4c2c(%rsp), %eax
movl %eax, 0x5fac(%rsp)
movl %eax, 0x5fa8(%rsp)
movl %eax, 0x5fa4(%rsp)
movl %eax, 0x5fa0(%rsp)
movl 0x5fa4(%rsp), %edx
movl 0x5fa8(%rsp), %ecx
movl 0x5fac(%rsp), %eax
movd 0x5fa0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movdqa %xmm0, 0x5f90(%rsp)
movdqa 0x5f90(%rsp), %xmm0
movdqa %xmm0, 0x6c0(%rsp)
leaq 0x6e0(%rsp), %rax
movq %rax, 0x4ca8(%rsp)
movq 0x4ca8(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x6b0(%rsp)
leaq 0x6e0(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x4ca0(%rsp)
movq 0x4ca0(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x6a0(%rsp)
leaq 0x6e0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x4c98(%rsp)
movq 0x4c98(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x690(%rsp)
leaq 0x6e0(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x4c90(%rsp)
movq 0x4c90(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x680(%rsp)
leaq 0x6e0(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x4c88(%rsp)
movq 0x4c88(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x670(%rsp)
leaq 0x6e0(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x4c80(%rsp)
movq 0x4c80(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x660(%rsp)
leaq 0x6e0(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x4c78(%rsp)
movq 0x4c78(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x650(%rsp)
leaq 0x6e0(%rsp), %rax
addq $0x70, %rax
movq %rax, 0x4c70(%rsp)
movq 0x4c70(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x640(%rsp)
leaq 0x5b0(%rsp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x4250
movl $0x0, 0x4b84(%rsp)
movl 0x4b84(%rsp), %eax
cmpl 0x6d4(%rsp), %eax
jge 0xb45ab
movaps 0x6b0(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4fa0(%rsp)
movaps %xmm0, 0x4f90(%rsp)
movaps 0x4fa0(%rsp), %xmm0
movaps 0x4f90(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x5a0(%rsp)
movaps 0x6a0(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4f80(%rsp)
movaps %xmm0, 0x4f70(%rsp)
movaps 0x4f80(%rsp), %xmm0
movaps 0x4f70(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x590(%rsp)
movaps 0x690(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4f60(%rsp)
movaps %xmm0, 0x4f50(%rsp)
movaps 0x4f60(%rsp), %xmm0
movaps 0x4f50(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x580(%rsp)
movaps 0x680(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4f40(%rsp)
movaps %xmm0, 0x4f30(%rsp)
movaps 0x4f40(%rsp), %xmm0
movaps 0x4f30(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x570(%rsp)
movaps 0x5a0(%rsp), %xmm0
leaq 0xb80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x4, %esi
movl %esi, 0x2c(%rsp)
callq 0xb4af0
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movaps %xmm0, 0x560(%rsp)
movaps 0x590(%rsp), %xmm0
callq 0xb4af0
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movaps %xmm0, 0x550(%rsp)
movaps 0x580(%rsp), %xmm0
callq 0xb4af0
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movaps %xmm0, 0x540(%rsp)
movaps 0x570(%rsp), %xmm0
callq 0xb4af0
movaps %xmm0, 0x530(%rsp)
movaps 0x560(%rsp), %xmm0
movaps %xmm0, 0x52a0(%rsp)
movl $0x14, 0x529c(%rsp)
movaps 0x52a0(%rsp), %xmm0
movd 0x529c(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x520(%rsp)
movaps 0x550(%rsp), %xmm0
movaps %xmm0, 0x5280(%rsp)
movl $0x14, 0x527c(%rsp)
movaps 0x5280(%rsp), %xmm0
movd 0x527c(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x510(%rsp)
movaps 0x540(%rsp), %xmm0
movaps %xmm0, 0x5260(%rsp)
movl $0x14, 0x525c(%rsp)
movaps 0x5260(%rsp), %xmm0
movd 0x525c(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x500(%rsp)
movaps 0x530(%rsp), %xmm0
movaps %xmm0, 0x5240(%rsp)
movl $0x14, 0x523c(%rsp)
movaps 0x5240(%rsp), %xmm0
movd 0x523c(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x4f0(%rsp)
movaps 0x560(%rsp), %xmm0
movaps %xmm0, 0x5220(%rsp)
movl $0x8, 0x521c(%rsp)
movaps 0x5220(%rsp), %xmm1
movd 0x521c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4f20(%rsp)
movaps %xmm0, 0x4f10(%rsp)
movaps 0x4f20(%rsp), %xmm0
movaps 0x4f10(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x4e0(%rsp)
movaps 0x550(%rsp), %xmm0
movaps %xmm0, 0x5200(%rsp)
movl $0x8, 0x51fc(%rsp)
movaps 0x5200(%rsp), %xmm1
movd 0x51fc(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4f00(%rsp)
movaps %xmm0, 0x4ef0(%rsp)
movaps 0x4f00(%rsp), %xmm0
movaps 0x4ef0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x4d0(%rsp)
movaps 0x540(%rsp), %xmm0
movaps %xmm0, 0x51e0(%rsp)
movl $0x8, 0x51dc(%rsp)
movaps 0x51e0(%rsp), %xmm1
movd 0x51dc(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4ee0(%rsp)
movaps %xmm0, 0x4ed0(%rsp)
movaps 0x4ee0(%rsp), %xmm0
movaps 0x4ed0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x4c0(%rsp)
movaps 0x530(%rsp), %xmm0
movaps %xmm0, 0x51c0(%rsp)
movl $0x8, 0x51bc(%rsp)
movaps 0x51c0(%rsp), %xmm1
movd 0x51bc(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4ec0(%rsp)
movaps %xmm0, 0x4eb0(%rsp)
movaps 0x4ec0(%rsp), %xmm0
movaps 0x4eb0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x4b0(%rsp)
movaps 0x560(%rsp), %xmm1
movl $0xff, 0x4c28(%rsp)
movl 0x4c28(%rsp), %eax
movl %eax, 0x5fcc(%rsp)
movl %eax, 0x5fc8(%rsp)
movl %eax, 0x5fc4(%rsp)
movl %eax, 0x5fc0(%rsp)
movl 0x5fc4(%rsp), %edx
movl 0x5fc8(%rsp), %ecx
movl 0x5fcc(%rsp), %eax
movd 0x5fc0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x5fb0(%rsp)
movaps 0x5fb0(%rsp), %xmm0
movaps %xmm1, 0x4ea0(%rsp)
movaps %xmm0, 0x4e90(%rsp)
movaps 0x4ea0(%rsp), %xmm0
movaps 0x4e90(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x4a0(%rsp)
movaps 0x550(%rsp), %xmm1
movl $0xff, 0x4c24(%rsp)
movl 0x4c24(%rsp), %eax
movl %eax, 0x5fec(%rsp)
movl %eax, 0x5fe8(%rsp)
movl %eax, 0x5fe4(%rsp)
movl %eax, 0x5fe0(%rsp)
movl 0x5fe4(%rsp), %edx
movl 0x5fe8(%rsp), %ecx
movl 0x5fec(%rsp), %eax
movd 0x5fe0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x5fd0(%rsp)
movaps 0x5fd0(%rsp), %xmm0
movaps %xmm1, 0x4e80(%rsp)
movaps %xmm0, 0x4e70(%rsp)
movaps 0x4e80(%rsp), %xmm0
movaps 0x4e70(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x490(%rsp)
movaps 0x540(%rsp), %xmm1
movl $0xff, 0x4c20(%rsp)
movl 0x4c20(%rsp), %eax
movl %eax, 0x600c(%rsp)
movl %eax, 0x6008(%rsp)
movl %eax, 0x6004(%rsp)
movl %eax, 0x6000(%rsp)
movl 0x6004(%rsp), %edx
movl 0x6008(%rsp), %ecx
movl 0x600c(%rsp), %eax
movd 0x6000(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x5ff0(%rsp)
movaps 0x5ff0(%rsp), %xmm0
movaps %xmm1, 0x4e60(%rsp)
movaps %xmm0, 0x4e50(%rsp)
movaps 0x4e60(%rsp), %xmm0
movaps 0x4e50(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x480(%rsp)
movaps 0x530(%rsp), %xmm1
movl $0xff, 0x4c1c(%rsp)
movl 0x4c1c(%rsp), %eax
movl %eax, 0x602c(%rsp)
movl %eax, 0x6028(%rsp)
movl %eax, 0x6024(%rsp)
movl %eax, 0x6020(%rsp)
movl 0x6024(%rsp), %edx
movl 0x6028(%rsp), %ecx
movl 0x602c(%rsp), %eax
movd 0x6020(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6010(%rsp)
movaps 0x6010(%rsp), %xmm0
movaps %xmm1, 0x4e40(%rsp)
movaps %xmm0, 0x4e30(%rsp)
movaps 0x4e40(%rsp), %xmm0
movaps 0x4e30(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x470(%rsp)
movaps 0x6b0(%rsp), %xmm0
movaps %xmm0, 0x51a0(%rsp)
movl $0xc, 0x519c(%rsp)
movaps 0x51a0(%rsp), %xmm1
movd 0x519c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x520(%rsp), %xmm0
movaps %xmm1, 0x54a0(%rsp)
movaps %xmm0, 0x5490(%rsp)
movaps 0x54a0(%rsp), %xmm1
movaps 0x5490(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x4e0(%rsp), %xmm0
movaps %xmm1, 0x53a0(%rsp)
movaps %xmm0, 0x5390(%rsp)
movaps 0x53a0(%rsp), %xmm0
movaps 0x5390(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x6b0(%rsp)
movaps 0x6a0(%rsp), %xmm0
movaps %xmm0, 0x5180(%rsp)
movl $0xc, 0x517c(%rsp)
movaps 0x5180(%rsp), %xmm1
movd 0x517c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x510(%rsp), %xmm0
movaps %xmm1, 0x5480(%rsp)
movaps %xmm0, 0x5470(%rsp)
movaps 0x5480(%rsp), %xmm1
movaps 0x5470(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x4d0(%rsp), %xmm0
movaps %xmm1, 0x5380(%rsp)
movaps %xmm0, 0x5370(%rsp)
movaps 0x5380(%rsp), %xmm0
movaps 0x5370(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x6a0(%rsp)
movaps 0x690(%rsp), %xmm0
movaps %xmm0, 0x5160(%rsp)
movl $0xc, 0x515c(%rsp)
movaps 0x5160(%rsp), %xmm1
movd 0x515c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x500(%rsp), %xmm0
movaps %xmm1, 0x5460(%rsp)
movaps %xmm0, 0x5450(%rsp)
movaps 0x5460(%rsp), %xmm1
movaps 0x5450(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x4c0(%rsp), %xmm0
movaps %xmm1, 0x5360(%rsp)
movaps %xmm0, 0x5350(%rsp)
movaps 0x5360(%rsp), %xmm0
movaps 0x5350(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x690(%rsp)
movaps 0x680(%rsp), %xmm0
movaps %xmm0, 0x5140(%rsp)
movl $0xc, 0x513c(%rsp)
movaps 0x5140(%rsp), %xmm1
movd 0x513c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x4f0(%rsp), %xmm0
movaps %xmm1, 0x5440(%rsp)
movaps %xmm0, 0x5430(%rsp)
movaps 0x5440(%rsp), %xmm1
movaps 0x5430(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x4b0(%rsp), %xmm0
movaps %xmm1, 0x5340(%rsp)
movaps %xmm0, 0x5330(%rsp)
movaps 0x5340(%rsp), %xmm0
movaps 0x5330(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x680(%rsp)
movaps 0x4a0(%rsp), %xmm1
movaps 0x490(%rsp), %xmm0
movaps %xmm1, 0x5520(%rsp)
movaps %xmm0, 0x5510(%rsp)
movaps 0x5520(%rsp), %xmm0
movaps 0x5510(%rsp), %xmm1
packusdw %xmm1, %xmm0
movaps %xmm0, 0x4a0(%rsp)
movaps 0x480(%rsp), %xmm1
movaps 0x470(%rsp), %xmm0
movaps %xmm1, 0x5500(%rsp)
movaps %xmm0, 0x54f0(%rsp)
movaps 0x5500(%rsp), %xmm0
movaps 0x54f0(%rsp), %xmm1
packusdw %xmm1, %xmm0
movaps %xmm0, 0x480(%rsp)
movaps 0x4a0(%rsp), %xmm1
movaps 0x480(%rsp), %xmm0
movaps %xmm1, 0x5560(%rsp)
movaps %xmm0, 0x5550(%rsp)
movaps 0x5560(%rsp), %xmm0
movaps 0x5550(%rsp), %xmm1
packuswb %xmm1, %xmm0
movaps %xmm0, 0x4a0(%rsp)
movaps 0x6b0(%rsp), %xmm1
movl $0x8000, 0x4c18(%rsp) # imm = 0x8000
movl 0x4c18(%rsp), %eax
movl %eax, 0x604c(%rsp)
movl %eax, 0x6048(%rsp)
movl %eax, 0x6044(%rsp)
movl %eax, 0x6040(%rsp)
movl 0x6044(%rsp), %edx
movl 0x6048(%rsp), %ecx
movl 0x604c(%rsp), %eax
movd 0x6040(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6030(%rsp)
movaps 0x6030(%rsp), %xmm0
movaps %xmm1, 0x5860(%rsp)
movaps %xmm0, 0x5850(%rsp)
movaps 0x5860(%rsp), %xmm1
movaps 0x5850(%rsp), %xmm0
pmaxud %xmm0, %xmm1
movaps 0x6b0(%rsp), %xmm0
movaps %xmm1, 0x5760(%rsp)
movaps %xmm0, 0x5750(%rsp)
movaps 0x5760(%rsp), %xmm1
movaps 0x5750(%rsp), %xmm0
pcmpeqd %xmm0, %xmm1
movl $0xffffffff, 0x4c14(%rsp) # imm = 0xFFFFFFFF
movl 0x4c14(%rsp), %eax
movl %eax, 0x606c(%rsp)
movl %eax, 0x6068(%rsp)
movl %eax, 0x6064(%rsp)
movl %eax, 0x6060(%rsp)
movl 0x6064(%rsp), %edx
movl 0x6068(%rsp), %ecx
movl 0x606c(%rsp), %eax
movd 0x6060(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6050(%rsp)
movaps 0x6050(%rsp), %xmm0
movaps %xmm1, 0x5660(%rsp)
movaps %xmm0, 0x5650(%rsp)
movaps 0x5660(%rsp), %xmm0
pcmpeqd %xmm1, %xmm1
movaps 0x5650(%rsp), %xmm2
pandn %xmm2, %xmm0
movaps %xmm0, 0x460(%rsp)
movaps 0x6a0(%rsp), %xmm2
movl $0x8000, 0x4c10(%rsp) # imm = 0x8000
movl 0x4c10(%rsp), %eax
movl %eax, 0x608c(%rsp)
movl %eax, 0x6088(%rsp)
movl %eax, 0x6084(%rsp)
movl %eax, 0x6080(%rsp)
movl 0x6084(%rsp), %edx
movl 0x6088(%rsp), %ecx
movl 0x608c(%rsp), %eax
movd 0x6080(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6070(%rsp)
movaps 0x6070(%rsp), %xmm0
movaps %xmm2, 0x5840(%rsp)
movaps %xmm0, 0x5830(%rsp)
movaps 0x5840(%rsp), %xmm2
movaps 0x5830(%rsp), %xmm0
pmaxud %xmm0, %xmm2
movaps 0x6a0(%rsp), %xmm0
movaps %xmm2, 0x5740(%rsp)
movaps %xmm0, 0x5730(%rsp)
movaps 0x5740(%rsp), %xmm2
movaps 0x5730(%rsp), %xmm0
pcmpeqd %xmm0, %xmm2
movl $0xffffffff, 0x4c0c(%rsp) # imm = 0xFFFFFFFF
movl 0x4c0c(%rsp), %eax
movl %eax, 0x60ac(%rsp)
movl %eax, 0x60a8(%rsp)
movl %eax, 0x60a4(%rsp)
movl %eax, 0x60a0(%rsp)
movl 0x60a4(%rsp), %edx
movl 0x60a8(%rsp), %ecx
movl 0x60ac(%rsp), %eax
movd 0x60a0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6090(%rsp)
movaps 0x6090(%rsp), %xmm0
movaps %xmm2, 0x5640(%rsp)
movaps %xmm0, 0x5630(%rsp)
movaps 0x5640(%rsp), %xmm0
movaps 0x5630(%rsp), %xmm2
pandn %xmm2, %xmm0
movaps %xmm0, 0x450(%rsp)
movaps 0x690(%rsp), %xmm2
movl $0x8000, 0x4c08(%rsp) # imm = 0x8000
movl 0x4c08(%rsp), %eax
movl %eax, 0x60cc(%rsp)
movl %eax, 0x60c8(%rsp)
movl %eax, 0x60c4(%rsp)
movl %eax, 0x60c0(%rsp)
movl 0x60c4(%rsp), %edx
movl 0x60c8(%rsp), %ecx
movl 0x60cc(%rsp), %eax
movd 0x60c0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x60b0(%rsp)
movaps 0x60b0(%rsp), %xmm0
movaps %xmm2, 0x5820(%rsp)
movaps %xmm0, 0x5810(%rsp)
movaps 0x5820(%rsp), %xmm2
movaps 0x5810(%rsp), %xmm0
pmaxud %xmm0, %xmm2
movaps 0x690(%rsp), %xmm0
movaps %xmm2, 0x5720(%rsp)
movaps %xmm0, 0x5710(%rsp)
movaps 0x5720(%rsp), %xmm2
movaps 0x5710(%rsp), %xmm0
pcmpeqd %xmm0, %xmm2
movl $0xffffffff, 0x4c04(%rsp) # imm = 0xFFFFFFFF
movl 0x4c04(%rsp), %eax
movl %eax, 0x60ec(%rsp)
movl %eax, 0x60e8(%rsp)
movl %eax, 0x60e4(%rsp)
movl %eax, 0x60e0(%rsp)
movl 0x60e4(%rsp), %edx
movl 0x60e8(%rsp), %ecx
movl 0x60ec(%rsp), %eax
movd 0x60e0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x60d0(%rsp)
movaps 0x60d0(%rsp), %xmm0
movaps %xmm2, 0x5620(%rsp)
movaps %xmm0, 0x5610(%rsp)
movaps 0x5620(%rsp), %xmm0
movaps 0x5610(%rsp), %xmm2
pandn %xmm2, %xmm0
movaps %xmm0, 0x440(%rsp)
movaps 0x680(%rsp), %xmm2
movl $0x8000, 0x4c00(%rsp) # imm = 0x8000
movl 0x4c00(%rsp), %eax
movl %eax, 0x610c(%rsp)
movl %eax, 0x6108(%rsp)
movl %eax, 0x6104(%rsp)
movl %eax, 0x6100(%rsp)
movl 0x6104(%rsp), %edx
movl 0x6108(%rsp), %ecx
movl 0x610c(%rsp), %eax
movd 0x6100(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x60f0(%rsp)
movaps 0x60f0(%rsp), %xmm0
movaps %xmm2, 0x5800(%rsp)
movaps %xmm0, 0x57f0(%rsp)
movaps 0x5800(%rsp), %xmm2
movaps 0x57f0(%rsp), %xmm0
pmaxud %xmm0, %xmm2
movaps 0x680(%rsp), %xmm0
movaps %xmm2, 0x5700(%rsp)
movaps %xmm0, 0x56f0(%rsp)
movaps 0x5700(%rsp), %xmm2
movaps 0x56f0(%rsp), %xmm0
pcmpeqd %xmm0, %xmm2
movl $0xffffffff, 0x4bfc(%rsp) # imm = 0xFFFFFFFF
movl 0x4bfc(%rsp), %eax
movl %eax, 0x612c(%rsp)
movl %eax, 0x6128(%rsp)
movl %eax, 0x6124(%rsp)
movl %eax, 0x6120(%rsp)
movl 0x6124(%rsp), %edx
movl 0x6128(%rsp), %ecx
movl 0x612c(%rsp), %eax
movd 0x6120(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6110(%rsp)
movaps 0x6110(%rsp), %xmm0
movaps %xmm2, 0x5600(%rsp)
movaps %xmm0, 0x55f0(%rsp)
movaps 0x5600(%rsp), %xmm0
pxor %xmm1, %xmm0
pand 0x55f0(%rsp), %xmm0
movdqa %xmm0, 0x430(%rsp)
leaq 0x330(%rsp), %rdi
leaq 0x43d42(%rip), %rsi     # 0xf6580
movl $0x100, %edx            # imm = 0x100
callq 0x43b0
movq 0x6d8(%rsp), %rax
addq $0x48, %rax
cmpq 0x4b88(%rsp), %rax
jbe 0xb28ac
leaq 0x5b0(%rsp), %rdi
movq 0x6d8(%rsp), %rsi
movq 0x4b88(%rsp), %rdx
movq 0x6d8(%rsp), %rax
subq %rax, %rdx
callq 0x4810
leaq 0x5b0(%rsp), %rax
movq %rax, 0x6d8(%rsp)
leaq 0x5b0(%rsp), %rax
addq $0x88, %rax
movq %rax, 0x4b88(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x5928(%rsp)
movq 0x5928(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x58e0(%rsp)
pmovzxwd 0x58e0(%rsp), %xmm0
movaps %xmm0, 0x320(%rsp)
movaps 0x460(%rsp), %xmm0
movaps %xmm0, 0x59a0(%rsp)
movaps 0x59a0(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0x31c(%rsp)
movaps 0x320(%rsp), %xmm1
movl 0x31c(%rsp), %eax
shlq $0x4, %rax
leaq 0x330(%rsp,%rax), %rax
movq %rax, 0x4c68(%rsp)
movq 0x4c68(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm1, 0x5aa0(%rsp)
movaps %xmm0, 0x5a90(%rsp)
movaps 0x5aa0(%rsp), %xmm0
movaps 0x5a90(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0x320(%rsp)
movl 0x31c(%rsp), %eax
movl %eax, 0x5ad8(%rsp)
popcntl 0x5ad8(%rsp), %ecx
movq 0x6d8(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x6d8(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x5920(%rsp)
movq 0x5920(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x58d0(%rsp)
pmovzxwd 0x58d0(%rsp), %xmm0
movaps %xmm0, 0x300(%rsp)
movaps 0x450(%rsp), %xmm0
movaps %xmm0, 0x5990(%rsp)
movaps 0x5990(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0x2fc(%rsp)
movl 0x2fc(%rsp), %eax
movl %eax, 0x5ad4(%rsp)
popcntl 0x5ad4(%rsp), %ecx
movq 0x6d8(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x6d8(%rsp)
movaps 0x300(%rsp), %xmm1
movl 0x2fc(%rsp), %eax
shlq $0x4, %rax
leaq 0x330(%rsp,%rax), %rax
movq %rax, 0x4c60(%rsp)
movq 0x4c60(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm1, 0x5a80(%rsp)
movaps %xmm0, 0x5a70(%rsp)
movaps 0x5a80(%rsp), %xmm0
movaps 0x5a70(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0x300(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x5918(%rsp)
movq 0x5918(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x58c0(%rsp)
pmovzxwd 0x58c0(%rsp), %xmm0
movaps %xmm0, 0x2e0(%rsp)
movaps 0x440(%rsp), %xmm0
movaps %xmm0, 0x5980(%rsp)
movaps 0x5980(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0x2dc(%rsp)
movaps 0x2e0(%rsp), %xmm1
movl 0x2dc(%rsp), %eax
shlq $0x4, %rax
leaq 0x330(%rsp,%rax), %rax
movq %rax, 0x4c58(%rsp)
movq 0x4c58(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm1, 0x5a60(%rsp)
movaps %xmm0, 0x5a50(%rsp)
movaps 0x5a60(%rsp), %xmm0
movaps 0x5a50(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0x2e0(%rsp)
movl 0x2dc(%rsp), %eax
movl %eax, 0x5ad0(%rsp)
popcntl 0x5ad0(%rsp), %ecx
movq 0x6d8(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x6d8(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x5910(%rsp)
movq 0x5910(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x58b0(%rsp)
pmovzxwd 0x58b0(%rsp), %xmm0
movaps %xmm0, 0x2c0(%rsp)
movaps 0x430(%rsp), %xmm0
movaps %xmm0, 0x5970(%rsp)
movaps 0x5970(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0x2bc(%rsp)
movl 0x2bc(%rsp), %eax
movl %eax, 0x5acc(%rsp)
popcntl 0x5acc(%rsp), %ecx
movq 0x6d8(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x6d8(%rsp)
movaps 0x2c0(%rsp), %xmm1
movl 0x2bc(%rsp), %eax
shlq $0x4, %rax
leaq 0x330(%rsp,%rax), %rax
movq %rax, 0x4c50(%rsp)
movq 0x4c50(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm1, 0x5a40(%rsp)
movaps %xmm0, 0x5a30(%rsp)
movaps 0x5a40(%rsp), %xmm0
movaps 0x5a30(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0x2c0(%rsp)
movaps 0x6b0(%rsp), %xmm0
movaps %xmm0, 0x5bc0(%rsp)
movl $0x10, 0x5bbc(%rsp)
movaps 0x5bc0(%rsp), %xmm0
movd 0x5bbc(%rsp), %xmm1
pslld %xmm1, %xmm0
movaps %xmm0, 0x2a0(%rsp)
movaps 0x6a0(%rsp), %xmm0
movaps %xmm0, 0x5ba0(%rsp)
movl $0x10, 0x5b9c(%rsp)
movaps 0x5ba0(%rsp), %xmm0
movd 0x5b9c(%rsp), %xmm1
pslld %xmm1, %xmm0
movaps %xmm0, 0x290(%rsp)
movaps 0x690(%rsp), %xmm0
movaps %xmm0, 0x5b80(%rsp)
movl $0x10, 0x5b7c(%rsp)
movaps 0x5b80(%rsp), %xmm0
movd 0x5b7c(%rsp), %xmm1
pslld %xmm1, %xmm0
movaps %xmm0, 0x280(%rsp)
movaps 0x680(%rsp), %xmm0
movaps %xmm0, 0x5b60(%rsp)
movl $0x10, 0x5b5c(%rsp)
movaps 0x5b60(%rsp), %xmm0
movd 0x5b5c(%rsp), %xmm1
pslld %xmm1, %xmm0
movaps %xmm0, 0x270(%rsp)
movaps 0x2a0(%rsp), %xmm1
movaps 0x320(%rsp), %xmm0
movaps %xmm1, 0x5cc0(%rsp)
movaps %xmm0, 0x5cb0(%rsp)
movaps 0x5cc0(%rsp), %xmm0
movaps 0x5cb0(%rsp), %xmm1
por %xmm1, %xmm0
movaps %xmm0, 0x2a0(%rsp)
movaps 0x290(%rsp), %xmm1
movaps 0x300(%rsp), %xmm0
movaps %xmm1, 0x5ca0(%rsp)
movaps %xmm0, 0x5c90(%rsp)
movaps 0x5ca0(%rsp), %xmm0
movaps 0x5c90(%rsp), %xmm1
por %xmm1, %xmm0
movaps %xmm0, 0x290(%rsp)
movaps 0x280(%rsp), %xmm1
movaps 0x2e0(%rsp), %xmm0
movaps %xmm1, 0x5c80(%rsp)
movaps %xmm0, 0x5c70(%rsp)
movaps 0x5c80(%rsp), %xmm0
movaps 0x5c70(%rsp), %xmm1
por %xmm1, %xmm0
movaps %xmm0, 0x280(%rsp)
movaps 0x270(%rsp), %xmm1
movaps 0x2c0(%rsp), %xmm0
movaps %xmm1, 0x5c60(%rsp)
movaps %xmm0, 0x5c50(%rsp)
movaps 0x5c60(%rsp), %xmm0
movaps 0x5c50(%rsp), %xmm1
por %xmm1, %xmm0
movaps %xmm0, 0x270(%rsp)
movaps 0x6b0(%rsp), %xmm2
movaps 0x2a0(%rsp), %xmm1
movaps 0x460(%rsp), %xmm0
movaps %xmm2, 0x5e40(%rsp)
movaps %xmm1, 0x5e30(%rsp)
movaps %xmm0, 0x5e20(%rsp)
movaps 0x5e40(%rsp), %xmm1
movaps 0x5e30(%rsp), %xmm2
movaps 0x5e20(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movaps %xmm0, 0x6b0(%rsp)
movaps 0x6a0(%rsp), %xmm2
movaps 0x290(%rsp), %xmm1
movaps 0x450(%rsp), %xmm0
movaps %xmm2, 0x5e10(%rsp)
movaps %xmm1, 0x5e00(%rsp)
movaps %xmm0, 0x5df0(%rsp)
movaps 0x5e10(%rsp), %xmm1
movaps 0x5e00(%rsp), %xmm2
movaps 0x5df0(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movaps %xmm0, 0x6a0(%rsp)
movaps 0x690(%rsp), %xmm2
movaps 0x280(%rsp), %xmm1
movaps 0x440(%rsp), %xmm0
movaps %xmm2, 0x5de0(%rsp)
movaps %xmm1, 0x5dd0(%rsp)
movaps %xmm0, 0x5dc0(%rsp)
movaps 0x5de0(%rsp), %xmm1
movaps 0x5dd0(%rsp), %xmm2
movaps 0x5dc0(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movaps %xmm0, 0x690(%rsp)
movaps 0x680(%rsp), %xmm2
movaps 0x270(%rsp), %xmm1
movaps 0x430(%rsp), %xmm0
movaps %xmm2, 0x5db0(%rsp)
movaps %xmm1, 0x5da0(%rsp)
movaps %xmm0, 0x5d90(%rsp)
movaps 0x5db0(%rsp), %xmm1
movaps 0x5da0(%rsp), %xmm2
movaps 0x5d90(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movaps %xmm0, 0x680(%rsp)
movaps 0x670(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4e20(%rsp)
movaps %xmm0, 0x4e10(%rsp)
movaps 0x4e20(%rsp), %xmm0
movaps 0x4e10(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x260(%rsp)
movaps 0x660(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4e00(%rsp)
movaps %xmm0, 0x4df0(%rsp)
movaps 0x4e00(%rsp), %xmm0
movaps 0x4df0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x250(%rsp)
movaps 0x650(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4de0(%rsp)
movaps %xmm0, 0x4dd0(%rsp)
movaps 0x4de0(%rsp), %xmm0
movaps 0x4dd0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x240(%rsp)
movaps 0x640(%rsp), %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4dc0(%rsp)
movaps %xmm0, 0x4db0(%rsp)
movaps 0x4dc0(%rsp), %xmm0
movaps 0x4db0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x230(%rsp)
movaps 0x260(%rsp), %xmm0
leaq 0xb80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x4, %esi
movl %esi, 0x1c(%rsp)
callq 0xb4af0
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movaps %xmm0, 0x220(%rsp)
movaps 0x250(%rsp), %xmm0
callq 0xb4af0
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movaps %xmm0, 0x210(%rsp)
movaps 0x240(%rsp), %xmm0
callq 0xb4af0
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movaps %xmm0, 0x200(%rsp)
movaps 0x230(%rsp), %xmm0
callq 0xb4af0
movaps %xmm0, 0x1f0(%rsp)
movaps 0x220(%rsp), %xmm0
movaps %xmm0, 0x5120(%rsp)
movl $0x14, 0x511c(%rsp)
movaps 0x5120(%rsp), %xmm0
movd 0x511c(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x1e0(%rsp)
movaps 0x210(%rsp), %xmm0
movaps %xmm0, 0x5100(%rsp)
movl $0x14, 0x50fc(%rsp)
movaps 0x5100(%rsp), %xmm0
movd 0x50fc(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x1d0(%rsp)
movaps 0x200(%rsp), %xmm0
movaps %xmm0, 0x50e0(%rsp)
movl $0x14, 0x50dc(%rsp)
movaps 0x50e0(%rsp), %xmm0
movd 0x50dc(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x1c0(%rsp)
movaps 0x1f0(%rsp), %xmm0
movaps %xmm0, 0x50c0(%rsp)
movl $0x14, 0x50bc(%rsp)
movaps 0x50c0(%rsp), %xmm0
movd 0x50bc(%rsp), %xmm1
psrld %xmm1, %xmm0
movaps %xmm0, 0x1b0(%rsp)
movaps 0x220(%rsp), %xmm0
movaps %xmm0, 0x50a0(%rsp)
movl $0x8, 0x509c(%rsp)
movaps 0x50a0(%rsp), %xmm1
movd 0x509c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4da0(%rsp)
movaps %xmm0, 0x4d90(%rsp)
movaps 0x4da0(%rsp), %xmm0
movaps 0x4d90(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x1a0(%rsp)
movaps 0x210(%rsp), %xmm0
movaps %xmm0, 0x5080(%rsp)
movl $0x8, 0x507c(%rsp)
movaps 0x5080(%rsp), %xmm1
movd 0x507c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4d80(%rsp)
movaps %xmm0, 0x4d70(%rsp)
movaps 0x4d80(%rsp), %xmm0
movaps 0x4d70(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x190(%rsp)
movaps 0x200(%rsp), %xmm0
movaps %xmm0, 0x5060(%rsp)
movl $0x8, 0x505c(%rsp)
movaps 0x5060(%rsp), %xmm1
movd 0x505c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4d60(%rsp)
movaps %xmm0, 0x4d50(%rsp)
movaps 0x4d60(%rsp), %xmm0
movaps 0x4d50(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x180(%rsp)
movaps 0x1f0(%rsp), %xmm0
movaps %xmm0, 0x5040(%rsp)
movl $0x8, 0x503c(%rsp)
movaps 0x5040(%rsp), %xmm1
movd 0x503c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x6c0(%rsp), %xmm0
movaps %xmm1, 0x4d40(%rsp)
movaps %xmm0, 0x4d30(%rsp)
movaps 0x4d40(%rsp), %xmm0
movaps 0x4d30(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x170(%rsp)
movaps 0x220(%rsp), %xmm1
movl $0xff, 0x4bf8(%rsp)
movl 0x4bf8(%rsp), %eax
movl %eax, 0x614c(%rsp)
movl %eax, 0x6148(%rsp)
movl %eax, 0x6144(%rsp)
movl %eax, 0x6140(%rsp)
movl 0x6144(%rsp), %edx
movl 0x6148(%rsp), %ecx
movl 0x614c(%rsp), %eax
movd 0x6140(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6130(%rsp)
movaps 0x6130(%rsp), %xmm0
movaps %xmm1, 0x4d20(%rsp)
movaps %xmm0, 0x4d10(%rsp)
movaps 0x4d20(%rsp), %xmm0
movaps 0x4d10(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x160(%rsp)
movaps 0x210(%rsp), %xmm1
movl $0xff, 0x4bf4(%rsp)
movl 0x4bf4(%rsp), %eax
movl %eax, 0x616c(%rsp)
movl %eax, 0x6168(%rsp)
movl %eax, 0x6164(%rsp)
movl %eax, 0x6160(%rsp)
movl 0x6164(%rsp), %edx
movl 0x6168(%rsp), %ecx
movl 0x616c(%rsp), %eax
movd 0x6160(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6150(%rsp)
movaps 0x6150(%rsp), %xmm0
movaps %xmm1, 0x4d00(%rsp)
movaps %xmm0, 0x4cf0(%rsp)
movaps 0x4d00(%rsp), %xmm0
movaps 0x4cf0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x150(%rsp)
movaps 0x200(%rsp), %xmm1
movl $0xff, 0x4bf0(%rsp)
movl 0x4bf0(%rsp), %eax
movl %eax, 0x618c(%rsp)
movl %eax, 0x6188(%rsp)
movl %eax, 0x6184(%rsp)
movl %eax, 0x6180(%rsp)
movl 0x6184(%rsp), %edx
movl 0x6188(%rsp), %ecx
movl 0x618c(%rsp), %eax
movd 0x6180(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6170(%rsp)
movaps 0x6170(%rsp), %xmm0
movaps %xmm1, 0x4ce0(%rsp)
movaps %xmm0, 0x4cd0(%rsp)
movaps 0x4ce0(%rsp), %xmm0
movaps 0x4cd0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x140(%rsp)
movaps 0x1f0(%rsp), %xmm1
movl $0xff, 0x4bec(%rsp)
movl 0x4bec(%rsp), %eax
movl %eax, 0x61ac(%rsp)
movl %eax, 0x61a8(%rsp)
movl %eax, 0x61a4(%rsp)
movl %eax, 0x61a0(%rsp)
movl 0x61a4(%rsp), %edx
movl 0x61a8(%rsp), %ecx
movl 0x61ac(%rsp), %eax
movd 0x61a0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6190(%rsp)
movaps 0x6190(%rsp), %xmm0
movaps %xmm1, 0x4cc0(%rsp)
movaps %xmm0, 0x4cb0(%rsp)
movaps 0x4cc0(%rsp), %xmm0
movaps 0x4cb0(%rsp), %xmm1
pand %xmm1, %xmm0
movaps %xmm0, 0x130(%rsp)
movaps 0x670(%rsp), %xmm0
movaps %xmm0, 0x5020(%rsp)
movl $0xc, 0x501c(%rsp)
movaps 0x5020(%rsp), %xmm1
movd 0x501c(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x1e0(%rsp), %xmm0
movaps %xmm1, 0x5420(%rsp)
movaps %xmm0, 0x5410(%rsp)
movaps 0x5420(%rsp), %xmm1
movaps 0x5410(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x1a0(%rsp), %xmm0
movaps %xmm1, 0x5320(%rsp)
movaps %xmm0, 0x5310(%rsp)
movaps 0x5320(%rsp), %xmm0
movaps 0x5310(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x670(%rsp)
movaps 0x660(%rsp), %xmm0
movaps %xmm0, 0x5000(%rsp)
movl $0xc, 0x4ffc(%rsp)
movaps 0x5000(%rsp), %xmm1
movd 0x4ffc(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x1d0(%rsp), %xmm0
movaps %xmm1, 0x5400(%rsp)
movaps %xmm0, 0x53f0(%rsp)
movaps 0x5400(%rsp), %xmm1
movaps 0x53f0(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x190(%rsp), %xmm0
movaps %xmm1, 0x5300(%rsp)
movaps %xmm0, 0x52f0(%rsp)
movaps 0x5300(%rsp), %xmm0
movaps 0x52f0(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x660(%rsp)
movaps 0x650(%rsp), %xmm0
movaps %xmm0, 0x4fe0(%rsp)
movl $0xc, 0x4fdc(%rsp)
movaps 0x4fe0(%rsp), %xmm1
movd 0x4fdc(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x1c0(%rsp), %xmm0
movaps %xmm1, 0x53e0(%rsp)
movaps %xmm0, 0x53d0(%rsp)
movaps 0x53e0(%rsp), %xmm1
movaps 0x53d0(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x180(%rsp), %xmm0
movaps %xmm1, 0x52e0(%rsp)
movaps %xmm0, 0x52d0(%rsp)
movaps 0x52e0(%rsp), %xmm0
movaps 0x52d0(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x650(%rsp)
movaps 0x640(%rsp), %xmm0
movaps %xmm0, 0x4fc0(%rsp)
movl $0xc, 0x4fbc(%rsp)
movaps 0x4fc0(%rsp), %xmm1
movd 0x4fbc(%rsp), %xmm0
psrld %xmm0, %xmm1
movaps 0x1b0(%rsp), %xmm0
movaps %xmm1, 0x53c0(%rsp)
movaps %xmm0, 0x53b0(%rsp)
movaps 0x53c0(%rsp), %xmm1
movaps 0x53b0(%rsp), %xmm0
pmulld %xmm0, %xmm1
movaps 0x170(%rsp), %xmm0
movaps %xmm1, 0x52c0(%rsp)
movaps %xmm0, 0x52b0(%rsp)
movaps 0x52c0(%rsp), %xmm0
movaps 0x52b0(%rsp), %xmm1
paddd %xmm1, %xmm0
movaps %xmm0, 0x640(%rsp)
movaps 0x160(%rsp), %xmm1
movaps 0x150(%rsp), %xmm0
movaps %xmm1, 0x54e0(%rsp)
movaps %xmm0, 0x54d0(%rsp)
movaps 0x54e0(%rsp), %xmm0
movaps 0x54d0(%rsp), %xmm1
packusdw %xmm1, %xmm0
movaps %xmm0, 0x160(%rsp)
movaps 0x140(%rsp), %xmm1
movaps 0x130(%rsp), %xmm0
movaps %xmm1, 0x54c0(%rsp)
movaps %xmm0, 0x54b0(%rsp)
movaps 0x54c0(%rsp), %xmm0
movaps 0x54b0(%rsp), %xmm1
packusdw %xmm1, %xmm0
movaps %xmm0, 0x140(%rsp)
movaps 0x160(%rsp), %xmm1
movaps 0x140(%rsp), %xmm0
movaps %xmm1, 0x5540(%rsp)
movaps %xmm0, 0x5530(%rsp)
movaps 0x5540(%rsp), %xmm0
movaps 0x5530(%rsp), %xmm1
packuswb %xmm1, %xmm0
movaps %xmm0, 0x160(%rsp)
movaps 0x670(%rsp), %xmm1
movl $0x8000, 0x4be8(%rsp) # imm = 0x8000
movl 0x4be8(%rsp), %eax
movl %eax, 0x61cc(%rsp)
movl %eax, 0x61c8(%rsp)
movl %eax, 0x61c4(%rsp)
movl %eax, 0x61c0(%rsp)
movl 0x61c4(%rsp), %edx
movl 0x61c8(%rsp), %ecx
movl 0x61cc(%rsp), %eax
movd 0x61c0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x61b0(%rsp)
movaps 0x61b0(%rsp), %xmm0
movaps %xmm1, 0x57e0(%rsp)
movaps %xmm0, 0x57d0(%rsp)
movaps 0x57e0(%rsp), %xmm1
movaps 0x57d0(%rsp), %xmm0
pmaxud %xmm0, %xmm1
movaps 0x670(%rsp), %xmm0
movaps %xmm1, 0x56e0(%rsp)
movaps %xmm0, 0x56d0(%rsp)
movaps 0x56e0(%rsp), %xmm1
movaps 0x56d0(%rsp), %xmm0
pcmpeqd %xmm0, %xmm1
movl $0xffffffff, 0x4be4(%rsp) # imm = 0xFFFFFFFF
movl 0x4be4(%rsp), %eax
movl %eax, 0x61ec(%rsp)
movl %eax, 0x61e8(%rsp)
movl %eax, 0x61e4(%rsp)
movl %eax, 0x61e0(%rsp)
movl 0x61e4(%rsp), %edx
movl 0x61e8(%rsp), %ecx
movl 0x61ec(%rsp), %eax
movd 0x61e0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x61d0(%rsp)
movaps 0x61d0(%rsp), %xmm0
movaps %xmm1, 0x55e0(%rsp)
movaps %xmm0, 0x55d0(%rsp)
movaps 0x55e0(%rsp), %xmm0
movaps 0x55d0(%rsp), %xmm1
pandn %xmm1, %xmm0
movaps %xmm0, 0x120(%rsp)
movaps 0x660(%rsp), %xmm1
movl $0x8000, 0x4be0(%rsp) # imm = 0x8000
movl 0x4be0(%rsp), %eax
movl %eax, 0x620c(%rsp)
movl %eax, 0x6208(%rsp)
movl %eax, 0x6204(%rsp)
movl %eax, 0x6200(%rsp)
movl 0x6204(%rsp), %edx
movl 0x6208(%rsp), %ecx
movl 0x620c(%rsp), %eax
movd 0x6200(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x61f0(%rsp)
movaps 0x61f0(%rsp), %xmm0
movaps %xmm1, 0x57c0(%rsp)
movaps %xmm0, 0x57b0(%rsp)
movaps 0x57c0(%rsp), %xmm1
movaps 0x57b0(%rsp), %xmm0
pmaxud %xmm0, %xmm1
movaps 0x660(%rsp), %xmm0
movaps %xmm1, 0x56c0(%rsp)
movaps %xmm0, 0x56b0(%rsp)
movaps 0x56c0(%rsp), %xmm1
movaps 0x56b0(%rsp), %xmm0
pcmpeqd %xmm0, %xmm1
movl $0xffffffff, 0x4bdc(%rsp) # imm = 0xFFFFFFFF
movl 0x4bdc(%rsp), %eax
movl %eax, 0x622c(%rsp)
movl %eax, 0x6228(%rsp)
movl %eax, 0x6224(%rsp)
movl %eax, 0x6220(%rsp)
movl 0x6224(%rsp), %edx
movl 0x6228(%rsp), %ecx
movl 0x622c(%rsp), %eax
movd 0x6220(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6210(%rsp)
movaps 0x6210(%rsp), %xmm0
movaps %xmm1, 0x55c0(%rsp)
movaps %xmm0, 0x55b0(%rsp)
movaps 0x55c0(%rsp), %xmm0
movaps 0x55b0(%rsp), %xmm1
pandn %xmm1, %xmm0
movaps %xmm0, 0x110(%rsp)
movaps 0x650(%rsp), %xmm1
movl $0x8000, 0x4bd8(%rsp) # imm = 0x8000
movl 0x4bd8(%rsp), %eax
movl %eax, 0x624c(%rsp)
movl %eax, 0x6248(%rsp)
movl %eax, 0x6244(%rsp)
movl %eax, 0x6240(%rsp)
movl 0x6244(%rsp), %edx
movl 0x6248(%rsp), %ecx
movl 0x624c(%rsp), %eax
movd 0x6240(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6230(%rsp)
movaps 0x6230(%rsp), %xmm0
movaps %xmm1, 0x57a0(%rsp)
movaps %xmm0, 0x5790(%rsp)
movaps 0x57a0(%rsp), %xmm1
movaps 0x5790(%rsp), %xmm0
pmaxud %xmm0, %xmm1
movaps 0x650(%rsp), %xmm0
movaps %xmm1, 0x56a0(%rsp)
movaps %xmm0, 0x5690(%rsp)
movaps 0x56a0(%rsp), %xmm1
movaps 0x5690(%rsp), %xmm0
pcmpeqd %xmm0, %xmm1
movl $0xffffffff, 0x4bd4(%rsp) # imm = 0xFFFFFFFF
movl 0x4bd4(%rsp), %eax
movl %eax, 0x626c(%rsp)
movl %eax, 0x6268(%rsp)
movl %eax, 0x6264(%rsp)
movl %eax, 0x6260(%rsp)
movl 0x6264(%rsp), %edx
movl 0x6268(%rsp), %ecx
movl 0x626c(%rsp), %eax
movd 0x6260(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6250(%rsp)
movaps 0x6250(%rsp), %xmm0
movaps %xmm1, 0x55a0(%rsp)
movaps %xmm0, 0x5590(%rsp)
movaps 0x55a0(%rsp), %xmm0
movaps 0x5590(%rsp), %xmm1
pandn %xmm1, %xmm0
movaps %xmm0, 0x100(%rsp)
movaps 0x640(%rsp), %xmm1
movl $0x8000, 0x4bd0(%rsp) # imm = 0x8000
movl 0x4bd0(%rsp), %eax
movl %eax, 0x628c(%rsp)
movl %eax, 0x6288(%rsp)
movl %eax, 0x6284(%rsp)
movl %eax, 0x6280(%rsp)
movl 0x6284(%rsp), %edx
movl 0x6288(%rsp), %ecx
movl 0x628c(%rsp), %eax
movd 0x6280(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6270(%rsp)
movaps 0x6270(%rsp), %xmm0
movaps %xmm1, 0x5780(%rsp)
movaps %xmm0, 0x5770(%rsp)
movaps 0x5780(%rsp), %xmm1
movaps 0x5770(%rsp), %xmm0
pmaxud %xmm0, %xmm1
movaps 0x640(%rsp), %xmm0
movaps %xmm1, 0x5680(%rsp)
movaps %xmm0, 0x5670(%rsp)
movaps 0x5680(%rsp), %xmm1
movaps 0x5670(%rsp), %xmm0
pcmpeqd %xmm0, %xmm1
movl $0xffffffff, 0x4bcc(%rsp) # imm = 0xFFFFFFFF
movl 0x4bcc(%rsp), %eax
movl %eax, 0x62ac(%rsp)
movl %eax, 0x62a8(%rsp)
movl %eax, 0x62a4(%rsp)
movl %eax, 0x62a0(%rsp)
movl 0x62a4(%rsp), %edx
movl 0x62a8(%rsp), %ecx
movl 0x62ac(%rsp), %eax
movd 0x62a0(%rsp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, 0x6290(%rsp)
movaps 0x6290(%rsp), %xmm0
movaps %xmm1, 0x5580(%rsp)
movaps %xmm0, 0x5570(%rsp)
movaps 0x5580(%rsp), %xmm0
movaps 0x5570(%rsp), %xmm1
pandn %xmm1, %xmm0
movaps %xmm0, 0xf0(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x5908(%rsp)
movq 0x5908(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x58a0(%rsp)
pmovzxwd 0x58a0(%rsp), %xmm0
movaps %xmm0, 0xe0(%rsp)
movaps 0x120(%rsp), %xmm0
movaps %xmm0, 0x5960(%rsp)
movaps 0x5960(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0xdc(%rsp)
movaps 0xe0(%rsp), %xmm1
movl 0xdc(%rsp), %eax
shlq $0x4, %rax
leaq 0x330(%rsp,%rax), %rax
movq %rax, 0x4c48(%rsp)
movq 0x4c48(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm1, 0x5a20(%rsp)
movaps %xmm0, 0x5a10(%rsp)
movaps 0x5a20(%rsp), %xmm0
movaps 0x5a10(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0xe0(%rsp)
movl 0xdc(%rsp), %eax
movl %eax, 0x5ac8(%rsp)
popcntl 0x5ac8(%rsp), %ecx
movq 0x6d8(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x6d8(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x5900(%rsp)
movq 0x5900(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x5890(%rsp)
pmovzxwd 0x5890(%rsp), %xmm0
movaps %xmm0, 0xc0(%rsp)
movaps 0x110(%rsp), %xmm0
movaps %xmm0, 0x5950(%rsp)
movaps 0x5950(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, 0x5ac4(%rsp)
popcntl 0x5ac4(%rsp), %ecx
movq 0x6d8(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x6d8(%rsp)
movaps 0xc0(%rsp), %xmm1
movl 0xbc(%rsp), %eax
shlq $0x4, %rax
leaq 0x330(%rsp,%rax), %rax
movq %rax, 0x4c40(%rsp)
movq 0x4c40(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm1, 0x5a00(%rsp)
movaps %xmm0, 0x59f0(%rsp)
movaps 0x5a00(%rsp), %xmm0
movaps 0x59f0(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0xc0(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x58f8(%rsp)
movq 0x58f8(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x5880(%rsp)
pmovzxwd 0x5880(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps 0x100(%rsp), %xmm0
movaps %xmm0, 0x5940(%rsp)
movaps 0x5940(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0x9c(%rsp)
movaps 0xa0(%rsp), %xmm1
movl 0x9c(%rsp), %eax
shlq $0x4, %rax
leaq 0x330(%rsp,%rax), %rax
movq %rax, 0x4c38(%rsp)
movq 0x4c38(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm1, 0x59e0(%rsp)
movaps %xmm0, 0x59d0(%rsp)
movaps 0x59e0(%rsp), %xmm0
movaps 0x59d0(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0xa0(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x5ac0(%rsp)
popcntl 0x5ac0(%rsp), %ecx
movq 0x6d8(%rsp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x6d8(%rsp)
movq 0x6d8(%rsp), %rax
movq %rax, 0x58f0(%rsp)
movq 0x58f0(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x5870(%rsp)
pmovzxwd 0x5870(%rsp), %xmm0
movdqa %xmm0, 0x80(%rsp)
movdqa 0xf0(%rsp), %xmm0
movaps %xmm0, 0x5930(%rsp)
movaps 0x5930(%rsp), %xmm0
movmskps %xmm0, %eax
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x5abc(%rsp)
movl 0x5abc(%rsp), %eax
popcntl %eax, %ecx
movq 0x6d8(%rsp), %rax
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x6d8(%rsp)
movdqa 0x80(%rsp), %xmm1
movl 0x7c(%rsp), %eax
movl %eax, %ecx
leaq 0x330(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x4c30(%rsp)
movq 0x4c30(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm1, 0x59c0(%rsp)
movdqa %xmm0, 0x59b0(%rsp)
movdqa 0x59c0(%rsp), %xmm0
movdqa 0x59b0(%rsp), %xmm1
pshufb %xmm1, %xmm0
movdqa %xmm0, 0x80(%rsp)
movdqa 0x670(%rsp), %xmm0
movdqa %xmm0, 0x5b40(%rsp)
movl $0x10, 0x5b3c(%rsp)
movdqa 0x5b40(%rsp), %xmm0
movl 0x5b3c(%rsp), %eax
movd %eax, %xmm1
pslld %xmm1, %xmm0
movdqa %xmm0, 0x60(%rsp)
movdqa 0x660(%rsp), %xmm0
movdqa %xmm0, 0x5b20(%rsp)
movl $0x10, 0x5b1c(%rsp)
movdqa 0x5b20(%rsp), %xmm0
movl 0x5b1c(%rsp), %eax
movd %eax, %xmm1
pslld %xmm1, %xmm0
movdqa %xmm0, 0x50(%rsp)
movdqa 0x650(%rsp), %xmm0
movdqa %xmm0, 0x5b00(%rsp)
movl $0x10, 0x5afc(%rsp)
movdqa 0x5b00(%rsp), %xmm0
movl 0x5afc(%rsp), %eax
movd %eax, %xmm1
pslld %xmm1, %xmm0
movdqa %xmm0, 0x40(%rsp)
movdqa 0x640(%rsp), %xmm0
movdqa %xmm0, 0x5ae0(%rsp)
movl $0x10, 0x5adc(%rsp)
movdqa 0x5ae0(%rsp), %xmm0
movl 0x5adc(%rsp), %eax
movd %eax, %xmm1
pslld %xmm1, %xmm0
movdqa %xmm0, 0x30(%rsp)
movdqa 0x60(%rsp), %xmm1
movdqa 0xe0(%rsp), %xmm0
movdqa %xmm1, 0x5c40(%rsp)
movdqa %xmm0, 0x5c30(%rsp)
movdqa 0x5c40(%rsp), %xmm0
por 0x5c30(%rsp), %xmm0
movdqa %xmm0, 0x60(%rsp)
movdqa 0x50(%rsp), %xmm1
movdqa 0xc0(%rsp), %xmm0
movdqa %xmm1, 0x5c20(%rsp)
movdqa %xmm0, 0x5c10(%rsp)
movdqa 0x5c20(%rsp), %xmm0
por 0x5c10(%rsp), %xmm0
movdqa %xmm0, 0x50(%rsp)
movdqa 0x40(%rsp), %xmm1
movdqa 0xa0(%rsp), %xmm0
movdqa %xmm1, 0x5c00(%rsp)
movdqa %xmm0, 0x5bf0(%rsp)
movdqa 0x5c00(%rsp), %xmm0
por 0x5bf0(%rsp), %xmm0
movdqa %xmm0, 0x40(%rsp)
movdqa 0x30(%rsp), %xmm1
movdqa 0x80(%rsp), %xmm0
movdqa %xmm1, 0x5be0(%rsp)
movdqa %xmm0, 0x5bd0(%rsp)
movdqa 0x5be0(%rsp), %xmm0
por 0x5bd0(%rsp), %xmm0
movdqa %xmm0, 0x30(%rsp)
movdqa 0x670(%rsp), %xmm2
movdqa 0x60(%rsp), %xmm1
movdqa 0x120(%rsp), %xmm0
movdqa %xmm2, 0x5d80(%rsp)
movdqa %xmm1, 0x5d70(%rsp)
movdqa %xmm0, 0x5d60(%rsp)
movdqa 0x5d80(%rsp), %xmm1
movdqa 0x5d70(%rsp), %xmm2
movdqa 0x5d60(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movdqa %xmm0, 0x670(%rsp)
movdqa 0x660(%rsp), %xmm2
movdqa 0x50(%rsp), %xmm1
movdqa 0x110(%rsp), %xmm0
movdqa %xmm2, 0x5d50(%rsp)
movdqa %xmm1, 0x5d40(%rsp)
movdqa %xmm0, 0x5d30(%rsp)
movdqa 0x5d50(%rsp), %xmm1
movdqa 0x5d40(%rsp), %xmm2
movdqa 0x5d30(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movdqa %xmm0, 0x660(%rsp)
movdqa 0x650(%rsp), %xmm2
movdqa 0x40(%rsp), %xmm1
movdqa 0x100(%rsp), %xmm0
movdqa %xmm2, 0x5d20(%rsp)
movdqa %xmm1, 0x5d10(%rsp)
movdqa %xmm0, 0x5d00(%rsp)
movdqa 0x5d20(%rsp), %xmm1
movdqa 0x5d10(%rsp), %xmm2
movdqa 0x5d00(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movdqa %xmm0, 0x650(%rsp)
movdqa 0x640(%rsp), %xmm2
movdqa 0x30(%rsp), %xmm1
movdqa 0xf0(%rsp), %xmm0
movdqa %xmm2, 0x5cf0(%rsp)
movdqa %xmm1, 0x5ce0(%rsp)
movdqa %xmm0, 0x5cd0(%rsp)
movdqa 0x5cf0(%rsp), %xmm1
movdqa 0x5ce0(%rsp), %xmm2
movdqa 0x5cd0(%rsp), %xmm0
pblendvb %xmm0, %xmm2, %xmm1
movaps %xmm1, %xmm0
movdqa %xmm0, 0x640(%rsp)
movq 0x4ba8(%rsp), %rax
movl 0x4b84(%rsp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movdqa 0x4a0(%rsp), %xmm0
movq %rax, 0x5e88(%rsp)
movdqa %xmm0, 0x5e70(%rsp)
movdqa 0x5e70(%rsp), %xmm0
movq 0x5e88(%rsp), %rax
movdqu %xmm0, (%rax)
movq 0x4ba8(%rsp), %rax
movl 0x4b84(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movdqa 0x160(%rsp), %xmm0
movq %rax, 0x5e68(%rsp)
movdqa %xmm0, 0x5e50(%rsp)
movdqa 0x5e50(%rsp), %xmm0
movq 0x5e68(%rsp), %rax
movdqu %xmm0, (%rax)
movl 0x4b84(%rsp), %eax
addl $0x20, %eax
movl %eax, 0x4b84(%rsp)
jmp 0xb192a
leaq 0x6e0(%rsp), %rax
movdqa 0x6b0(%rsp), %xmm0
movq %rax, 0x5f88(%rsp)
movdqa %xmm0, 0x5f70(%rsp)
movdqa 0x5f70(%rsp), %xmm0
movq 0x5f88(%rsp), %rax
movdqa %xmm0, (%rax)
leaq 0x6e0(%rsp), %rax
addq $0x10, %rax
movdqa 0x6a0(%rsp), %xmm0
movq %rax, 0x5f68(%rsp)
movdqa %xmm0, 0x5f50(%rsp)
movdqa 0x5f50(%rsp), %xmm0
movq 0x5f68(%rsp), %rax
movdqa %xmm0, (%rax)
leaq 0x6e0(%rsp), %rax
addq $0x20, %rax
movdqa 0x690(%rsp), %xmm0
movq %rax, 0x5f48(%rsp)
movdqa %xmm0, 0x5f30(%rsp)
movdqa 0x5f30(%rsp), %xmm0
movq 0x5f48(%rsp), %rax
movdqa %xmm0, (%rax)
leaq 0x6e0(%rsp), %rax
addq $0x30, %rax
movdqa 0x680(%rsp), %xmm0
movq %rax, 0x5f28(%rsp)
movdqa %xmm0, 0x5f10(%rsp)
movdqa 0x5f10(%rsp), %xmm0
movq 0x5f28(%rsp), %rax
movdqa %xmm0, (%rax)
leaq 0x6e0(%rsp), %rax
addq $0x40, %rax
movdqa 0x670(%rsp), %xmm0
movq %rax, 0x5f08(%rsp)
movdqa %xmm0, 0x5ef0(%rsp)
movdqa 0x5ef0(%rsp), %xmm0
movq 0x5f08(%rsp), %rax
movdqa %xmm0, (%rax)
leaq 0x6e0(%rsp), %rax
addq $0x50, %rax
movdqa 0x660(%rsp), %xmm0
movq %rax, 0x5ee8(%rsp)
movdqa %xmm0, 0x5ed0(%rsp)
movdqa 0x5ed0(%rsp), %xmm0
movq 0x5ee8(%rsp), %rax
movdqa %xmm0, (%rax)
leaq 0x6e0(%rsp), %rax
addq $0x60, %rax
movdqa 0x650(%rsp), %xmm0
movq %rax, 0x5ec8(%rsp)
movdqa %xmm0, 0x5eb0(%rsp)
movdqa 0x5eb0(%rsp), %xmm0
movq 0x5ec8(%rsp), %rax
movdqa %xmm0, (%rax)
leaq 0x6e0(%rsp), %rax
addq $0x70, %rax
movdqa 0x640(%rsp), %xmm0
movq %rax, 0x5ea8(%rsp)
movdqa %xmm0, 0x5e90(%rsp)
movdqa 0x5e90(%rsp), %xmm0
movq 0x5ea8(%rsp), %rax
movdqa %xmm0, (%rax)
movl 0x4ba4(%rsp), %eax
andl $0x1f, %eax
movl %eax, 0x774(%rsp)
movl 0x774(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x774(%rsp)
cmpl $0x0, %eax
jle 0xb47e5
movslq 0x774(%rsp), %rax
movl 0x6e0(%rsp,%rax,4), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, %eax
movl 0xb80(%rsp,%rax,4), %eax
movb %al, %dl
movq 0x4ba8(%rsp), %rax
movl 0x6d4(%rsp), %ecx
addl 0x774(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xb4790
movq 0x4ba8(%rsp), %rax
movq %rax, 0x4bc0(%rsp)
jmp 0xb4810
movq 0x4b90(%rsp), %rdi
callq 0x45a0
movq $0x0, 0x4bc0(%rsp)
movq 0x4bc0(%rsp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)