// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_diag_sse41_128_8.c
// Function: parasail_nw_rowcol_diag_sse41_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(vNH, H_pr[-1], 15);
        vWH = _mm_srli_si128(vWH, 1);
        vWH = _mm_insert_epi8(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(vNH, H_pr[j], 15);
            vF = _mm_srli_si128(vF, 1);
            vF = _mm_insert_epi8(vF, F_pr[j], 15);
            vF = _mm_max_epi8(
                    _mm_subs_epi8(vNH, vOpen),
                    _mm_subs_epi8(vF, vGap));
            vE = _mm_max_epi8(
                    _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(vNWH, vE);
            vWH = _mm_max_epi8(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(vWH, vIBoundary, cond);
                vF = _mm_blendv_epi8(vF, vNegInf, cond);
                vE = _mm_blendv_epi8(vE, vNegInf, cond);
            }
            /* cannot start checking sat until after J clears boundary */
            if (j > PAD) {
                vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm_max_epi8(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(vWH,0);
            F_pr[j-15] = (int8_t)_mm_extract_epi8(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(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(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 $0x258, %rsp            # imm = 0x258
testq %rdx, %rdx
je 0x432128
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x43212f
movl %r8d, %ebp
testl %r8d, %r8d
js 0x432136
testl %r9d, %r9d
js 0x43213d
movq 0x290(%rsp), %r8
testq %r8, %r8
je 0x432144
movl 0x30(%r8), %eax
testl %eax, %eax
jne 0x430dd6
testq %rdi, %rdi
je 0x43214b
movl %esi, %ebx
testl %esi, %esi
jle 0x432152
testl %eax, %eax
je 0x430dda
movl 0x34(%r8), %ebx
movq %rdi, 0xf0(%rsp)
movq %rdx, 0x8(%rsp)
movq %r9, 0xc8(%rsp)
movl %ebp, %esi
negl %esi
movl 0x20(%r8), %eax
movl %eax, %ecx
negb %cl
movl %esi, 0x7c(%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 0x432157
movb %r15b, 0xb0(%rsp)
movq %rbx, 0x70(%rsp)
movq %rax, 0x10(%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 0x432157
movq 0x290(%rsp), %rdi
cmpl $0x0, 0x30(%rdi)
movq %rbx, 0xd8(%rsp)
movq %rax, 0xe8(%rsp)
je 0x430ebd
movq $0x0, 0x80(%rsp)
movq 0x70(%rsp), %rbx
jmp 0x430f47
movq 0x70(%rsp), %rbx
leal 0xf(%rbx), %r13d
movslq %r13d, %rsi
movl $0x10, %edi
callq 0x2094c8
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x432157
testl %ebx, %ebx
movq 0x290(%rsp), %rdi
movq 0x80(%rsp), %r8
movq 0xf0(%rsp), %r9
jle 0x430f1c
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 0x430f04
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 0x290(%rsp), %rdi
leal 0xf(%r14), %r10d
addb $-0x7f, %r12b
movl %r12d, 0x78(%rsp)
movzbl %r12b, %eax
movd %eax, %xmm1
movzbl 0xb0(%rsp), %eax
movd %eax, %xmm2
movq 0xc8(%rsp), %r8
movl 0x7c(%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 $0xf1, %r8d, %esi
subl %ebp, %esi
movd %esi, %xmm3
imull $0xf2, %r8d, %esi
subl %ebp, %esi
pinsrb $0x1, %esi, %xmm3
imull $0xf3, %r8d, %esi
subl %ebp, %esi
pinsrb $0x2, %esi, %xmm3
imull $0xf4, %r8d, %esi
subl %ebp, %esi
pinsrb $0x3, %esi, %xmm3
imull $0xf5, %r8d, %esi
subl %ebp, %esi
pinsrb $0x4, %esi, %xmm3
imull $0xf6, %r8d, %esi
subl %ebp, %esi
pinsrb $0x5, %esi, %xmm3
imull $0xf7, %r8d, %esi
subl %ebp, %esi
pinsrb $0x6, %esi, %xmm3
leal -0x1(%rbx), %esi
movl %esi, 0x18(%rsp)
pinsrb $0x7, %edx, %xmm3
imull $0xf9, %r8d, %edx
subl %ebp, %edx
pinsrb $0x8, %edx, %xmm3
imull $0xfa, %r8d, %edx
subl %ebp, %edx
pinsrb $0x9, %edx, %xmm3
imull $0xfb, %r8d, %edx
subl %ebp, %edx
pinsrb $0xa, %edx, %xmm3
leal -0x1(%r14), %edx
movl %edx, 0x1c(%rsp)
pxor %xmm0, %xmm0
pshufb %xmm0, %xmm1
movdqa %xmm1, 0xb0(%rsp)
pshufb %xmm0, %xmm2
movdqa %xmm2, 0x100(%rsp)
movd %ebp, %xmm1
pshufb %xmm0, %xmm1
movdqa %xmm1, 0x240(%rsp)
movd %r8d, %xmm1
pshufb %xmm0, %xmm1
movdqa %xmm1, 0x230(%rsp)
psllw $0x4, %xmm1
pand 0x1c4bbd(%rip), %xmm1   # 0x5f5c50
movdqa %xmm1, 0x210(%rsp)
movd %ebx, %xmm1
pshufb %xmm0, %xmm1
movd %r14d, %xmm2
pshufb %xmm0, %xmm2
pcmpeqd %xmm0, %xmm0
paddsb %xmm0, %xmm1
movdqa %xmm1, 0x200(%rsp)
pinsrb $0xb, %ecx, %xmm3
imull $0xfd, %r8d, %ecx
subl %ebp, %ecx
pinsrb $0xc, %ecx, %xmm3
movl %r9d, %ecx
subl %r8d, %ecx
pinsrb $0xd, %eax, %xmm3
pinsrb $0xe, %ecx, %xmm3
paddsb %xmm0, %xmm2
movdqa %xmm2, 0x220(%rsp)
pinsrb $0xf, %r9d, %xmm3
movdqa %xmm3, 0xf0(%rsp)
cmpl $0x2, %r14d
movl $0x1, %r13d
cmovgel %r14d, %r13d
xorl %eax, %eax
movq 0x8(%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 0x431119
xorl %r12d, %r12d
movq %r12, 0x7(%r15)
movq %r12, (%r15)
movl %r14d, %ebx
leaq 0xf(%rbx,%r15), %rdi
leal 0x1(%r14), %eax
cmpl %eax, %r10d
movl %r10d, 0x8(%rsp)
cmovgl %r10d, %eax
movl %r14d, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
negb %bpl
movl 0x78(%rsp), %edx
movq 0xc8(%rsp), %rax
movq 0xd8(%rsp), %r11
movq 0xe8(%rsp), %rdi
movb %bpl, 0xf(%r11,%r12)
movb %dl, 0xf(%rdi,%r12)
incq %r12
subb %al, %bpl
cmpq %r12, %r13
jne 0x431183
xorl %eax, %eax
movb %dl, (%r11,%rax)
movb %dl, (%rdi,%rax)
incq %rax
cmpq $0xf, %rax
jne 0x43119a
leaq 0xf(%rbx), %rax
movq 0x290(%rsp), %rcx
movq 0x80(%rsp), %r12
movl 0x8(%rsp), %r8d
movb %dl, (%r11,%rax)
movb %dl, (%rdi,%rax)
incq %rax
incl %r14d
cmpl %r14d, %r8d
jg 0x4311c3
movb $0x0, 0xe(%r11)
movq 0x70(%rsp), %rsi
testl %esi, %esi
jle 0x43206c
movdqa 0xb0(%rsp), %xmm4
movdqa %xmm4, %xmm0
psrldq $0x1, %xmm0             # xmm0 = xmm0[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
movdqa %xmm0, 0x1f0(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x198(%rsp)
cmpl $0x2, %r8d
movl $0x1, %eax
cmovgel %r8d, %eax
movq %rax, 0x190(%rsp)
movl %esi, %edx
movl 0x18(%rsp), %esi
leaq 0x1(%rbx), %rax
movq %rax, 0x188(%rsp)
leaq 0x2(%rbx), %rax
movq %rax, 0x180(%rsp)
leaq 0x3(%rbx), %rax
movq %rax, 0x178(%rsp)
leaq 0x4(%rbx), %rax
movq %rax, 0x170(%rsp)
leaq 0x5(%rbx), %rax
movq %rax, 0x168(%rsp)
leaq 0x6(%rbx), %rax
movq %rax, 0x160(%rsp)
leaq 0x7(%rbx), %rax
movq %rax, 0x158(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, 0x150(%rsp)
leaq 0x9(%rbx), %rax
movq %rax, 0x148(%rsp)
leaq 0xa(%rbx), %rax
movq %rax, 0x140(%rsp)
leaq 0xb(%rbx), %rax
movq %rax, 0x138(%rsp)
movdqa 0x1c47fb(%rip), %xmm5   # 0x5f5ab0
pcmpeqd %xmm7, %xmm7
movdqa 0x16508e(%rip), %xmm8   # 0x596350
movdqa 0x100(%rsp), %xmm2
movdqa %xmm4, %xmm1
leaq 0xc(%rbx), %rax
movq %rax, 0x130(%rsp)
leaq 0xd(%rbx), %rax
movq %rax, 0x128(%rsp)
leaq 0xe(%rbx), %rax
movq %rax, 0x120(%rsp)
xorl %r8d, %r8d
movq %r12, %r14
movdqa 0x240(%rsp), %xmm6
movdqa 0x230(%rsp), %xmm9
movl 0x30(%rcx), %r12d
movl %r8d, %r10d
testl %r12d, %r12d
movl 0x18(%rsp), %eax
movq %r8, %rdi
jne 0x431324
movsbl (%r14,%rdi), %r10d
movl %r10d, 0x68(%rsp)
movq %rdi, %r8
orq $0x1, %r8
testl %r12d, %r12d
movq %r8, 0x70(%rsp)
je 0x431349
cmpq %rdx, %r8
movl %eax, %ebp
cmovbl %r8d, %ebp
movl %ebp, 0x60(%rsp)
jmp 0x431353
movsbl (%r14,%r8), %r8d
movl %r8d, 0x60(%rsp)
movq %rdi, %r8
orq $0x2, %r8
testl %r12d, %r12d
movq %r8, 0x1e8(%rsp)
je 0x431378
cmpq %rdx, %r8
movl %eax, %r10d
cmovbl %r8d, %r10d
movl %r10d, 0x58(%rsp)
jmp 0x431382
movsbl (%r14,%r8), %r8d
movl %r8d, 0x58(%rsp)
movq %rdi, %r8
orq $0x3, %r8
testl %r12d, %r12d
movq %r8, 0x1e0(%rsp)
je 0x4313a7
cmpq %rdx, %r8
movl %eax, %r10d
cmovbl %r8d, %r10d
movl %r10d, 0x50(%rsp)
jmp 0x4313b1
movsbl (%r14,%r8), %r8d
movl %r8d, 0x50(%rsp)
movq %rdi, %r8
orq $0x4, %r8
testl %r12d, %r12d
movq %r8, 0x1d8(%rsp)
je 0x4313d6
cmpq %rdx, %r8
movl %eax, %r10d
cmovbl %r8d, %r10d
movl %r10d, 0x48(%rsp)
jmp 0x4313e0
movsbl (%r14,%r8), %r8d
movl %r8d, 0x48(%rsp)
movq %rdi, %r8
orq $0x5, %r8
testl %r12d, %r12d
movq %r8, 0x1d0(%rsp)
je 0x431405
cmpq %rdx, %r8
movl %eax, %r10d
cmovbl %r8d, %r10d
movl %r10d, 0x40(%rsp)
jmp 0x43140f
movsbl (%r14,%r8), %r8d
movl %r8d, 0x40(%rsp)
movq %rdi, %r8
orq $0x6, %r8
testl %r12d, %r12d
movq %rdi, 0x8(%rsp)
movq %r8, 0x1c8(%rsp)
je 0x431433
cmpq %rdx, %r8
movl %eax, %edi
cmovbl %r8d, %edi
jmp 0x431438
movsbl (%r14,%r8), %edi
movl %edi, 0x38(%rsp)
movq 0x8(%rcx), %rdi
movq %rdi, 0xe0(%rsp)
movl 0x18(%rcx), %edi
movq 0x8(%rsp), %rcx
orq $0x7, %rcx
testl %r12d, %r12d
movq %rcx, 0x1c0(%rsp)
je 0x431472
cmpq %rdx, %rcx
movl %eax, %r10d
cmovbl %ecx, %r10d
movl %r10d, 0x30(%rsp)
jmp 0x43147b
movsbl (%r14,%rcx), %ecx
movl %ecx, 0x30(%rsp)
movq 0x8(%rsp), %rcx
orq $0x8, %rcx
testl %r12d, %r12d
movq %rcx, 0x1b8(%rsp)
je 0x4314a2
cmpq %rdx, %rcx
movl %eax, %r10d
cmovbl %ecx, %r10d
movl %r10d, 0x28(%rsp)
jmp 0x4314ab
movsbl (%r14,%rcx), %ecx
movl %ecx, 0x28(%rsp)
movq 0x8(%rsp), %rcx
orq $0x9, %rcx
testl %r12d, %r12d
movq %rcx, 0x1b0(%rsp)
je 0x4314d2
cmpq %rdx, %rcx
movl %eax, %r10d
cmovbl %ecx, %r10d
movl %r10d, 0x20(%rsp)
jmp 0x4314db
movsbl (%r14,%rcx), %ecx
movl %ecx, 0x20(%rsp)
movq 0x8(%rsp), %rcx
orq $0xa, %rcx
testl %r12d, %r12d
movq %rcx, 0x1a8(%rsp)
je 0x431505
cmpq %rdx, %rcx
movl %eax, %r10d
cmovbl %ecx, %r10d
movl %r10d, 0xa8(%rsp)
jmp 0x431511
movsbl (%r14,%rcx), %ecx
movl %ecx, 0xa8(%rsp)
movq 0x8(%rsp), %rcx
orq $0xb, %rcx
testl %r12d, %r12d
movq %rcx, 0x1a0(%rsp)
je 0x43153e
movq %r14, %r8
cmpq %rdx, %rcx
movl %eax, %r10d
cmovbl %ecx, %r10d
movl %r10d, 0xa0(%rsp)
jmp 0x43154d
movq %r14, %r8
movsbl (%r14,%rcx), %ecx
movl %ecx, 0xa0(%rsp)
movq 0x8(%rsp), %r9
orq $0xc, %r9
testl %r12d, %r12d
je 0x431566
cmpq %rdx, %r9
movl %eax, %ecx
cmovbl %r9d, %ecx
jmp 0x43156b
movsbl (%r8,%r9), %ecx
movl %ecx, 0x98(%rsp)
movq 0x8(%rsp), %rbp
orq $0xd, %rbp
testl %r12d, %r12d
je 0x431588
cmpq %rdx, %rbp
cmovbl %ebp, %eax
jmp 0x43158d
movsbl (%r8,%rbp), %eax
movl %eax, 0x90(%rsp)
movq 0x8(%rsp), %rax
orq $0xe, %rax
testl %r12d, %r12d
je 0x4315ae
cmpq %rdx, %rax
movl 0x18(%rsp), %ecx
cmovbl %eax, %ecx
jmp 0x4315b3
movsbl (%r8,%rax), %ecx
movl %ecx, 0x88(%rsp)
movq 0x8(%rsp), %rcx
orq $0xf, %rcx
testl %r12d, %r12d
movq %r9, 0x118(%rsp)
je 0x4315de
cmpq %rdx, %rcx
movl 0x18(%rsp), %r14d
cmovbl %ecx, %r14d
jmp 0x4315e3
movsbl (%r8,%rcx), %r14d
movl 0x68(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x68(%rsp)
movl 0x60(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x60(%rsp)
movl 0x58(%rsp), %r8d
imull %edi, %r8d
movl %r8d, 0x58(%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 0xa8(%rsp), %r10d
imull %edi, %r10d
movl 0xa0(%rsp), %r8d
imull %edi, %r8d
movl 0x98(%rsp), %r12d
imull %edi, %r12d
movl 0x90(%rsp), %r13d
imull %edi, %r13d
movl 0x88(%rsp), %r9d
imull %edi, %r9d
imull %edi, %r14d
movl %r14d, 0xd0(%rsp)
movslq 0x68(%rsp), %rdi
movq 0xe0(%rsp), %r14
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x68(%rsp)
movslq 0x60(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x60(%rsp)
movslq 0x58(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x58(%rsp)
movslq 0x50(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x50(%rsp)
movslq 0x48(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x48(%rsp)
movslq 0x40(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x40(%rsp)
movslq 0x38(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x38(%rsp)
movslq 0x30(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x30(%rsp)
movslq 0x28(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x28(%rsp)
movslq 0x20(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x20(%rsp)
movslq %r10d, %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0xa8(%rsp)
movslq %r8d, %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0xa0(%rsp)
movslq %r12d, %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x98(%rsp)
movslq %r13d, %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x90(%rsp)
movslq %r9d, %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0x88(%rsp)
movslq 0xd0(%rsp), %rdi
leaq (%r14,%rdi,4), %rdi
movq %rdi, 0xe0(%rsp)
movq 0x8(%rsp), %r12
leaq 0x10(%r12), %rdi
movq %rdi, 0xd0(%rsp)
movq 0xc8(%rsp), %r10
imull %r10d, %edi
movl 0x7c(%rsp), %r9d
movl %r9d, %r8d
subl %edi, %r8d
movdqa 0x1f0(%rsp), %xmm11
movdqa %xmm11, %xmm3
pinsrb $0xf, 0xe(%r11), %xmm3
movb %r8b, 0xe(%r11)
movl %r12d, %edi
imull %r10d, %edi
movl %r9d, %r8d
subl %edi, %r8d
pinsrb $0xf, %r8d, %xmm11
movdqa %xmm5, %xmm12
pcmpeqb 0x200(%rsp), %xmm12
movdqa 0x1c4456(%rip), %xmm13  # 0x5f5c70
movdqa 0xb0(%rsp), %xmm15
movdqa %xmm15, %xmm14
xorl %r12d, %r12d
movq 0xe8(%rsp), %rdi
movq 0x118(%rsp), %r14
movsbq (%r15,%r12), %r8
movq 0xe0(%rsp), %r9
movd (%r9,%r8,4), %xmm0
movsbq 0x1(%r15,%r12), %r8
movq 0x88(%rsp), %r9
pinsrb $0x1, (%r9,%r8,4), %xmm0
movsbq 0x2(%r15,%r12), %r8
movq 0x90(%rsp), %r9
pinsrb $0x2, (%r9,%r8,4), %xmm0
movsbq 0x3(%r15,%r12), %r8
movq 0x98(%rsp), %r9
pinsrb $0x3, (%r9,%r8,4), %xmm0
movsbq 0x4(%r15,%r12), %r8
movq 0xa0(%rsp), %r9
pinsrb $0x4, (%r9,%r8,4), %xmm0
movsbq 0x5(%r15,%r12), %r8
movq 0xa8(%rsp), %r9
pinsrb $0x5, (%r9,%r8,4), %xmm0
movsbq 0x6(%r15,%r12), %r8
movq 0x20(%rsp), %r9
pinsrb $0x6, (%r9,%r8,4), %xmm0
movsbq 0x7(%r15,%r12), %r8
movq 0x28(%rsp), %r9
pinsrb $0x7, (%r9,%r8,4), %xmm0
movsbq 0x8(%r15,%r12), %r8
movq 0x30(%rsp), %r9
pinsrb $0x8, (%r9,%r8,4), %xmm0
movsbq 0x9(%r15,%r12), %r8
movq 0x38(%rsp), %r9
pinsrb $0x9, (%r9,%r8,4), %xmm0
movsbq 0xa(%r15,%r12), %r8
movq 0x40(%rsp), %r9
pinsrb $0xa, (%r9,%r8,4), %xmm0
movsbq 0xb(%r15,%r12), %r8
movq 0x48(%rsp), %r9
pinsrb $0xb, (%r9,%r8,4), %xmm0
movsbq 0xc(%r15,%r12), %r8
movq 0x50(%rsp), %r9
pinsrb $0xc, (%r9,%r8,4), %xmm0
movsbq 0xd(%r15,%r12), %r8
movq 0x58(%rsp), %r9
pinsrb $0xd, (%r9,%r8,4), %xmm0
movsbq 0xe(%r15,%r12), %r8
movq 0x60(%rsp), %r9
pinsrb $0xe, (%r9,%r8,4), %xmm0
movsbq 0xf(%r15,%r12), %r8
movq 0x68(%rsp), %r9
pinsrb $0xf, (%r9,%r8,4), %xmm0
movdqa %xmm3, %xmm10
movdqa %xmm11, %xmm3
psrldq $0x1, %xmm3             # xmm3 = xmm3[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
pinsrb $0xf, 0xf(%r11,%r12), %xmm3
paddsb %xmm10, %xmm0
psrldq $0x1, %xmm14            # xmm14 = xmm14[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
pinsrb $0xf, 0xf(%rdi,%r12), %xmm14
movq 0x8(%rsp), %rdi
cmpq %rsi, %rdi
movdqa %xmm3, %xmm10
psubsb %xmm6, %xmm10
psubsb %xmm9, %xmm14
pmaxsb %xmm10, %xmm14
psubsb %xmm6, %xmm11
psubsb %xmm9, %xmm15
pmaxsb %xmm11, %xmm15
movdqa %xmm15, %xmm11
pmaxsb %xmm14, %xmm11
pmaxsb %xmm0, %xmm11
movdqa %xmm13, %xmm0
pcmpeqb %xmm7, %xmm0
pblendvb %xmm0, 0xf0(%rsp), %xmm11
setne %r10b
movdqa 0xb0(%rsp), %xmm10
pblendvb %xmm0, %xmm10, %xmm14
pblendvb %xmm0, %xmm10, %xmm15
cmpq $0x10, %r12
jb 0x431a25
pminsb %xmm11, %xmm2
pmaxsb %xmm11, %xmm1
movq 0x10(%rsp), %r8
movq 0x10(%r8), %r8
movq (%r8), %r9
movq 0x8(%r8), %r8
cmpq %rbx, %r12
setae %r11b
orb %r11b, %r10b
pextrb $0xf, %xmm11, %r10d
jne 0x431a50
movsbl %r10b, %r11d
movl %r11d, (%r9,%r12,4)
cmpq %r12, 0x198(%rsp)
jne 0x431a62
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x70(%rsp), %rdi
cmpq %rsi, %rdi
setne %r10b
leaq -0x1(%r12), %r11
cmpq %rbx, %r11
setae %r11b
orb %r10b, %r11b
pextrb $0xe, %xmm11, %r10d
jne 0x431a8f
movsbl %r10b, %r11d
movl %r11d, -0x4(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, %rbx
setne %r13b
orb %r11b, %r13b
jne 0x431aaa
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1e8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431ae4
leaq -0x2(%r12), %r10
cmpq $0x2, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431ae4
pextrb $0xd, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x8(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x188(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431b0b
pextrb $0xd, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1e0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431b45
leaq -0x3(%r12), %r10
cmpq $0x3, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431b45
pextrb $0xc, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0xc(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x180(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431b6c
pextrb $0xc, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1d8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431ba6
leaq -0x4(%r12), %r10
cmpq $0x4, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431ba6
pextrb $0xb, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x10(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x178(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431bcd
pextrb $0xb, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1d0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431c07
leaq -0x5(%r12), %r10
cmpq $0x5, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431c07
pextrb $0xa, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x14(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x170(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431c2e
pextrb $0xa, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1c8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431c68
leaq -0x6(%r12), %r10
cmpq $0x6, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431c68
pextrb $0x9, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x18(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x168(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431c8f
pextrb $0x9, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1c0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431cc9
leaq -0x7(%r12), %r10
cmpq $0x7, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431cc9
pextrb $0x8, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x1c(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x160(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431cf0
pextrb $0x8, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1b8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431d2a
leaq -0x8(%r12), %r10
cmpq $0x8, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431d2a
pextrb $0x7, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x20(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x158(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431d51
pextrb $0x7, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1b0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431d8b
leaq -0x9(%r12), %r10
cmpq $0x9, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431d8b
pextrb $0x6, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x24(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x150(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431db2
pextrb $0x6, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1a8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431dec
leaq -0xa(%r12), %r10
cmpq $0xa, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431dec
pextrb $0x5, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x28(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x148(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431e13
pextrb $0x5, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1a0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x431e4d
leaq -0xb(%r12), %r10
cmpq $0xb, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431e4d
pextrb $0x4, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x2c(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x140(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431e74
pextrb $0x4, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
cmpq %rsi, %r14
jne 0x431ea6
leaq -0xc(%r12), %r10
cmpq $0xc, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431ea6
pextrb $0x3, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x30(%r9,%r12,4)
cmpq %rdx, %r14
setae %r10b
cmpq %r12, 0x138(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431ecd
pextrb $0x3, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%r14,4)
cmpq %rsi, %rbp
jne 0x431eff
leaq -0xd(%r12), %r10
cmpq $0xd, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431eff
pextrb $0x2, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x34(%r9,%r12,4)
cmpq %rdx, %rbp
setae %r10b
cmpq %r12, 0x130(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431f26
pextrb $0x2, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rbp,4)
cmpq %rsi, %rax
jne 0x431f58
leaq -0xe(%r12), %r10
cmpq $0xe, %r12
setae %r11b
cmpq %rbx, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x431f58
pextrb $0x1, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x38(%r9,%r12,4)
cmpq %rdx, %rax
setae %r10b
cmpq %r12, 0x128(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x431f7f
pextrb $0x1, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rax,4)
cmpq %rsi, %rcx
jne 0x431fab
leaq -0xf(%r12), %r10
cmpq $0xf, %r12
setb %r11b
cmpq %rbx, %r10
setge %r10b
orb %r11b, %r10b
jne 0x431fab
movd %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x3c(%r9,%r12,4)
cmpq %rdx, %rcx
setae %r9b
cmpq %r12, 0x120(%rsp)
setne %r10b
orb %r9b, %r10b
movq 0xd8(%rsp), %r11
jne 0x431fd8
movd %xmm11, %r9d
movsbl %r9b, %r9d
movl %r9d, (%r8,%rcx,4)
pextrb $0x0, %xmm11, (%r11,%r12)
movq 0xe8(%rsp), %rdi
pextrb $0x0, %xmm14, (%rdi,%r12)
movdqa %xmm13, %xmm0
pcmpeqb 0x220(%rsp), %xmm0
pand %xmm12, %xmm0
pblendvb %xmm0, %xmm11, %xmm4
paddsb %xmm8, %xmm13
incq %r12
cmpq %r12, 0x190(%rsp)
jne 0x43183c
paddsb 0x164169(%rip), %xmm5   # 0x596190
movdqa 0xf0(%rsp), %xmm0
psubsb 0x210(%rsp), %xmm0
movdqa %xmm0, 0xf0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, %r8
cmpq %rdx, %rax
movq 0x290(%rsp), %rcx
movq 0x80(%rsp), %r14
jb 0x43130c
movl 0x78(%rsp), %edx
jmp 0x432085
movdqa 0xb0(%rsp), %xmm1
movdqa %xmm1, %xmm4
movdqa 0x100(%rsp), %xmm2
movq %r12, %r14
movl $0x10, %eax
pextrb $0xf, %xmm4, %ecx
movzbl %dl, %edx
cmpb %dl, %cl
cmovgl %ecx, %edx
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %eax
jne 0x43208a
movdqa 0xb0(%rsp), %xmm0
pcmpgtb %xmm2, %xmm0
pcmpgtb 0x100(%rsp), %xmm1
por %xmm0, %xmm1
pmovmskb %xmm1, %eax
testl %eax, %eax
je 0x4320de
movq 0x10(%rsp), %rax
orb $0x40, 0xc(%rax)
xorl %edx, %edx
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movsbl %dl, %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rcx)
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rcx)
callq 0x2094b5
movq 0xd8(%rsp), %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x290(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x432160
movq %r14, %rdi
callq 0x2094b5
jmp 0x432160
callq 0x1d368f
jmp 0x432157
callq 0x1d3669
jmp 0x432157
callq 0x1d3643
jmp 0x432157
callq 0x1d361d
jmp 0x432157
callq 0x1d35f7
jmp 0x432157
callq 0x1d35d1
jmp 0x432157
callq 0x1d35ab
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop