// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_diag_sse2_128_8.c
// Function: parasail_nw_rowcol_diag_sse2_128_8
parasail_result_t* FNAME(
        const char * const restrict _s1, const int _s1Len,
        const char * const restrict _s2, const int s2Len,
        const int open, const int gap, const parasail_matrix_t *matrix)
{
    /* declare local variables */
    int32_t N = 0;
    int32_t PAD = 0;
    int32_t PAD2 = 0;
    int32_t s1Len = 0;
    int32_t s1Len_PAD = 0;
    int32_t s2Len_PAD = 0;
    int8_t * restrict s1 = NULL;
    int8_t * restrict s2B = NULL;
    int8_t * restrict _H_pr = NULL;
    int8_t * restrict _F_pr = NULL;
    int8_t * restrict s2 = NULL;
    int8_t * restrict H_pr = NULL;
    int8_t * restrict F_pr = NULL;
    parasail_result_t *result = NULL;
    int32_t i = 0;
    int32_t j = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    int8_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vNegInf;
    __m128i vOpen;
    __m128i vGap;
    __m128i vOne;
    __m128i vN;
    __m128i vGapN;
    __m128i vNegOne;
    __m128i vI;
    __m128i vJreset;
    __m128i vMax;
    __m128i vILimit;
    __m128i vILimit1;
    __m128i vJLimit;
    __m128i vJLimit1;
    __m128i vIBoundary;

    /* validate inputs */
    PARASAIL_CHECK_NULL(_s2);
    PARASAIL_CHECK_GT0(s2Len);
    PARASAIL_CHECK_GE0(open);
    PARASAIL_CHECK_GE0(gap);
    PARASAIL_CHECK_NULL(matrix);
    if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
        PARASAIL_CHECK_NULL(_s1);
        PARASAIL_CHECK_GT0(_s1Len);
    }

    /* initialize stack variables */
    N = 16; /* number of values in vector */
    PAD = N-1;
    PAD2 = PAD*2;
    s1Len = matrix->type == PARASAIL_MATRIX_TYPE_SQUARE ? _s1Len : matrix->length;
    s1Len_PAD = s1Len+PAD;
    s2Len_PAD = s2Len+PAD;
    i = 0;
    j = 0;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInf = _mm_set1_epi8(NEG_LIMIT);
    vOpen = _mm_set1_epi8(open);
    vGap  = _mm_set1_epi8(gap);
    vOne = _mm_set1_epi8(1);
    vN = _mm_set1_epi8(N);
    vGapN = _mm_set1_epi8(gap*N);
    vNegOne = _mm_set1_epi8(-1);
    vI = _mm_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);
    vJreset = _mm_set_epi8(0,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15);
    vMax = vNegInf;
    vILimit = _mm_set1_epi8(s1Len);
    vILimit1 = _mm_subs_epi8(vILimit, vOne);
    vJLimit = _mm_set1_epi8(s2Len);
    vJLimit1 = _mm_subs_epi8(vJLimit, vOne);
    vIBoundary = _mm_set_epi8(
            -open-0*gap,
            -open-1*gap,
            -open-2*gap,
            -open-3*gap,
            -open-4*gap,
            -open-5*gap,
            -open-6*gap,
            -open-7*gap,
            -open-8*gap,
            -open-9*gap,
            -open-10*gap,
            -open-11*gap,
            -open-12*gap,
            -open-13*gap,
            -open-14*gap,
            -open-15*gap);

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(s1Len, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(s1Len, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_DIAG
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    s2B= parasail_memalign_int8_t(16, s2Len+PAD2);
    _H_pr = parasail_memalign_int8_t(16, s2Len+PAD2);
    _F_pr = parasail_memalign_int8_t(16, s2Len+PAD2);
    s2 = s2B+PAD; /* will allow later for negative indices */
    H_pr = _H_pr+PAD;
    F_pr = _F_pr+PAD;

    /* validate heap variables */
    if (!s2B) return NULL;
    if (!_H_pr) return NULL;
    if (!_F_pr) return NULL;

    /* convert _s1 from char to int in range 0-23 */
    if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
        s1 = parasail_memalign_int8_t(16, s1Len+PAD);
        if (!s1) return NULL;
        for (i=0; i<s1Len; ++i) {
            s1[i] = matrix->mapper[(unsigned char)_s1[i]];
        }
        /* pad back of s1 with dummy values */
        for (i=s1Len; i<s1Len_PAD; ++i) {
            s1[i] = 0; /* point to first matrix row because we don't care */
        }
    }

    /* convert _s2 from char to int in range 0-23 */
    for (j=0; j<s2Len; ++j) {
        s2[j] = matrix->mapper[(unsigned char)_s2[j]];
    }
    /* pad front of s2 with dummy values */
    for (j=-PAD; j<0; ++j) {
        s2[j] = 0; /* point to first matrix row because we don't care */
    }
    /* pad back of s2 with dummy values */
    for (j=s2Len; j<s2Len_PAD; ++j) {
        s2[j] = 0; /* point to first matrix row because we don't care */
    }

    /* set initial values for stored row */
    for (j=0; j<s2Len; ++j) {
        H_pr[j] = -open - j*gap;
        F_pr[j] = NEG_LIMIT;
    }
    /* pad front of stored row values */
    for (j=-PAD; j<0; ++j) {
        H_pr[j] = NEG_LIMIT;
        F_pr[j] = NEG_LIMIT;
    }
    /* pad back of stored row values */
    for (j=s2Len; j<s2Len+PAD; ++j) {
        H_pr[j] = NEG_LIMIT;
        F_pr[j] = NEG_LIMIT;
    }
    H_pr[-1] = 0; /* upper left corner */

    /* iterate over query sequence */
    for (i=0; i<s1Len; i+=N) {
        __m128i vNH = vNegInf;
        __m128i vWH = vNegInf;
        __m128i vE = vNegInf;
        __m128i vF = vNegInf;
        __m128i vJ = vJreset;
        const int * const restrict matrow0 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+0] : ((i+0 >= s1Len) ? s1Len-1 : i+0))];
        const int * const restrict matrow1 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+1] : ((i+1 >= s1Len) ? s1Len-1 : i+1))];
        const int * const restrict matrow2 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+2] : ((i+2 >= s1Len) ? s1Len-1 : i+2))];
        const int * const restrict matrow3 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+3] : ((i+3 >= s1Len) ? s1Len-1 : i+3))];
        const int * const restrict matrow4 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+4] : ((i+4 >= s1Len) ? s1Len-1 : i+4))];
        const int * const restrict matrow5 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+5] : ((i+5 >= s1Len) ? s1Len-1 : i+5))];
        const int * const restrict matrow6 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+6] : ((i+6 >= s1Len) ? s1Len-1 : i+6))];
        const int * const restrict matrow7 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+7] : ((i+7 >= s1Len) ? s1Len-1 : i+7))];
        const int * const restrict matrow8 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+8] : ((i+8 >= s1Len) ? s1Len-1 : i+8))];
        const int * const restrict matrow9 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+9] : ((i+9 >= s1Len) ? s1Len-1 : i+9))];
        const int * const restrict matrow10 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+10] : ((i+10 >= s1Len) ? s1Len-1 : i+10))];
        const int * const restrict matrow11 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+11] : ((i+11 >= s1Len) ? s1Len-1 : i+11))];
        const int * const restrict matrow12 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+12] : ((i+12 >= s1Len) ? s1Len-1 : i+12))];
        const int * const restrict matrow13 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+13] : ((i+13 >= s1Len) ? s1Len-1 : i+13))];
        const int * const restrict matrow14 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+14] : ((i+14 >= s1Len) ? s1Len-1 : i+14))];
        const int * const restrict matrow15 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+15] : ((i+15 >= s1Len) ? s1Len-1 : i+15))];
        vNH = _mm_srli_si128(vNH, 1);
        vNH = _mm_insert_epi8_rpl(vNH, H_pr[-1], 15);
        vWH = _mm_srli_si128(vWH, 1);
        vWH = _mm_insert_epi8_rpl(vWH, -open - i*gap, 15);
        H_pr[-1] = -open - (i+N)*gap;
        /* iterate over database sequence */
        for (j=0; j<s2Len+PAD; ++j) {
            __m128i vMat;
            __m128i vNWH = vNH;
            vNH = _mm_srli_si128(vWH, 1);
            vNH = _mm_insert_epi8_rpl(vNH, H_pr[j], 15);
            vF = _mm_srli_si128(vF, 1);
            vF = _mm_insert_epi8_rpl(vF, F_pr[j], 15);
            vF = _mm_max_epi8_rpl(
                    _mm_subs_epi8(vNH, vOpen),
                    _mm_subs_epi8(vF, vGap));
            vE = _mm_max_epi8_rpl(
                    _mm_subs_epi8(vWH, vOpen),
                    _mm_subs_epi8(vE, vGap));
            vMat = _mm_set_epi8(
                    matrow0[s2[j-0]],
                    matrow1[s2[j-1]],
                    matrow2[s2[j-2]],
                    matrow3[s2[j-3]],
                    matrow4[s2[j-4]],
                    matrow5[s2[j-5]],
                    matrow6[s2[j-6]],
                    matrow7[s2[j-7]],
                    matrow8[s2[j-8]],
                    matrow9[s2[j-9]],
                    matrow10[s2[j-10]],
                    matrow11[s2[j-11]],
                    matrow12[s2[j-12]],
                    matrow13[s2[j-13]],
                    matrow14[s2[j-14]],
                    matrow15[s2[j-15]]
                    );
            vNWH = _mm_adds_epi8(vNWH, vMat);
            vWH = _mm_max_epi8_rpl(vNWH, vE);
            vWH = _mm_max_epi8_rpl(vWH, vF);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m128i cond = _mm_cmpeq_epi8(vJ,vNegOne);
                vWH = _mm_blendv_epi8_rpl(vWH, vIBoundary, cond);
                vF = _mm_blendv_epi8_rpl(vF, vNegInf, cond);
                vE = _mm_blendv_epi8_rpl(vE, vNegInf, cond);
            }
            /* cannot start checking sat until after J clears boundary */
            if (j > PAD) {
                vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vWH);
            }
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vWH, i, s1Len, j, s2Len);
#endif
#ifdef PARASAIL_ROWCOL
            arr_store_rowcol(result->rowcols->score_row, result->rowcols->score_col, vWH, i, s1Len, j, s2Len);
#endif
            H_pr[j-15] = (int8_t)_mm_extract_epi8_rpl(vWH,0);
            F_pr[j-15] = (int8_t)_mm_extract_epi8_rpl(vF,0);
            /* as minor diagonal vector passes across table, extract
               last table value at the i,j bound */
            {
                __m128i cond_valid_I = _mm_cmpeq_epi8(vI, vILimit1);
                __m128i cond_valid_J = _mm_cmpeq_epi8(vJ, vJLimit1);
                __m128i cond_all = _mm_and_si128(cond_valid_I, cond_valid_J);
                vMax = _mm_blendv_epi8_rpl(vMax, vWH, cond_all);
            }
            vJ = _mm_adds_epi8(vJ, vOne);
        }
        vI = _mm_adds_epi8(vI, vN);
        vIBoundary = _mm_subs_epi8(vIBoundary, vGapN);
    }

    /* max in vMax */
    for (i=0; i<N; ++i) {
        int8_t value;
        value = (int8_t) _mm_extract_epi8_rpl(vMax, 15);
        if (value > score) {
            score = value;
        }
        vMax = _mm_slli_si128(vMax, 1);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi8(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi8(vSaturationCheckMax, vPosLimit)))) {
        result->flag |= PARASAIL_FLAG_SATURATED;
        score = 0;
        end_query = 0;
        end_ref = 0;
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(_F_pr);
    parasail_free(_H_pr);
    parasail_free(s2B);
    if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
        parasail_free(s1);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
testq %rdx, %rdx
je 0x34877a
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x348781
movl %r8d, %ebp
testl %r8d, %r8d
js 0x348788
testl %r9d, %r9d
js 0x34878f
movq 0x300(%rsp), %r8
testq %r8, %r8
je 0x348796
movl 0x30(%r8), %eax
testl %eax, %eax
jne 0x347286
testq %rdi, %rdi
je 0x34879d
movl %esi, %ebx
testl %esi, %esi
jle 0x3487a4
testl %eax, %eax
je 0x34728a
movl 0x34(%r8), %ebx
movq %rdi, (%rsp)
movq %rdx, 0xa0(%rsp)
movq %r9, 0xb8(%rsp)
movl %ebp, %esi
negl %esi
movl 0x20(%r8), %eax
movl %eax, %ecx
negb %cl
movl %esi, 0x5c(%rsp)
cmpl %esi, %eax
movzbl %cl, %r12d
cmovgl %ebp, %r12d
movb $0x7e, %r15b
subb 0x1c(%r8), %r15b
movl %ebx, %edi
movl %r14d, %esi
callq 0x209630
testq %rax, %rax
je 0x3487a9
movb %r15b, 0xf0(%rsp)
movq %rbx, 0x60(%rsp)
movq %rax, 0xd8(%rsp)
orl $0x10141001, 0xc(%rax)  # imm = 0x10141001
leal 0x1e(%r14), %r13d
movl $0x10, %edi
movq %r13, %rsi
callq 0x2094c8
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x2094c8
movq %rax, %rbx
movl $0x10, %edi
movq %r13, %rsi
callq 0x2094c8
testq %r15, %r15
sete %dl
testq %rbx, %rbx
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x3487a9
movq 0x300(%rsp), %rdi
cmpl $0x0, 0x30(%rdi)
movq %rbx, 0xc0(%rsp)
movq %rax, 0xd0(%rsp)
je 0x34736c
movq $0x0, 0x78(%rsp)
movq 0x60(%rsp), %rbx
jmp 0x3473ec
movq 0x60(%rsp), %rbx
leal 0xf(%rbx), %r13d
movslq %r13d, %rsi
movl $0x10, %edi
callq 0x2094c8
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x3487a9
testl %ebx, %ebx
movq 0x300(%rsp), %rdi
movq 0x78(%rsp), %r8
movq (%rsp), %r9
jle 0x3473c1
movl %ebx, %eax
xorl %ecx, %ecx
movq 0x10(%rdi), %rdx
movzbl (%r9,%rcx), %esi
movb (%rdx,%rsi,4), %dl
movb %dl, (%r8,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x3473a9
movslq %ebx, %rax
movq %r8, %rdi
addq %rax, %rdi
leal 0x1(%rbx), %eax
cmpl %eax, %r13d
cmovgl %r13d, %eax
movl %ebx, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x300(%rsp), %rdi
leal 0xf(%r14), %eax
movl %eax, (%rsp)
addb $-0x7f, %r12b
movl %r12d, 0x58(%rsp)
movzbl %r12b, %eax
movd %eax, %xmm0
movzbl 0xf0(%rsp), %eax
movd %eax, %xmm1
movq 0xb8(%rsp), %r8
movl 0x5c(%rsp), %r9d
movl %r9d, %eax
subl %r8d, %eax
subl %r8d, %eax
leal (,%r8,4), %edx
movl %r9d, %ecx
subl %edx, %ecx
leal (,%r8,8), %esi
movl %r9d, %edx
subl %esi, %edx
leal -0x1(%rbx), %esi
movl %esi, 0xc(%rsp)
movd %ebx, %xmm2
punpcklbw %xmm2, %xmm2    # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm2, %xmm3      # xmm3 = xmm2[0,0,0,0]
pcmpeqd %xmm2, %xmm2
paddsb %xmm2, %xmm3
movdqa %xmm3, 0x250(%rsp)
movd %r14d, %xmm3
punpcklbw %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
paddsb %xmm2, %xmm3
movdqa %xmm3, 0x290(%rsp)
movd %edx, %xmm5
imull $0xf7, %r8d, %edx
subl %ebp, %edx
movd %edx, %xmm4
imull $0xf6, %r8d, %edx
subl %ebp, %edx
movd %edx, %xmm7
imull $0xf5, %r8d, %edx
subl %ebp, %edx
movd %edx, %xmm2
imull $0xf4, %r8d, %edx
subl %ebp, %edx
movd %edx, %xmm8
imull $0xf3, %r8d, %edx
subl %ebp, %edx
movd %edx, %xmm3
imull $0xf2, %r8d, %edx
subl %ebp, %edx
movd %edx, %xmm6
imull $0xf1, %r8d, %edx
subl %ebp, %edx
movd %edx, %xmm9
leal -0x1(%r14), %edx
movl %edx, 0x8(%rsp)
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xe0(%rsp)
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm0      # xmm0 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x120(%rsp)
punpcklbw %xmm5, %xmm4    # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1],xmm4[2],xmm5[2],xmm4[3],xmm5[3],xmm4[4],xmm5[4],xmm4[5],xmm5[5],xmm4[6],xmm5[6],xmm4[7],xmm5[7]
movd %ebp, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
punpcklbw %xmm7, %xmm2    # xmm2 = xmm2[0],xmm7[0],xmm2[1],xmm7[1],xmm2[2],xmm7[2],xmm2[3],xmm7[3],xmm2[4],xmm7[4],xmm2[5],xmm7[5],xmm2[6],xmm7[6],xmm2[7],xmm7[7]
movd %r8d, %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
punpcklwd %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1],xmm2[2],xmm4[2],xmm2[3],xmm4[3]
movdqa %xmm1, 0x280(%rsp)
psllw $0x4, %xmm1
pand 0x2ae6ed(%rip), %xmm1   # 0x5f5c50
movdqa %xmm1, 0x240(%rsp)
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x270(%rsp)
punpcklbw %xmm8, %xmm3    # xmm3 = xmm3[0],xmm8[0],xmm3[1],xmm8[1],xmm3[2],xmm8[2],xmm3[3],xmm8[3],xmm3[4],xmm8[4],xmm3[5],xmm8[5],xmm3[6],xmm8[6],xmm3[7],xmm8[7]
movd %ecx, %xmm0
imull $0xfb, %r8d, %ecx
subl %ebp, %ecx
punpcklbw %xmm6, %xmm9    # xmm9 = xmm9[0],xmm6[0],xmm9[1],xmm6[1],xmm9[2],xmm6[2],xmm9[3],xmm6[3],xmm9[4],xmm6[4],xmm9[5],xmm6[5],xmm9[6],xmm6[6],xmm9[7],xmm6[7]
movd %ecx, %xmm1
imull $0xfa, %r8d, %ecx
subl %ebp, %ecx
punpcklwd %xmm3, %xmm9    # xmm9 = xmm9[0],xmm3[0],xmm9[1],xmm3[1],xmm9[2],xmm3[2],xmm9[3],xmm3[3]
movd %ecx, %xmm3
imull $0xf9, %r8d, %ecx
subl %ebp, %ecx
punpckldq %xmm2, %xmm9    # xmm9 = xmm9[0],xmm2[0],xmm9[1],xmm2[1]
movd %ecx, %xmm2
movl %r9d, %ecx
subl %r8d, %ecx
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
movd %eax, %xmm0
imull $0xfd, %r8d, %eax
subl %ebp, %eax
punpcklbw %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1],xmm2[2],xmm3[2],xmm2[3],xmm3[3],xmm2[4],xmm3[4],xmm2[5],xmm3[5],xmm2[6],xmm3[6],xmm2[7],xmm3[7]
punpcklwd %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
movd %eax, %xmm1
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
movd %ecx, %xmm0
movd %r9d, %xmm3
punpcklbw %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3],xmm0[4],xmm3[4],xmm0[5],xmm3[5],xmm0[6],xmm3[6],xmm0[7],xmm3[7]
punpcklwd %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3]
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
punpcklqdq %xmm2, %xmm9    # xmm9 = xmm9[0],xmm2[0]
movdqa %xmm9, 0xf0(%rsp)
cmpl $0x2, %r14d
movl $0x1, %r13d
cmovgel %r14d, %r13d
xorl %eax, %eax
movq 0xa0(%rsp), %rsi
movq 0x10(%rdi), %rcx
movzbl (%rsi,%rax), %edx
movb (%rcx,%rdx,4), %cl
movb %cl, 0xf(%r15,%rax)
incq %rax
cmpq %rax, %r13
jne 0x34761c
xorl %r12d, %r12d
movq %r12, 0x7(%r15)
movq %r12, (%r15)
movl %r14d, %ebx
leaq (%rbx,%r15), %rdi
addq $0xf, %rdi
leal 0x1(%r14), %eax
movl (%rsp), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %r14d, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
negb %bpl
movq 0xb8(%rsp), %rax
movl 0x58(%rsp), %edx
movq 0xc0(%rsp), %r11
movq 0xd0(%rsp), %rdi
movb %bpl, 0xf(%r11,%r12)
movb %dl, 0xf(%rdi,%r12)
incq %r12
subb %al, %bpl
cmpq %r12, %r13
jne 0x347685
xorl %eax, %eax
movb %dl, (%r11,%rax)
movb %dl, (%rdi,%rax)
incq %rax
cmpq $0xf, %rax
jne 0x34769c
leaq 0xf(%rbx), %rax
movq 0xd8(%rsp), %r13
movq 0x300(%rsp), %rcx
movq 0x78(%rsp), %r12
movl 0xc(%rsp), %r10d
movl (%rsp), %esi
movb %dl, (%r11,%rax)
movb %dl, (%rdi,%rax)
incq %rax
incl %r14d
cmpl %r14d, %esi
jg 0x3476cd
movb $0x0, 0xe(%r11)
movdqa 0xe0(%rsp), %xmm0
movdqa %xmm0, %xmm2
movdqa %xmm0, 0x110(%rsp)
movdqa 0x120(%rsp), %xmm0
movdqa %xmm0, 0x100(%rsp)
movq 0x60(%rsp), %rdx
testl %edx, %edx
movq %r12, %r14
jle 0x3486c8
movdqa 0xe0(%rsp), %xmm0
movdqa %xmm0, %xmm1
psrldq $0x1, %xmm1             # xmm1 = xmm1[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
movq %rax, 0x1c0(%rsp)
movl 0x8(%rsp), %eax
movq %rax, 0x1b8(%rsp)
movl %edx, %edx
movl %r10d, %esi
leaq 0x1(%rbx), %rax
movq %rax, 0x1b0(%rsp)
leaq 0x2(%rbx), %rax
movq %rax, 0x1a8(%rsp)
leaq 0x3(%rbx), %rax
movq %rax, 0x1a0(%rsp)
leaq 0x4(%rbx), %rax
movq %rax, 0x198(%rsp)
leaq 0x5(%rbx), %rax
movq %rax, 0x190(%rsp)
leaq 0x6(%rbx), %rax
movq %rax, 0x188(%rsp)
leaq 0x7(%rbx), %rax
movq %rax, 0x180(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, 0x178(%rsp)
leaq 0x9(%rbx), %rax
movq %rax, 0x170(%rsp)
leaq 0xa(%rbx), %rax
movq %rax, 0x168(%rsp)
leaq 0xb(%rbx), %rax
movq %rax, 0x160(%rsp)
pand 0x2ae482(%rip), %xmm1   # 0x5f5c60
movdqa %xmm1, 0x230(%rsp)
movdqa 0x2ae2c1(%rip), %xmm3   # 0x5f5ab0
movdqa 0x120(%rsp), %xmm1
movdqa %xmm1, 0x100(%rsp)
movdqa %xmm0, 0x110(%rsp)
movdqa %xmm0, %xmm2
leaq 0xc(%rbx), %rax
movq %rax, 0x158(%rsp)
leaq 0xd(%rbx), %rax
movq %rax, 0x150(%rsp)
leaq 0xe(%rbx), %rax
movq %rax, 0x148(%rsp)
xorl %eax, %eax
movl 0x30(%rcx), %r12d
movl %eax, %edi
testl %r12d, %r12d
jne 0x347844
movsbl (%r14,%rax), %edi
movl %edi, 0xa0(%rsp)
movq %rax, %rdi
orq $0x1, %rdi
testl %r12d, %r12d
je 0x347863
cmpq %rdx, %rdi
movl %r10d, %r8d
cmovbl %edi, %r8d
jmp 0x347868
movsbl (%r14,%rdi), %r8d
movl %r8d, 0x60(%rsp)
movq %rax, %r8
orq $0x2, %r8
testl %r12d, %r12d
movq %r8, 0x220(%rsp)
je 0x347891
cmpq %rdx, %r8
movl %r10d, %ebp
cmovbl %r8d, %ebp
movl %ebp, 0x50(%rsp)
jmp 0x34789b
movsbl (%r14,%r8), %r8d
movl %r8d, 0x50(%rsp)
movq %rax, %r8
orq $0x3, %r8
testl %r12d, %r12d
movq %r8, 0x218(%rsp)
je 0x3478bf
cmpq %rdx, %r8
movl %r10d, %ebp
cmovbl %r8d, %ebp
movl %ebp, 0x48(%rsp)
jmp 0x3478c9
movsbl (%r14,%r8), %r8d
movl %r8d, 0x48(%rsp)
movq %rax, %r8
orq $0x4, %r8
testl %r12d, %r12d
movq %r8, 0x210(%rsp)
je 0x3478ed
cmpq %rdx, %r8
movl %r10d, %ebp
cmovbl %r8d, %ebp
movl %ebp, 0x40(%rsp)
jmp 0x3478f7
movsbl (%r14,%r8), %r8d
movl %r8d, 0x40(%rsp)
movq %rax, %r8
orq $0x5, %r8
testl %r12d, %r12d
movq %r8, 0x208(%rsp)
je 0x34791b
cmpq %rdx, %r8
movl %r10d, %ebp
cmovbl %r8d, %ebp
movl %ebp, 0x38(%rsp)
jmp 0x347925
movsbl (%r14,%r8), %r8d
movl %r8d, 0x38(%rsp)
movq %rax, %r8
orq $0x6, %r8
testl %r12d, %r12d
movq %rax, (%rsp)
movq %rdi, 0x228(%rsp)
movq %r8, 0x200(%rsp)
je 0x347951
cmpq %rdx, %r8
movl %r10d, %eax
cmovbl %r8d, %eax
jmp 0x347956
movsbl (%r14,%r8), %eax
movl %eax, 0x30(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0xc8(%rsp)
movl 0x18(%rcx), %edi
movq (%rsp), %rax
orq $0x7, %rax
testl %r12d, %r12d
movq %rax, 0x1f8(%rsp)
je 0x34798d
cmpq %rdx, %rax
movl %r10d, %ecx
cmovbl %eax, %ecx
movl %ecx, 0x28(%rsp)
jmp 0x347996
movsbl (%r14,%rax), %eax
movl %eax, 0x28(%rsp)
movq (%rsp), %rax
orq $0x8, %rax
testl %r12d, %r12d
movq %rax, 0x1f0(%rsp)
je 0x3479ba
cmpq %rdx, %rax
movl %r10d, %ecx
cmovbl %eax, %ecx
movl %ecx, 0x20(%rsp)
jmp 0x3479c3
movsbl (%r14,%rax), %eax
movl %eax, 0x20(%rsp)
movq (%rsp), %rax
orq $0x9, %rax
testl %r12d, %r12d
movq %rax, 0x1e8(%rsp)
je 0x3479e7
cmpq %rdx, %rax
movl %r10d, %ecx
cmovbl %eax, %ecx
movl %ecx, 0x18(%rsp)
jmp 0x3479f0
movsbl (%r14,%rax), %eax
movl %eax, 0x18(%rsp)
movq (%rsp), %rax
orq $0xa, %rax
testl %r12d, %r12d
movq %rax, 0x1e0(%rsp)
je 0x347a14
cmpq %rdx, %rax
movl %r10d, %ecx
cmovbl %eax, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x347a1d
movsbl (%r14,%rax), %eax
movl %eax, 0x10(%rsp)
movq (%rsp), %rax
orq $0xb, %rax
testl %r12d, %r12d
movq %rax, 0x1d8(%rsp)
je 0x347a47
movq %r14, %r8
cmpq %rdx, %rax
movl %r10d, %ecx
cmovbl %eax, %ecx
movl %ecx, 0x98(%rsp)
jmp 0x347a56
movq %r14, %r8
movsbl (%r14,%rax), %eax
movl %eax, 0x98(%rsp)
movq (%rsp), %r14
orq $0xc, %r14
testl %r12d, %r12d
je 0x347a6f
cmpq %rdx, %r14
movl %r10d, %eax
cmovbl %r14d, %eax
jmp 0x347a74
movsbl (%r8,%r14), %eax
movl %eax, 0x90(%rsp)
movq (%rsp), %rbp
orq $0xd, %rbp
testl %r12d, %r12d
je 0x347a93
cmpq %rdx, %rbp
movl %r10d, %eax
cmovbl %ebp, %eax
jmp 0x347a98
movsbl (%r8,%rbp), %eax
movl %eax, 0x88(%rsp)
movq (%rsp), %rax
orq $0xe, %rax
testl %r12d, %r12d
je 0x347abd
cmpq %rdx, %rax
cmovbl %eax, %r10d
movl %r10d, 0x80(%rsp)
jmp 0x347ac9
movsbl (%r8,%rax), %ecx
movl %ecx, 0x80(%rsp)
movq (%rsp), %rcx
orq $0xf, %rcx
testl %r12d, %r12d
je 0x347ae4
cmpq %rdx, %rcx
movl 0xc(%rsp), %r13d
cmovbl %ecx, %r13d
jmp 0x347ae9
movsbl (%r8,%rcx), %r13d
movl 0xa0(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0xa0(%rsp)
movl 0x60(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x60(%rsp)
movl 0x50(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x50(%rsp)
movl 0x48(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x48(%rsp)
movl 0x40(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x40(%rsp)
movl 0x38(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x38(%rsp)
movl 0x30(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x30(%rsp)
movl 0x28(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x28(%rsp)
movl 0x20(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x20(%rsp)
movl 0x18(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x18(%rsp)
movl 0x10(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x10(%rsp)
movl 0x98(%rsp), %r10d
imull %edi, %r10d
movl 0x90(%rsp), %r12d
imull %edi, %r12d
movl 0x88(%rsp), %r9d
imull %edi, %r9d
movl 0x80(%rsp), %r8d
imull %edi, %r8d
imull %edi, %r13d
movl %r13d, 0x130(%rsp)
movslq 0xa0(%rsp), %rdi
movq 0xc8(%rsp), %r13
leaq (,%rdi,4), %rdi
addq %r13, %rdi
movq %rdi, 0x98(%rsp)
movslq 0x60(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x90(%rsp)
movslq 0x50(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x50(%rsp)
movslq 0x48(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x48(%rsp)
movslq 0x40(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x40(%rsp)
movslq 0x38(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x38(%rsp)
movslq 0x30(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x30(%rsp)
movslq 0x28(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x28(%rsp)
movslq 0x20(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x20(%rsp)
movslq 0x18(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x18(%rsp)
movslq 0x10(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x10(%rsp)
movslq %r10d, %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x88(%rsp)
movslq %r12d, %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x80(%rsp)
movslq %r9d, %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x1d0(%rsp)
movslq %r8d, %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0x1c8(%rsp)
movslq 0x130(%rsp), %rdi
leaq (%r13,%rdi,4), %rdi
movq %rdi, 0xc8(%rsp)
movq (%rsp), %r12
leaq 0x10(%r12), %rdi
movq %rdi, 0x140(%rsp)
movq 0xb8(%rsp), %r9
imull %r9d, %edi
movl 0x5c(%rsp), %r10d
movl %r10d, %r8d
subl %edi, %r8d
movzbl 0xe(%r11), %edi
movb %r8b, 0xe(%r11)
movl %r12d, %r8d
imull %r9d, %r8d
movl %r10d, %r9d
subl %r8d, %r9d
movd %r9d, %xmm12
movd %edi, %xmm6
pslldq $0xf, %xmm12            # xmm12 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm12[0]
movdqa 0x230(%rsp), %xmm0
por %xmm0, %xmm12
pslldq $0xf, %xmm6             # xmm6 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm6[0]
por %xmm0, %xmm6
movdqa %xmm3, 0x260(%rsp)
pcmpeqb 0x250(%rsp), %xmm3
movdqa %xmm3, 0x130(%rsp)
movdqa 0x2adf13(%rip), %xmm5   # 0x5f5c70
movdqa 0xe0(%rsp), %xmm11
movdqa %xmm11, %xmm13
xorl %r12d, %r12d
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %r13
movdqa %xmm2, 0xa0(%rsp)
movdqa %xmm6, 0x60(%rsp)
movzbl 0xf(%r11,%r12), %r8d
movd %r8d, %xmm14
movzbl 0xf(%rdi,%r12), %r8d
movd %r8d, %xmm15
movsbq 0xf(%r15,%r12), %r8
movq 0x98(%rsp), %rdi
movd (%rdi,%r8,4), %xmm3
movsbq 0xe(%r15,%r12), %r8
movq 0x90(%rsp), %rdi
movd (%rdi,%r8,4), %xmm6
movsbq 0xd(%r15,%r12), %r8
movq 0x50(%rsp), %rdi
movd (%rdi,%r8,4), %xmm9
movsbq 0xc(%r15,%r12), %r8
movq 0x48(%rsp), %rdi
movd (%rdi,%r8,4), %xmm8
movsbq 0xb(%r15,%r12), %r8
movq 0x40(%rsp), %rdi
movd (%rdi,%r8,4), %xmm7
movsbq 0xa(%r15,%r12), %r8
movq 0x38(%rsp), %rdi
movd (%rdi,%r8,4), %xmm4
movsbq 0x9(%r15,%r12), %r8
movq 0x30(%rsp), %rdi
movd (%rdi,%r8,4), %xmm1
movsbq 0x8(%r15,%r12), %r8
movq 0x28(%rsp), %rdi
movd (%rdi,%r8,4), %xmm0
movsbq 0x7(%r15,%r12), %r8
movq 0x20(%rsp), %rdi
movd (%rdi,%r8,4), %xmm2
movsbq 0x6(%r15,%r12), %r8
movq 0x18(%rsp), %rdi
movd (%rdi,%r8,4), %xmm10
movsbq 0x5(%r15,%r12), %r8
punpcklbw %xmm3, %xmm6    # xmm6 = xmm6[0],xmm3[0],xmm6[1],xmm3[1],xmm6[2],xmm3[2],xmm6[3],xmm3[3],xmm6[4],xmm3[4],xmm6[5],xmm3[5],xmm6[6],xmm3[6],xmm6[7],xmm3[7]
movq 0x10(%rsp), %rdi
movd (%rdi,%r8,4), %xmm3
movsbq 0x4(%r15,%r12), %r8
punpcklbw %xmm9, %xmm8    # xmm8 = xmm8[0],xmm9[0],xmm8[1],xmm9[1],xmm8[2],xmm9[2],xmm8[3],xmm9[3],xmm8[4],xmm9[4],xmm8[5],xmm9[5],xmm8[6],xmm9[6],xmm8[7],xmm9[7]
movq 0x88(%rsp), %rdi
movd (%rdi,%r8,4), %xmm9
movsbq 0x3(%r15,%r12), %r8
punpcklwd %xmm6, %xmm8    # xmm8 = xmm8[0],xmm6[0],xmm8[1],xmm6[1],xmm8[2],xmm6[2],xmm8[3],xmm6[3]
movq 0x80(%rsp), %rdi
movd (%rdi,%r8,4), %xmm6
movsbq 0x2(%r15,%r12), %r8
punpcklbw %xmm7, %xmm4    # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1],xmm4[2],xmm7[2],xmm4[3],xmm7[3],xmm4[4],xmm7[4],xmm4[5],xmm7[5],xmm4[6],xmm7[6],xmm4[7],xmm7[7]
movq 0x1d0(%rsp), %rdi
movd (%rdi,%r8,4), %xmm7
movsbq 0x1(%r15,%r12), %r8
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
movq 0x1c8(%rsp), %rdi
movd (%rdi,%r8,4), %xmm1
movsbq (%r15,%r12), %r8
punpcklwd %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1],xmm0[2],xmm4[2],xmm0[3],xmm4[3]
movq 0xc8(%rsp), %rdi
movd (%rdi,%r8,4), %xmm4
punpckldq %xmm8, %xmm0    # xmm0 = xmm0[0],xmm8[0],xmm0[1],xmm8[1]
punpcklbw %xmm2, %xmm10   # xmm10 = xmm10[0],xmm2[0],xmm10[1],xmm2[1],xmm10[2],xmm2[2],xmm10[3],xmm2[3],xmm10[4],xmm2[4],xmm10[5],xmm2[5],xmm10[6],xmm2[6],xmm10[7],xmm2[7]
punpcklbw %xmm3, %xmm9    # xmm9 = xmm9[0],xmm3[0],xmm9[1],xmm3[1],xmm9[2],xmm3[2],xmm9[3],xmm3[3],xmm9[4],xmm3[4],xmm9[5],xmm3[5],xmm9[6],xmm3[6],xmm9[7],xmm3[7]
punpcklwd %xmm10, %xmm9   # xmm9 = xmm9[0],xmm10[0],xmm9[1],xmm10[1],xmm9[2],xmm10[2],xmm9[3],xmm10[3]
punpcklbw %xmm6, %xmm7    # xmm7 = xmm7[0],xmm6[0],xmm7[1],xmm6[1],xmm7[2],xmm6[2],xmm7[3],xmm6[3],xmm7[4],xmm6[4],xmm7[5],xmm6[5],xmm7[6],xmm6[6],xmm7[7],xmm6[7]
movdqa %xmm14, %xmm6
punpcklbw %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1],xmm4[2],xmm1[2],xmm4[3],xmm1[3],xmm4[4],xmm1[4],xmm4[5],xmm1[5],xmm4[6],xmm1[6],xmm4[7],xmm1[7]
punpcklwd %xmm7, %xmm4    # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1],xmm4[2],xmm7[2],xmm4[3],xmm7[3]
punpckldq %xmm9, %xmm4    # xmm4 = xmm4[0],xmm9[0],xmm4[1],xmm9[1]
punpcklqdq %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0]
paddsb 0x60(%rsp), %xmm4
movdqa %xmm12, %xmm0
psrldq $0x1, %xmm0             # xmm0 = xmm0[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
pslldq $0xf, %xmm6             # xmm6 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm6[0]
por %xmm0, %xmm6
psrldq $0x1, %xmm13            # xmm13 = xmm13[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
pslldq $0xf, %xmm15            # xmm15 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm15[0]
por %xmm13, %xmm15
movdqa %xmm6, %xmm0
movdqa 0x270(%rsp), %xmm2
psubsb %xmm2, %xmm0
movdqa 0x280(%rsp), %xmm1
psubsb %xmm1, %xmm15
movdqa %xmm0, %xmm14
pcmpgtb %xmm15, %xmm14
pand %xmm14, %xmm0
pandn %xmm15, %xmm14
por %xmm0, %xmm14
psubsb %xmm2, %xmm12
psubsb %xmm1, %xmm11
movdqa %xmm12, %xmm15
pcmpgtb %xmm11, %xmm15
pand %xmm15, %xmm12
pandn %xmm11, %xmm15
por %xmm12, %xmm15
movdqa %xmm4, %xmm0
pcmpgtb %xmm15, %xmm0
pand %xmm0, %xmm4
pandn %xmm15, %xmm0
por %xmm4, %xmm0
movdqa %xmm0, %xmm1
pcmpgtb %xmm14, %xmm1
pand %xmm1, %xmm0
pandn %xmm14, %xmm1
por %xmm0, %xmm1
movdqa %xmm5, %xmm11
pcmpeqb 0x2adc31(%rip), %xmm11  # 0x5f5c00
movdqa %xmm11, %xmm0
pandn %xmm1, %xmm0
movdqa 0xf0(%rsp), %xmm12
pand %xmm11, %xmm12
por %xmm0, %xmm12
cmpq $0x10, %r12
jb 0x348046
movdqa 0x100(%rsp), %xmm2
movdqa %xmm2, %xmm0
pcmpgtb %xmm12, %xmm0
movdqa %xmm12, %xmm1
pand %xmm0, %xmm1
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movdqa 0x110(%rsp), %xmm2
movdqa %xmm2, %xmm1
pcmpgtb %xmm12, %xmm1
pand %xmm1, %xmm2
pandn %xmm12, %xmm1
por %xmm1, %xmm2
movdqa %xmm2, 0x110(%rsp)
movdqa %xmm0, 0x100(%rsp)
movq (%rsp), %rdi
cmpq %rsi, %rdi
setne %r10b
movq 0x10(%r13), %r8
movq (%r8), %r9
movq 0x8(%r8), %r8
cmpq %rbx, %r12
setae %r11b
orb %r10b, %r11b
pextrw $0x7, %xmm12, %r10d
movdqa 0xa0(%rsp), %xmm2
jne 0x348086
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r9,%r12,4)
cmpq %r12, 0x1b8(%rsp)
jne 0x34809f
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rdi,4)
movq 0x228(%rsp), %rdi
cmpq %rsi, %rdi
setne %r11b
leaq -0x1(%r12), %r13
cmpq %rbx, %r13
setae %r13b
orb %r11b, %r13b
jne 0x3480c8
movsbl %r10b, %r11d
movl %r11d, -0x4(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, %rbx
setne %r13b
orb %r11b, %r13b
jne 0x3480e3
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
pextrw $0x6, %xmm12, %r10d
movq 0x220(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x348123
leaq -0x2(%r12), %r11
cmpq $0x2, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x348123
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x8(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x1b0(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x34814a
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rdi,4)
movq 0x218(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x34817d
leaq -0x3(%r12), %r11
cmpq $0x3, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x34817d
movsbl %r10b, %r11d
movl %r11d, -0xc(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x1a8(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x34819d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
pextrw $0x5, %xmm12, %r10d
movq 0x210(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x3481dd
leaq -0x4(%r12), %r11
cmpq $0x4, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x3481dd
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x10(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x1a0(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x348204
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rdi,4)
movq 0x208(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x348237
leaq -0x5(%r12), %r11
cmpq $0x5, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x348237
movsbl %r10b, %r11d
movl %r11d, -0x14(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x198(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x348257
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
pextrw $0x4, %xmm12, %r10d
movq 0x200(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x348297
leaq -0x6(%r12), %r11
cmpq $0x6, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x348297
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x18(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x190(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x3482be
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rdi,4)
movq 0x1f8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x3482f1
leaq -0x7(%r12), %r11
cmpq $0x7, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x3482f1
movsbl %r10b, %r11d
movl %r11d, -0x1c(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x188(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x348311
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
pextrw $0x3, %xmm12, %r10d
movq 0x1f0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x348351
leaq -0x8(%r12), %r11
cmpq $0x8, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x348351
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x20(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x180(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x348378
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rdi,4)
movq 0x1e8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x3483ab
leaq -0x9(%r12), %r11
cmpq $0x9, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x3483ab
movsbl %r10b, %r11d
movl %r11d, -0x24(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x178(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x3483cb
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
pextrw $0x2, %xmm12, %r10d
movq 0x1e0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x34840b
leaq -0xa(%r12), %r11
cmpq $0xa, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x34840b
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x28(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x170(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x348432
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rdi,4)
movq 0x1d8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x348465
leaq -0xb(%r12), %r11
cmpq $0xb, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x348465
movsbl %r10b, %r11d
movl %r11d, -0x2c(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, 0x168(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x348485
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movd %xmm12, %r10d
cmpq %rsi, %r14
jne 0x3484b8
leaq -0xc(%r12), %r11
cmpq $0xc, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x3484b8
movl %r10d, %r11d
sarl $0x18, %r11d
movl %r11d, -0x30(%r9,%r12,4)
cmpq %rdx, %r14
setae %r11b
cmpq %r12, 0x160(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x3484db
movl %r10d, %r11d
sarl $0x18, %r11d
movl %r11d, (%r8,%r14,4)
cmpq %rsi, %rbp
jne 0x34850d
leaq -0xd(%r12), %r11
cmpq $0xd, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x34850d
movl %r10d, %r11d
shrl $0x10, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x34(%r9,%r12,4)
cmpq %rdx, %rbp
setae %r11b
cmpq %r12, 0x158(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x348534
movl %r10d, %r11d
shrl $0x10, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rbp,4)
cmpq %rsi, %rax
jne 0x348566
leaq -0xe(%r12), %r11
cmpq $0xe, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x348566
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x38(%r9,%r12,4)
cmpq %rdx, %rax
setae %r11b
cmpq %r12, 0x150(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x34858d
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rax,4)
cmpq %rsi, %rcx
jne 0x3485b4
leaq -0xf(%r12), %r11
cmpq $0xf, %r12
setb %r13b
cmpq %rbx, %r11
setge %r11b
orb %r13b, %r11b
jne 0x3485b4
movsbl %r10b, %r11d
movl %r11d, -0x3c(%r9,%r12,4)
cmpq %rdx, %rcx
setae %r9b
cmpq %r12, 0x148(%rsp)
setne %r11b
orb %r9b, %r11b
movq 0xd8(%rsp), %r13
jne 0x3485dc
movsbl %r10b, %r9d
movl %r9d, (%r8,%rcx,4)
movdqa %xmm11, %xmm13
pandn %xmm14, %xmm13
movdqa 0xe0(%rsp), %xmm0
pand %xmm11, %xmm0
por %xmm0, %xmm13
pandn %xmm15, %xmm11
por %xmm0, %xmm11
movdqa %xmm12, 0x2b0(%rsp)
movb 0x2b0(%rsp), %r8b
movq 0xc0(%rsp), %r11
movb %r8b, (%r11,%r12)
movd %xmm13, %r8d
movq 0xd0(%rsp), %rdi
movb %r8b, (%rdi,%r12)
movdqa %xmm5, %xmm0
pcmpeqb 0x290(%rsp), %xmm0
pand 0x130(%rsp), %xmm0
movdqa %xmm12, %xmm1
pand %xmm0, %xmm1
pandn %xmm2, %xmm0
movdqa %xmm0, %xmm2
por %xmm1, %xmm2
paddsb 0x24dceb(%rip), %xmm5   # 0x596350
incq %r12
cmpq %r12, 0x1c0(%rsp)
jne 0x347d7f
movdqa 0x260(%rsp), %xmm3
paddsb 0x24db09(%rip), %xmm3   # 0x596190
movdqa 0xf0(%rsp), %xmm0
psubsb 0x240(%rsp), %xmm0
movdqa %xmm0, 0xf0(%rsp)
movq 0x140(%rsp), %rcx
movq %rcx, %rax
cmpq %rdx, %rcx
movq 0x300(%rsp), %rcx
movq 0x78(%rsp), %r14
movl 0xc(%rsp), %r10d
jb 0x347834
movl $0x10, %eax
movl 0x58(%rsp), %edx
movdqa %xmm2, 0x2a0(%rsp)
movzbl 0x2af(%rsp), %ecx
movzbl %dl, %edx
cmpb %dl, %cl
cmovgl %ecx, %edx
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %eax
jne 0x3486d1
movdqa 0xe0(%rsp), %xmm0
pcmpgtb 0x100(%rsp), %xmm0
movdqa 0x110(%rsp), %xmm1
pcmpgtb 0x120(%rsp), %xmm1
por %xmm0, %xmm1
pmovmskb %xmm1, %eax
testl %eax, %eax
je 0x348735
orb $0x40, 0xc(%r13)
xorl %edx, %edx
movl $0x0, 0x8(%rsp)
xorl %r10d, %r10d
movsbl %dl, %eax
movl %eax, (%r13)
movl %r10d, 0x4(%r13)
movl 0x8(%rsp), %eax
movl %eax, 0x8(%r13)
callq 0x2094b5
movq 0xc0(%rsp), %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x300(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x3487ac
movq %r14, %rdi
callq 0x2094b5
jmp 0x3487ac
callq 0x1b5c23
jmp 0x3487a9
callq 0x1b5bfd
jmp 0x3487a9
callq 0x1b5bd7
jmp 0x3487a9
callq 0x1b5bb1
jmp 0x3487a9
callq 0x1b5b8b
jmp 0x3487a9
callq 0x1b5b65
jmp 0x3487a9
callq 0x1b5b3f
xorl %r13d, %r13d
movq %r13, %rax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)