// File: /workspace/github_c_makefile_star2_O3/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 $0x2b8, %rsp            # imm = 0x2B8
testq %rdx, %rdx
je 0x35ec7c
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x35ec83
movl %r8d, %ebp
testl %r8d, %r8d
js 0x35ec8a
testl %r9d, %r9d
js 0x35ec91
movq %rdx, %r15
movq 0x2f0(%rsp), %rdx
testq %rdx, %rdx
je 0x35ec98
cmpl $0x0, 0x30(%rdx)
je 0x35d749
movl 0x34(%rdx), %ebx
jmp 0x35d75c
testq %rdi, %rdi
je 0x35ec9f
movl %esi, %ebx
testl %esi, %esi
jle 0x35eca6
movq %rdi, 0x10(%rsp)
movq %r9, 0x88(%rsp)
movl %ebp, %esi
negl %esi
movl 0x20(%rdx), %eax
movl %eax, %ecx
negb %cl
movl %esi, 0x74(%rsp)
cmpl %esi, %eax
movzbl %cl, %eax
cmovgl %ebp, %eax
movl %eax, 0x20(%rsp)
movb $0x7e, %r13b
subb 0x1c(%rdx), %r13b
movl %ebx, %edi
movl %r14d, %esi
callq 0x20ac53
testq %rax, %rax
je 0x35ecab
movq %rax, %r12
movb %r13b, 0x28(%rsp)
movq %r15, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
orl $0x10141001, 0xc(%rax)  # imm = 0x10141001
leal 0x1e(%r14), %r13d
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a620
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a620
movq %rax, %rbx
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a620
testq %r15, %r15
sete %dl
testq %rbx, %rbx
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x35ecab
movq %r12, 0xb8(%rsp)
movq 0x2f0(%rsp), %rdi
cmpl $0x0, 0x30(%rdi)
movq %rbx, 0x78(%rsp)
movq %rax, 0x98(%rsp)
je 0x35d842
movq $0x0, 0x80(%rsp)
movq 0x8(%rsp), %rbx
movq 0x18(%rsp), %r13
jmp 0x35d8c6
movq 0x8(%rsp), %rbx
leal 0xf(%rbx), %r12d
movslq %r12d, %rsi
movl $0x10, %edi
callq 0x20a620
testq %rax, %rax
movq 0x18(%rsp), %r13
je 0x35ecab
testl %ebx, %ebx
movq 0x2f0(%rsp), %rdi
movq 0x10(%rsp), %r9
jle 0x35d893
movl %ebx, %r8d
xorl %ecx, %ecx
movq 0x10(%rdi), %rdx
movzbl (%r9,%rcx), %esi
movb (%rdx,%rsi,4), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r8
jne 0x35d87c
movslq %ebx, %rdx
movq %rax, 0x80(%rsp)
movq %rax, %rdi
addq %rdx, %rdi
leal 0x1(%rbx), %eax
cmpl %eax, %r12d
cmovgl %r12d, %eax
movl %ebx, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x2f0(%rsp), %rdi
leal 0xf(%r14), %r12d
movl 0x20(%rsp), %eax
addb $-0x7f, %al
movl %eax, 0x20(%rsp)
movzbl %al, %eax
movd %eax, %xmm0
movzbl 0x28(%rsp), %eax
movd %eax, %xmm1
movq 0x88(%rsp), %r8
movl 0x74(%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
imull $0xf5, %r8d, %esi
subl %ebp, %esi
movd %esi, %xmm6
imull $0xf6, %r8d, %esi
subl %ebp, %esi
movd %esi, %xmm5
imull $0xf7, %r8d, %esi
subl %ebp, %esi
movd %esi, %xmm4
leal -0x1(%rbx), %esi
movl %esi, 0x24(%rsp)
movd %r8d, %xmm2
movd %ebx, %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, %xmm7      # xmm7 = xmm3[0,0,0,0]
pcmpeqd %xmm3, %xmm3
paddsb %xmm3, %xmm7
movdqa %xmm7, 0x240(%rsp)
movd %r14d, %xmm7
punpcklbw %xmm7, %xmm7    # xmm7 = xmm7[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm7, %xmm7      # xmm7 = xmm7[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm7, %xmm7      # xmm7 = xmm7[0,0,0,0]
paddsb %xmm3, %xmm7
movdqa %xmm7, 0x280(%rsp)
pshufd $0x0, %xmm2, %xmm7      # xmm7 = xmm2[0,0,0,0]
movdqa 0x2cc469(%rip), %xmm3   # 0x629e00
pshufd $0xf5, %xmm3, %xmm8     # xmm8 = xmm3[1,1,3,3]
pmuludq %xmm7, %xmm8
pmuludq %xmm3, %xmm7
movd %ebp, %xmm3
pshufd $0xe8, %xmm8, %xmm8     # xmm8 = xmm8[0,2,2,3]
pshufd $0xe8, %xmm7, %xmm9     # xmm9 = xmm7[0,2,2,3]
punpckldq %xmm8, %xmm9    # xmm9 = xmm9[0],xmm8[0],xmm9[1],xmm8[1]
pshufd $0x0, %xmm3, %xmm7      # xmm7 = xmm3[0,0,0,0]
psubd %xmm7, %xmm9
pand 0x2cc442(%rip), %xmm9   # 0x629e10
packuswb %xmm9, %xmm9
packuswb %xmm9, %xmm9
movdqa 0x2cc43f(%rip), %xmm8   # 0x629e20
pand %xmm8, %xmm9
pshufd $0x50, %xmm6, %xmm6     # xmm6 = xmm6[0,0,1,1]
pandn %xmm6, %xmm8
movd %edx, %xmm7
imull $0xf9, %r8d, %edx
subl %ebp, %edx
por %xmm9, %xmm8
movdqa 0x2cc425(%rip), %xmm9   # 0x629e30
pand %xmm9, %xmm8
psllq $0x28, %xmm5
pandn %xmm5, %xmm9
movd %edx, %xmm5
imull $0xfa, %r8d, %edx
subl %ebp, %edx
por %xmm8, %xmm9
movdqa 0x2cc40c(%rip), %xmm6   # 0x629e40
pand %xmm6, %xmm9
psllq $0x30, %xmm4
pandn %xmm4, %xmm6
movd %edx, %xmm4
imull $0xfb, %r8d, %edx
subl %ebp, %edx
por %xmm9, %xmm6
movdqa 0x2cc3f3(%rip), %xmm8   # 0x629e50
pand %xmm8, %xmm6
psllq $0x38, %xmm7
pandn %xmm7, %xmm8
movd %edx, %xmm7
leal -0x1(%r14), %edx
movl %edx, 0x34(%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, 0xa0(%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, 0xe0(%rsp)
punpcklbw %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm3, %xmm0      # xmm0 = xmm3[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x270(%rsp)
punpcklbw %xmm2, %xmm2    # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm2, %xmm0      # xmm0 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
por %xmm6, %xmm8
movdqa 0x2cc388(%rip), %xmm1   # 0x629e60
pand %xmm1, %xmm8
pshufd $0x44, %xmm5, %xmm0     # xmm0 = xmm5[0,1,0,1]
pandn %xmm0, %xmm1
movdqa %xmm2, 0x260(%rsp)
psllw $0x4, %xmm2
pand 0x2cc2f4(%rip), %xmm2   # 0x629df0
movdqa %xmm2, 0x230(%rsp)
por %xmm8, %xmm1
movdqa 0x2cc35e(%rip), %xmm0   # 0x629e70
pand %xmm0, %xmm1
pslldq $0x9, %xmm4             # xmm4 = zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm4[0,1,2,3,4,5,6]
pandn %xmm4, %xmm0
movd %ecx, %xmm2
imull $0xfd, %r8d, %ecx
subl %ebp, %ecx
por %xmm1, %xmm0
movdqa 0x2cc348(%rip), %xmm1   # 0x629e80
pand %xmm1, %xmm0
pslldq $0xa, %xmm7             # xmm7 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm7[0,1,2,3,4,5]
pandn %xmm7, %xmm1
movd %ecx, %xmm3
movl %r9d, %ecx
subl %r8d, %ecx
por %xmm0, %xmm1
movdqa 0x2cc335(%rip), %xmm0   # 0x629e90
pand %xmm0, %xmm1
pslldq $0xb, %xmm2             # xmm2 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm2[0,1,2,3,4]
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movdqa 0x2cc32c(%rip), %xmm1   # 0x629ea0
pand %xmm1, %xmm0
pshufd $0x0, %xmm3, %xmm2      # xmm2 = xmm3[0,0,0,0]
pandn %xmm2, %xmm1
por %xmm0, %xmm1
movdqa 0x2cc323(%rip), %xmm0   # 0x629eb0
pand %xmm0, %xmm1
movd %eax, %xmm2
pslldq $0xd, %xmm2             # xmm2 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm2[0,1,2]
pandn %xmm2, %xmm0
por %xmm1, %xmm0
pand 0x2cc316(%rip), %xmm0   # 0x629ec0
movd %ecx, %xmm1
pslldq $0xe, %xmm1             # xmm1 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm1[0,1]
por %xmm0, %xmm1
pand 0x2cc311(%rip), %xmm1   # 0x629ed0
movd %r9d, %xmm0
pslldq $0xf, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0]
por %xmm1, %xmm0
movdqa %xmm0, 0xf0(%rsp)
movl %r14d, %ebx
xorl %eax, %eax
movq 0x10(%rdi), %rcx
movzbl (%r13,%rax), %edx
movb (%rcx,%rdx,4), %cl
movb %cl, 0xf(%r15,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x35dbdb
xorl %r13d, %r13d
movq %r13, 0x7(%r15)
movq %r13, (%r15)
leaq (%r15,%rbx), %rdi
addq $0xf, %rdi
leal 0x1(%r14), %eax
cmpl %eax, %r12d
cmovgl %r12d, %eax
movl %r14d, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
negb %bpl
movl 0x20(%rsp), %ecx
movq 0x88(%rsp), %rax
movq 0x78(%rsp), %rdx
movq 0x98(%rsp), %rdi
movb %bpl, 0xf(%rdx,%r13)
movb %cl, 0xf(%rdi,%r13)
incq %r13
subb %al, %bpl
cmpq %r13, %rbx
jne 0x35dc3f
xorl %eax, %eax
movb %cl, (%rdx,%rax)
movb %cl, (%rdi,%rax)
incq %rax
cmpq $0xf, %rax
jne 0x35dc56
leaq 0xf(%rbx), %rax
movq 0x2f0(%rsp), %r9
movq 0x8(%rsp), %rsi
movb %cl, (%rdx,%rax)
movb %cl, (%rdi,%rax)
incq %rax
incl %r14d
cmpl %r14d, %r12d
jg 0x35dc76
movb $0x0, 0xe(%rdx)
movdqa 0xa0(%rsp), %xmm0
movdqa %xmm0, %xmm2
movdqa %xmm0, 0xd0(%rsp)
movdqa 0xe0(%rsp), %xmm0
movdqa %xmm0, 0xc0(%rsp)
testl %esi, %esi
jle 0x35ebbc
movdqa 0xa0(%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, %r12d
movl $0x1, %eax
cmovgel %r12d, %eax
movq %rax, 0x1a0(%rsp)
movl 0x34(%rsp), %eax
movq %rax, 0x198(%rsp)
movl %esi, %edx
movl 0x24(%rsp), %esi
leaq 0x1(%rbx), %rax
movq %rax, 0x190(%rsp)
leaq 0x2(%rbx), %rax
movq %rax, 0x188(%rsp)
leaq 0x3(%rbx), %rax
movq %rax, 0x180(%rsp)
leaq 0x4(%rbx), %rax
movq %rax, 0x178(%rsp)
leaq 0x5(%rbx), %rax
movq %rax, 0x170(%rsp)
leaq 0x6(%rbx), %rax
movq %rax, 0x168(%rsp)
leaq 0x7(%rbx), %rax
movq %rax, 0x160(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, 0x158(%rsp)
leaq 0x9(%rbx), %rax
movq %rax, 0x150(%rsp)
leaq 0xa(%rbx), %rax
movq %rax, 0x148(%rsp)
leaq 0xb(%rbx), %rax
movq %rax, 0x140(%rsp)
pand 0x2cc150(%rip), %xmm1   # 0x629ed0
movdqa %xmm1, 0x220(%rsp)
movdqa 0x2cbebf(%rip), %xmm3   # 0x629c50
movdqa 0xe0(%rsp), %xmm1
movdqa %xmm1, 0xc0(%rsp)
movdqa %xmm0, 0xd0(%rsp)
movdqa %xmm0, %xmm2
leaq 0xc(%rbx), %rax
movq %rax, 0x138(%rsp)
leaq 0xd(%rbx), %rax
movq %rax, 0x130(%rsp)
leaq 0xe(%rbx), %rax
movq %rax, 0x128(%rsp)
xorl %r13d, %r13d
cmpl $0x0, 0x30(%r9)
je 0x35deee
movq %r13, %rax
orq $0x1, %rax
cmpq %rdx, %rax
movl 0x24(%rsp), %r10d
cmovael %r10d, %eax
movq %rax, 0x8(%rsp)
movq %r13, %rax
orq $0x2, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x10(%rsp)
movq %r13, %r11
orq $0x3, %r11
cmpq %rdx, %r11
cmovael %r10d, %r11d
movq %r13, %rax
orq $0x4, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x18(%rsp)
movq %r13, %r14
orq $0x5, %r14
cmpq %rdx, %r14
cmovael %r10d, %r14d
movq %r13, %rax
orq $0x6, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x28(%rsp)
movq %r13, %r12
orq $0x7, %r12
cmpq %rdx, %r12
cmovael %r10d, %r12d
movq %r13, %rax
orq $0x8, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x58(%rsp)
movq %r13, %rbp
orq $0x9, %rbp
cmpq %rdx, %rbp
cmovael %r10d, %ebp
movq %r13, %rax
orq $0xa, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x50(%rsp)
movq %r13, %rcx
orq $0xb, %rcx
cmpq %rdx, %rcx
cmovael %r10d, %ecx
movq %r13, %rax
orq $0xc, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x48(%rsp)
movq %r13, %r8
orq $0xd, %r8
cmpq %rdx, %r8
cmovael %r10d, %r8d
movq %r13, %rax
orq $0xe, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x40(%rsp)
movq %r13, %rax
orq $0xf, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x38(%rsp)
movl %r13d, %r10d
jmp 0x35df82
movq 0x80(%rsp), %rdi
movsbl (%rdi,%r13), %r10d
movsbl 0x1(%rdi,%r13), %eax
movq %rax, 0x8(%rsp)
movsbl 0x2(%rdi,%r13), %eax
movq %rax, 0x10(%rsp)
movsbl 0x3(%rdi,%r13), %r11d
movsbl 0x4(%rdi,%r13), %eax
movq %rax, 0x18(%rsp)
movsbl 0x5(%rdi,%r13), %r14d
movsbl 0x6(%rdi,%r13), %eax
movq %rax, 0x28(%rsp)
movsbl 0x7(%rdi,%r13), %r12d
movsbl 0x8(%rdi,%r13), %eax
movq %rax, 0x58(%rsp)
movsbl 0x9(%rdi,%r13), %ebp
movsbl 0xa(%rdi,%r13), %eax
movq %rax, 0x50(%rsp)
movsbl 0xb(%rdi,%r13), %ecx
movsbl 0xc(%rdi,%r13), %eax
movq %rax, 0x48(%rsp)
movsbl 0xd(%rdi,%r13), %r8d
movsbl 0xe(%rdi,%r13), %eax
movq %rax, 0x40(%rsp)
movsbl 0xf(%rdi,%r13), %eax
movq %rax, 0x38(%rsp)
movl 0x18(%r9), %r9d
imull %r9d, %r8d
imull %r9d, %ecx
imull %r9d, %ebp
movq %rbp, 0x100(%rsp)
imull %r9d, %r12d
movq %r12, 0x110(%rsp)
imull %r9d, %r14d
movq %r14, 0x68(%rsp)
imull %r9d, %r11d
movq %r11, 0x60(%rsp)
movq 0x8(%rsp), %rax
imull %r9d, %eax
movq %rax, 0x8(%rsp)
imull %r9d, %r10d
movl %r10d, 0x90(%rsp)
movq 0x10(%rsp), %rax
imull %r9d, %eax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %r12
imull %r9d, %r12d
movq 0x28(%rsp), %rbp
imull %r9d, %ebp
movq 0x58(%rsp), %r14
imull %r9d, %r14d
movq 0x50(%rsp), %r11
imull %r9d, %r11d
movq 0x48(%rsp), %r10
imull %r9d, %r10d
movq 0x40(%rsp), %rax
imull %r9d, %eax
movq 0x38(%rsp), %rdi
imull %r9d, %edi
movslq %r8d, %r9
movq 0x2f0(%rsp), %r8
movq 0x8(%r8), %r8
leaq (%r8,%r9,4), %r9
movq %r9, 0x218(%rsp)
movslq %ecx, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x210(%rsp)
movslq 0x100(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x208(%rsp)
movslq 0x110(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x200(%rsp)
movslq 0x68(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1f8(%rsp)
movslq 0x60(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1f0(%rsp)
movslq 0x8(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1e8(%rsp)
movslq 0x90(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x90(%rsp)
movslq 0x10(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1e0(%rsp)
movslq %r12d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1d8(%rsp)
movslq %ebp, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1d0(%rsp)
movslq %r14d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1c8(%rsp)
movslq %r11d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1c0(%rsp)
movslq %r10d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x1b8(%rsp)
cltq
leaq (%r8,%rax,4), %rax
movq %rax, 0x1b0(%rsp)
movslq %edi, %rax
leaq (%r8,%rax,4), %rax
movq %rax, 0x1a8(%rsp)
leaq 0x10(%r13), %rax
movq %rax, 0x120(%rsp)
movq 0x88(%rsp), %rdi
imull %edi, %eax
movl 0x74(%rsp), %r8d
movl %r8d, %ecx
subl %eax, %ecx
movq 0x78(%rsp), %r9
movzbl 0xe(%r9), %eax
movb %cl, 0xe(%r9)
movl %r13d, %ecx
imull %edi, %ecx
movl %r8d, %edi
subl %ecx, %edi
movd %edi, %xmm10
movd %eax, %xmm6
pslldq $0xf, %xmm10            # xmm10 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm10[0]
movdqa 0x220(%rsp), %xmm0
por %xmm0, %xmm10
pslldq $0xf, %xmm6             # xmm6 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm6[0]
por %xmm0, %xmm6
movq %r13, %rax
orq $0x1, %rax
movq %rax, 0x8(%rsp)
movq %r13, %rax
orq $0x2, %rax
movq %rax, 0x10(%rsp)
movq %r13, %rax
orq $0x3, %rax
movq %rax, 0x18(%rsp)
movq %r13, %rax
orq $0x4, %rax
movq %rax, 0x28(%rsp)
movq %r13, %rax
orq $0x5, %rax
movq %rax, 0x58(%rsp)
movq %r13, %rax
orq $0x6, %rax
movq %rax, 0x50(%rsp)
movq %r13, %rax
orq $0x7, %rax
movq %rax, 0x48(%rsp)
movq %r13, %rax
orq $0x8, %rax
movq %rax, 0x40(%rsp)
movq %r13, %rax
orq $0x9, %rax
movq %rax, 0x38(%rsp)
movq %r13, %rax
orq $0xa, %rax
movq %rax, 0x68(%rsp)
movq %r13, %rax
orq $0xb, %rax
movq %rax, 0x60(%rsp)
movq %r13, %r14
orq $0xc, %r14
movq %r13, %rbp
orq $0xd, %rbp
movq %r13, %rax
orq $0xe, %rax
movq %r13, %rcx
orq $0xf, %rcx
movdqa %xmm3, 0x250(%rsp)
pcmpeqb 0x240(%rsp), %xmm3
movdqa %xmm3, 0x290(%rsp)
movdqa 0x2cbc8c(%rip), %xmm5   # 0x629ee0
movdqa 0xa0(%rsp), %xmm12
movdqa %xmm12, %xmm13
xorl %r12d, %r12d
movq 0x98(%rsp), %rdi
movdqa %xmm2, 0x110(%rsp)
movdqa %xmm6, 0x100(%rsp)
movzbl 0xf(%r9,%r12), %r8d
movd %r8d, %xmm14
movzbl 0xf(%rdi,%r12), %r8d
movd %r8d, %xmm15
movsbq 0xf(%r15,%r12), %r8
movq 0x90(%rsp), %rdi
movd (%rdi,%r8,4), %xmm3
movsbq 0xe(%r15,%r12), %r8
movq 0x1e8(%rsp), %rdi
movd (%rdi,%r8,4), %xmm6
movsbq 0xd(%r15,%r12), %r8
movq 0x1e0(%rsp), %rdi
movd (%rdi,%r8,4), %xmm11
movsbq 0xc(%r15,%r12), %r8
movq 0x1f0(%rsp), %rdi
movd (%rdi,%r8,4), %xmm8
movsbq 0xb(%r15,%r12), %r8
movq 0x1d8(%rsp), %rdi
movd (%rdi,%r8,4), %xmm7
movsbq 0xa(%r15,%r12), %r8
movq 0x1f8(%rsp), %rdi
movd (%rdi,%r8,4), %xmm4
movsbq 0x9(%r15,%r12), %r8
movq 0x1d0(%rsp), %rdi
movd (%rdi,%r8,4), %xmm0
movsbq 0x8(%r15,%r12), %r8
movq 0x200(%rsp), %rdi
movd (%rdi,%r8,4), %xmm1
movsbq 0x7(%r15,%r12), %r8
movq 0x1c8(%rsp), %rdi
movd (%rdi,%r8,4), %xmm9
movsbq 0x6(%r15,%r12), %r8
movq 0x208(%rsp), %rdi
movd (%rdi,%r8,4), %xmm2
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 0x1c0(%rsp), %rdi
movd (%rdi,%r8,4), %xmm3
movsbq 0x4(%r15,%r12), %r8
punpcklbw %xmm11, %xmm8   # xmm8 = xmm8[0],xmm11[0],xmm8[1],xmm11[1],xmm8[2],xmm11[2],xmm8[3],xmm11[3],xmm8[4],xmm11[4],xmm8[5],xmm11[5],xmm8[6],xmm11[6],xmm8[7],xmm11[7]
movq 0x210(%rsp), %rdi
movd (%rdi,%r8,4), %xmm11
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 0x1b8(%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 0x218(%rsp), %rdi
movd (%rdi,%r8,4), %xmm7
movsbq 0x1(%r15,%r12), %r8
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]
movq 0x1b0(%rsp), %rdi
movd (%rdi,%r8,4), %xmm0
movsbq (%r15,%r12), %r8
punpcklwd %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1],xmm1[2],xmm4[2],xmm1[3],xmm4[3]
movq 0x1a8(%rsp), %rdi
movd (%rdi,%r8,4), %xmm4
punpckldq %xmm8, %xmm1    # xmm1 = xmm1[0],xmm8[0],xmm1[1],xmm8[1]
punpcklbw %xmm9, %xmm2    # xmm2 = xmm2[0],xmm9[0],xmm2[1],xmm9[1],xmm2[2],xmm9[2],xmm2[3],xmm9[3],xmm2[4],xmm9[4],xmm2[5],xmm9[5],xmm2[6],xmm9[6],xmm2[7],xmm9[7]
punpcklbw %xmm3, %xmm11   # xmm11 = xmm11[0],xmm3[0],xmm11[1],xmm3[1],xmm11[2],xmm3[2],xmm11[3],xmm3[3],xmm11[4],xmm3[4],xmm11[5],xmm3[5],xmm11[6],xmm3[6],xmm11[7],xmm3[7]
punpcklwd %xmm2, %xmm11   # xmm11 = xmm11[0],xmm2[0],xmm11[1],xmm2[1],xmm11[2],xmm2[2],xmm11[3],xmm2[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 %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3],xmm4[4],xmm0[4],xmm4[5],xmm0[5],xmm4[6],xmm0[6],xmm4[7],xmm0[7]
punpcklwd %xmm7, %xmm4    # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1],xmm4[2],xmm7[2],xmm4[3],xmm7[3]
punpckldq %xmm11, %xmm4   # xmm4 = xmm4[0],xmm11[0],xmm4[1],xmm11[1]
punpcklqdq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0]
paddsb 0x100(%rsp), %xmm4
movdqa %xmm10, %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), %xmm1
psubsb %xmm1, %xmm0
movdqa 0x260(%rsp), %xmm2
psubsb %xmm2, %xmm15
movdqa %xmm0, %xmm14
pcmpgtb %xmm15, %xmm14
pand %xmm14, %xmm0
pandn %xmm15, %xmm14
por %xmm0, %xmm14
psubsb %xmm1, %xmm10
psubsb %xmm2, %xmm12
movdqa %xmm10, %xmm15
pcmpgtb %xmm12, %xmm15
pand %xmm15, %xmm10
pandn %xmm12, %xmm15
por %xmm10, %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, %xmm12
pcmpeqb 0x2cb8c1(%rip), %xmm12  # 0x629da0
movdqa %xmm12, %xmm0
pandn %xmm1, %xmm0
movdqa 0xf0(%rsp), %xmm10
pand %xmm12, %xmm10
por %xmm0, %xmm10
cmpq $0x10, %r12
jb 0x35e556
movdqa 0xc0(%rsp), %xmm2
movdqa %xmm2, %xmm0
pcmpgtb %xmm10, %xmm0
movdqa %xmm10, %xmm1
pand %xmm0, %xmm1
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movdqa 0xd0(%rsp), %xmm2
movdqa %xmm2, %xmm1
pcmpgtb %xmm10, %xmm1
pand %xmm1, %xmm2
pandn %xmm10, %xmm1
por %xmm1, %xmm2
movdqa %xmm2, 0xd0(%rsp)
movdqa %xmm0, 0xc0(%rsp)
cmpq %rsi, %r13
setne %r10b
movq 0xb8(%rsp), %r8
movq 0x10(%r8), %r8
movq (%r8), %r9
movq 0x8(%r8), %r8
cmpq %rbx, %r12
setae %r11b
orb %r10b, %r11b
pextrw $0x7, %xmm10, %r10d
movdqa 0x110(%rsp), %xmm2
jne 0x35e59a
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r9,%r12,4)
cmpq %r12, 0x198(%rsp)
jne 0x35e5b3
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%r13,4)
movq %r13, %rdi
cmpq %rsi, 0x8(%rsp)
setne %r11b
leaq -0x1(%r12), %r13
cmpq %rbx, %r13
setae %r13b
orb %r11b, %r13b
jne 0x35e5d9
movsbl %r10b, %r11d
movl %r11d, -0x4(%r9,%r12,4)
cmpq %rdx, 0x8(%rsp)
setae %r11b
cmpq %r12, %rbx
setne %r13b
orb %r11b, %r13b
jne 0x35e5fb
movsbl %r10b, %r10d
movq 0x8(%rsp), %r11
movl %r10d, (%r8,%r11,4)
pextrw $0x6, %xmm10, %r10d
cmpq %rsi, 0x10(%rsp)
jne 0x35e635
leaq -0x2(%r12), %r11
cmpq $0x2, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e635
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x8(%r9,%r12,4)
cmpq %rdx, 0x10(%rsp)
setae %r11b
cmpq %r12, 0x190(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e663
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movq 0x10(%rsp), %r13
movl %r11d, (%r8,%r13,4)
cmpq %rsi, 0x18(%rsp)
jne 0x35e690
leaq -0x3(%r12), %r11
cmpq $0x3, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e690
movsbl %r10b, %r11d
movl %r11d, -0xc(%r9,%r12,4)
cmpq %rdx, 0x18(%rsp)
setae %r11b
cmpq %r12, 0x188(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e6b7
movsbl %r10b, %r10d
movq 0x18(%rsp), %r11
movl %r10d, (%r8,%r11,4)
pextrw $0x5, %xmm10, %r10d
cmpq %rsi, 0x28(%rsp)
jne 0x35e6f1
leaq -0x4(%r12), %r11
cmpq $0x4, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e6f1
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x10(%r9,%r12,4)
cmpq %rdx, 0x28(%rsp)
setae %r11b
cmpq %r12, 0x180(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e71f
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movq 0x28(%rsp), %r13
movl %r11d, (%r8,%r13,4)
cmpq %rsi, 0x58(%rsp)
jne 0x35e74c
leaq -0x5(%r12), %r11
cmpq $0x5, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e74c
movsbl %r10b, %r11d
movl %r11d, -0x14(%r9,%r12,4)
cmpq %rdx, 0x58(%rsp)
setae %r11b
cmpq %r12, 0x178(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e773
movsbl %r10b, %r10d
movq 0x58(%rsp), %r11
movl %r10d, (%r8,%r11,4)
pextrw $0x4, %xmm10, %r10d
cmpq %rsi, 0x50(%rsp)
jne 0x35e7ad
leaq -0x6(%r12), %r11
cmpq $0x6, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e7ad
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x18(%r9,%r12,4)
cmpq %rdx, 0x50(%rsp)
setae %r11b
cmpq %r12, 0x170(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e7db
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movq 0x50(%rsp), %r13
movl %r11d, (%r8,%r13,4)
cmpq %rsi, 0x48(%rsp)
jne 0x35e808
leaq -0x7(%r12), %r11
cmpq $0x7, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e808
movsbl %r10b, %r11d
movl %r11d, -0x1c(%r9,%r12,4)
cmpq %rdx, 0x48(%rsp)
setae %r11b
cmpq %r12, 0x168(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e82f
movsbl %r10b, %r10d
movq 0x48(%rsp), %r11
movl %r10d, (%r8,%r11,4)
pextrw $0x3, %xmm10, %r10d
cmpq %rsi, 0x40(%rsp)
jne 0x35e869
leaq -0x8(%r12), %r11
cmpq $0x8, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e869
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x20(%r9,%r12,4)
cmpq %rdx, 0x40(%rsp)
setae %r11b
cmpq %r12, 0x160(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e897
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movq 0x40(%rsp), %r13
movl %r11d, (%r8,%r13,4)
cmpq %rsi, 0x38(%rsp)
jne 0x35e8c4
leaq -0x9(%r12), %r11
cmpq $0x9, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e8c4
movsbl %r10b, %r11d
movl %r11d, -0x24(%r9,%r12,4)
cmpq %rdx, 0x38(%rsp)
setae %r11b
cmpq %r12, 0x158(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e8eb
movsbl %r10b, %r10d
movq 0x38(%rsp), %r11
movl %r10d, (%r8,%r11,4)
pextrw $0x2, %xmm10, %r10d
cmpq %rsi, 0x68(%rsp)
jne 0x35e925
leaq -0xa(%r12), %r11
cmpq $0xa, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e925
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x28(%r9,%r12,4)
cmpq %rdx, 0x68(%rsp)
setae %r11b
cmpq %r12, 0x150(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e953
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movq 0x68(%rsp), %r13
movl %r11d, (%r8,%r13,4)
cmpq %rsi, 0x60(%rsp)
jne 0x35e980
leaq -0xb(%r12), %r11
cmpq $0xb, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e980
movsbl %r10b, %r11d
movl %r11d, -0x2c(%r9,%r12,4)
cmpq %rdx, 0x60(%rsp)
setae %r11b
cmpq %r12, 0x148(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e9a7
movsbl %r10b, %r10d
movq 0x60(%rsp), %r11
movl %r10d, (%r8,%r11,4)
movd %xmm10, %r10d
cmpq %rsi, %r14
jne 0x35e9da
leaq -0xc(%r12), %r11
cmpq $0xc, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35e9da
movl %r10d, %r11d
sarl $0x18, %r11d
movl %r11d, -0x30(%r9,%r12,4)
cmpq %rdx, %r14
setae %r11b
cmpq %r12, 0x140(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35e9fd
movl %r10d, %r11d
sarl $0x18, %r11d
movl %r11d, (%r8,%r14,4)
cmpq %rsi, %rbp
jne 0x35ea2f
leaq -0xd(%r12), %r11
cmpq $0xd, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35ea2f
movl %r10d, %r11d
shrl $0x10, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x34(%r9,%r12,4)
cmpq %rdx, %rbp
setae %r11b
cmpq %r12, 0x138(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35ea56
movl %r10d, %r11d
shrl $0x10, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rbp,4)
cmpq %rsi, %rax
jne 0x35ea88
leaq -0xe(%r12), %r11
cmpq $0xe, %r12
setae %r13b
cmpq %rbx, %r11
setl %r11b
andb %r13b, %r11b
cmpb $0x1, %r11b
jne 0x35ea88
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, -0x38(%r9,%r12,4)
cmpq %rdx, %rax
setae %r11b
cmpq %r12, 0x130(%rsp)
setne %r13b
orb %r11b, %r13b
jne 0x35eaaf
movl %r10d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
movl %r11d, (%r8,%rax,4)
cmpq %rsi, %rcx
setne %r11b
cmpq $0xf, %r12
setb %r13b
orb %r11b, %r13b
jne 0x35eacc
movsbl %r10b, %r11d
movl %r11d, -0x3c(%r9,%r12,4)
cmpq %rdx, %rcx
setae %r9b
cmpq %r12, 0x128(%rsp)
setne %r11b
orb %r9b, %r11b
movq %rdi, %r13
jne 0x35eaef
movsbl %r10b, %r9d
movl %r9d, (%r8,%rcx,4)
movdqa %xmm12, %xmm13
pandn %xmm14, %xmm13
movdqa 0xa0(%rsp), %xmm0
pand %xmm12, %xmm0
por %xmm0, %xmm13
pandn %xmm15, %xmm12
por %xmm0, %xmm12
movq 0x78(%rsp), %r9
movb %r10b, (%r9,%r12)
movd %xmm13, %r8d
movq 0x98(%rsp), %rdi
movb %r8b, (%rdi,%r12)
movdqa %xmm5, %xmm0
pcmpeqb 0x280(%rsp), %xmm0
pand 0x290(%rsp), %xmm0
movdqa %xmm10, %xmm1
pand %xmm0, %xmm1
pandn %xmm2, %xmm0
movdqa %xmm0, %xmm2
por %xmm1, %xmm2
paddsb 0x26b7fd(%rip), %xmm5   # 0x5ca360
incq %r12
cmpq %r12, 0x1a0(%rsp)
jne 0x35e26e
movdqa 0x250(%rsp), %xmm3
paddsb 0x26b63b(%rip), %xmm3   # 0x5ca1c0
movdqa 0xf0(%rsp), %xmm0
psubsb 0x230(%rsp), %xmm0
movdqa %xmm0, 0xf0(%rsp)
movq 0x120(%rsp), %rax
movq %rax, %r13
cmpq %rdx, %rax
movq 0x2f0(%rsp), %r9
jb 0x35ddd7
movl $0x10, %eax
movl 0x20(%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 0x35ebc5
movdqa 0xa0(%rsp), %xmm0
pcmpgtb 0xc0(%rsp), %xmm0
movdqa 0xd0(%rsp), %xmm1
pcmpgtb 0xe0(%rsp), %xmm1
por %xmm0, %xmm1
pmovmskb %xmm1, %eax
testl %eax, %eax
movq 0xb8(%rsp), %rbx
je 0x35ec35
orb $0x40, 0xc(%rbx)
xorl %edx, %edx
movl $0x0, 0x34(%rsp)
movl $0x0, 0x24(%rsp)
movsbl %dl, %eax
movl %eax, (%rbx)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rbx)
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rbx)
callq 0x20a60d
movq 0x78(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x2f0(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x35ecad
movq 0x80(%rsp), %rdi
callq 0x20a60d
jmp 0x35ecad
callq 0x1b5c17
jmp 0x35ecab
callq 0x1b5bf1
jmp 0x35ecab
callq 0x1b5bcb
jmp 0x35ecab
callq 0x1b5ba5
jmp 0x35ecab
callq 0x1b5b7f
jmp 0x35ecab
callq 0x1b5b59
jmp 0x35ecab
callq 0x1b5b33
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop