// File: /workspace/github_c_makefile_star2_O3/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 0x457687
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x45768e
movl %r8d, %r15d
testl %r8d, %r8d
js 0x457695
testl %r9d, %r9d
js 0x45769c
movq 0x290(%rsp), %r8
testq %r8, %r8
je 0x4576a3
cmpl $0x0, 0x30(%r8)
je 0x4563e4
movl 0x34(%r8), %esi
jmp 0x4563f5
testq %rdi, %rdi
je 0x4576aa
testl %esi, %esi
jle 0x4576b1
movq %rdi, 0x70(%rsp)
movq %rdx, 0x40(%rsp)
movd %r9d, %xmm0
movdqa %xmm0, 0x100(%rsp)
pinsrd $0x1, %r9d, %xmm0
movq %r9, 0x88(%rsp)
pinsrd $0x2, %r9d, %xmm0
pinsrd $0x3, %r15d, %xmm0
pmulld 0x1d5b2d(%rip), %xmm0   # 0x62bf60
movl 0x20(%r8), %eax
movdqa %xmm0, 0xc0(%rsp)
pextrd $0x3, %xmm0, %edi
movl %eax, %ecx
negb %cl
movl %edi, 0x1c(%rsp)
cmpl %edi, %eax
movzbl %cl, %ebp
cmovgl %r15d, %ebp
movb $0x7e, %bl
subb 0x1c(%r8), %bl
movq %rsi, 0x8(%rsp)
movl %esi, %edi
movl %r14d, %esi
callq 0x20ac53
testq %rax, %rax
je 0x4576b6
movq %rax, %r12
movl %r15d, 0x38(%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
movl $0x10, %edi
movq %r13, %rsi
movq %rax, %r13
callq 0x20a620
testq %r15, %r15
sete %dl
testq %r13, %r13
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x4576b6
movq %r12, 0xe0(%rsp)
movq 0x290(%rsp), %rdi
cmpl $0x0, 0x30(%rdi)
movq %rax, 0xb8(%rsp)
je 0x4564fb
xorl %eax, %eax
movq 0x8(%rsp), %r10
jmp 0x456588
movq 0x8(%rsp), %r12
leal 0xf(%r12), %eax
movl %eax, 0x30(%rsp)
movslq %eax, %rsi
movl $0x10, %edi
callq 0x20a620
testq %rax, %rax
je 0x4576b6
testl %r12d, %r12d
movq 0x290(%rsp), %rdi
movq 0x70(%rsp), %r10
jle 0x45654d
movl %r12d, %r8d
xorl %ecx, %ecx
movq 0x10(%rdi), %rdx
movzbl (%r10,%rcx), %esi
movb (%rdx,%rsi,4), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r8
jne 0x456536
movslq %r12d, %rcx
movq %rax, %rdi
addq %rcx, %rdi
leal 0x1(%r12), %ecx
movl 0x30(%rsp), %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movl %r12d, %edx
notl %edx
addl %ecx, %edx
incq %rdx
xorl %esi, %esi
movq %rax, %r12
callq 0x19e090
movq 0x8(%rsp), %r10
movq %r12, %rax
movq 0x290(%rsp), %rdi
movq %rax, 0xd8(%rsp)
movdqa 0x100(%rsp), %xmm3
pshufd $0x0, %xmm3, %xmm6      # xmm6 = xmm3[0,0,0,0]
pmulld 0x1d3859(%rip), %xmm6   # 0x629e00
addb $-0x7f, %bpl
movl %ebp, 0x4c(%rsp)
movzbl %bpl, %eax
movd %eax, %xmm4
pxor %xmm0, %xmm0
movzbl %bl, %eax
movd %eax, %xmm5
movl 0x38(%rsp), %r11d
movd %r11d, %xmm1
movdqa %xmm1, %xmm7
movq 0x88(%rsp), %r8
movl 0x1c(%rsp), %r9d
movl %r9d, %eax
subl %r8d, %eax
subl %r8d, %eax
imull $0xfd, %r8d, %ecx
subl %r11d, %ecx
imull $0xfb, %r8d, %edx
subl %r11d, %edx
leal (,%r8,8), %esi
pshufd $0x0, %xmm1, %xmm2      # xmm2 = xmm1[0,0,0,0]
pinsrd $0x1, %r11d, %xmm1
pinsrd $0x2, %r11d, %xmm1
pinsrd $0x3, %esi, %xmm1
imull $0xf9, %r8d, %esi
subl %r11d, %esi
psubd %xmm2, %xmm6
movdqa 0xc0(%rsp), %xmm2
psubd %xmm1, %xmm2
pmovzxbd 0x1d5825(%rip), %xmm1   # 0x62be64
pand %xmm1, %xmm2
pand %xmm1, %xmm6
packusdw %xmm2, %xmm6
packuswb %xmm0, %xmm6
pinsrb $0x8, %esi, %xmm6
imull $0xfa, %r8d, %esi
subl %r11d, %esi
leal 0xf(%r14), %ebx
pinsrb $0x9, %esi, %xmm6
leal (,%r8,4), %esi
pinsrb $0xa, %edx, %xmm6
movl %r9d, %edx
subl %esi, %edx
leal -0x1(%r10), %esi
movl %esi, 0x14(%rsp)
pinsrb $0xb, %edx, %xmm6
leal -0x1(%r14), %edx
movl %edx, 0x18(%rsp)
pshufb %xmm0, %xmm4
movdqa %xmm4, 0x70(%rsp)
pshufb %xmm0, %xmm5
movdqa %xmm5, 0xf0(%rsp)
pshufb %xmm0, %xmm3
movdqa %xmm3, 0x100(%rsp)
psllw $0x4, %xmm3
pand 0x1d3729(%rip), %xmm3   # 0x629df0
movdqa %xmm3, 0x220(%rsp)
pshufb %xmm0, %xmm7
movdqa %xmm7, 0x240(%rsp)
movd %r10d, %xmm2
pshufb %xmm0, %xmm2
pcmpeqd %xmm1, %xmm1
paddsb %xmm1, %xmm2
movdqa %xmm2, 0x210(%rsp)
movd %r14d, %xmm2
pshufb %xmm0, %xmm2
paddsb %xmm1, %xmm2
movdqa %xmm2, 0x230(%rsp)
pinsrb $0xc, %ecx, %xmm6
movl %r9d, %ecx
subl %r8d, %ecx
pinsrb $0xd, %eax, %xmm6
pinsrb $0xe, %ecx, %xmm6
pinsrb $0xf, %r9d, %xmm6
movdqa %xmm6, 0xc0(%rsp)
movl %r14d, %ebp
xorl %eax, %eax
movq 0x40(%rsp), %rsi
movq 0x10(%rdi), %rcx
movzbl (%rsi,%rax), %edx
movb (%rcx,%rdx,4), %cl
movb %cl, 0xf(%r15,%rax)
incq %rax
cmpq %rax, %rbp
jne 0x456742
xorl %r12d, %r12d
movq %r12, 0x7(%r15)
movq %r12, (%r15)
leaq 0xf(%r15,%rbp), %rdi
leal 0x1(%r14), %eax
cmpl %eax, %ebx
cmovgl %ebx, %eax
movl %r14d, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
movl 0x1c(%rsp), %eax
movl 0x4c(%rsp), %edx
movq 0x88(%rsp), %rcx
movq 0xb8(%rsp), %rdi
movb %al, 0xf(%r13,%r12)
movb %dl, 0xf(%rdi,%r12)
incq %r12
subb %cl, %al
cmpq %r12, %rbp
jne 0x45679b
xorl %eax, %eax
movb %dl, (%r13,%rax)
movb %dl, (%rdi,%rax)
incq %rax
cmpq $0xf, %rax
jne 0x4567b1
leaq 0xf(%rbp), %rax
movq 0x290(%rsp), %r9
movq 0x8(%rsp), %rcx
movb %dl, (%r13,%rax)
movb %dl, (%rdi,%rax)
incq %rax
incl %r14d
cmpl %r14d, %ebx
jg 0x4567d3
movb $0x0, 0xe(%r13)
testl %ecx, %ecx
jle 0x4575d6
movdqa 0x70(%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, 0x200(%rsp)
movl 0x18(%rsp), %eax
movq %rax, 0x190(%rsp)
cmpl $0x2, %ebx
movl $0x1, %eax
cmovgel %ebx, %eax
movq %rax, 0x188(%rsp)
movl %ecx, %edx
movl 0x14(%rsp), %esi
leaq 0x1(%rbp), %rax
movq %rax, 0x180(%rsp)
leaq 0x2(%rbp), %rax
movq %rax, 0x178(%rsp)
leaq 0x3(%rbp), %rax
movq %rax, 0x170(%rsp)
leaq 0x4(%rbp), %rax
movq %rax, 0x168(%rsp)
leaq 0x5(%rbp), %rax
movq %rax, 0x160(%rsp)
leaq 0x6(%rbp), %rax
movq %rax, 0x158(%rsp)
leaq 0x7(%rbp), %rax
movq %rax, 0x150(%rsp)
leaq 0x8(%rbp), %rax
movq %rax, 0x148(%rsp)
leaq 0x9(%rbp), %rax
movq %rax, 0x140(%rsp)
leaq 0xa(%rbp), %rax
movq %rax, 0x138(%rsp)
leaq 0xb(%rbp), %rax
movq %rax, 0x130(%rsp)
movdqa 0x1d3394(%rip), %xmm5   # 0x629c50
pcmpeqd %xmm7, %xmm7
movdqa 0x173a97(%rip), %xmm8   # 0x5ca360
movdqa 0xf0(%rsp), %xmm2
movdqa %xmm4, %xmm1
leaq 0xc(%rbp), %rax
movq %rax, 0x128(%rsp)
leaq 0xd(%rbp), %rax
movq %rax, 0x120(%rsp)
leaq 0xe(%rbp), %rax
movq %rax, 0x118(%rsp)
movq $0x0, 0x8(%rsp)
movq %r13, 0xe8(%rsp)
movdqa 0x240(%rsp), %xmm9
cmpl $0x0, 0x30(%r9)
je 0x456a31
movq 0x8(%rsp), %r11
movq %r11, %rax
orq $0x1, %rax
cmpq %rdx, %rax
movl 0x14(%rsp), %r10d
cmovael %r10d, %eax
movq %rax, 0x28(%rsp)
movq %r11, %rax
orq $0x2, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x20(%rsp)
movq %r11, %rbx
orq $0x3, %rbx
cmpq %rdx, %rbx
cmovael %r10d, %ebx
movq %r11, %rax
orq $0x4, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x40(%rsp)
movq %r11, %r14
orq $0x5, %r14
cmpq %rdx, %r14
cmovael %r10d, %r14d
movq %r11, %rax
orq $0x6, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x38(%rsp)
movq %r11, %r12
orq $0x7, %r12
cmpq %rdx, %r12
cmovael %r10d, %r12d
movq %r11, %rax
orq $0x8, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x30(%rsp)
movq %r11, %r13
orq $0x9, %r13
cmpq %rdx, %r13
cmovael %r10d, %r13d
movq %r11, %rax
orq $0xa, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x68(%rsp)
movq %r11, %rcx
orq $0xb, %rcx
cmpq %rdx, %rcx
cmovael %r10d, %ecx
movq %r11, %rax
orq $0xc, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x60(%rsp)
movq %r11, %r8
orq $0xd, %r8
cmpq %rdx, %r8
cmovael %r10d, %r8d
movq %r11, %rax
orq $0xe, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x58(%rsp)
movq %r11, %rax
orq $0xf, %rax
cmpq %rdx, %rax
cmovael %r10d, %eax
movq %rax, 0x50(%rsp)
movl %r11d, %r10d
jmp 0x456aca
movq 0xd8(%rsp), %rdi
movq 0x8(%rsp), %r11
movsbl (%rdi,%r11), %r10d
movsbl 0x1(%rdi,%r11), %eax
movq %rax, 0x28(%rsp)
movsbl 0x2(%rdi,%r11), %eax
movq %rax, 0x20(%rsp)
movsbl 0x3(%rdi,%r11), %ebx
movsbl 0x4(%rdi,%r11), %eax
movq %rax, 0x40(%rsp)
movsbl 0x5(%rdi,%r11), %r14d
movsbl 0x6(%rdi,%r11), %eax
movq %rax, 0x38(%rsp)
movsbl 0x7(%rdi,%r11), %r12d
movsbl 0x8(%rdi,%r11), %eax
movq %rax, 0x30(%rsp)
movsbl 0x9(%rdi,%r11), %r13d
movsbl 0xa(%rdi,%r11), %eax
movq %rax, 0x68(%rsp)
movsbl 0xb(%rdi,%r11), %ecx
movsbl 0xc(%rdi,%r11), %eax
movq %rax, 0x60(%rsp)
movsbl 0xd(%rdi,%r11), %r8d
movsbl 0xe(%rdi,%r11), %eax
movq %rax, 0x58(%rsp)
movsbl 0xf(%rdi,%r11), %eax
movq %rax, 0x50(%rsp)
movl 0x18(%r9), %r9d
imull %r9d, %r8d
imull %r9d, %ecx
imull %r9d, %r13d
movq %r13, 0x98(%rsp)
imull %r9d, %r12d
movq %r12, 0xa0(%rsp)
imull %r9d, %r14d
movq %r14, 0xa8(%rsp)
imull %r9d, %ebx
movq %rbx, 0xb0(%rsp)
movq 0x28(%rsp), %rax
imull %r9d, %eax
movq %rax, 0x28(%rsp)
imull %r9d, %r10d
movl %r10d, 0x90(%rsp)
movq 0x20(%rsp), %rax
imull %r9d, %eax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %r12
imull %r9d, %r12d
movq 0x38(%rsp), %r13
imull %r9d, %r13d
movq 0x30(%rsp), %r14
imull %r9d, %r14d
movq 0x68(%rsp), %rbx
imull %r9d, %ebx
movq 0x60(%rsp), %r10
imull %r9d, %r10d
movq 0x58(%rsp), %rax
imull %r9d, %eax
movq 0x50(%rsp), %rdi
imull %r9d, %edi
movslq %r8d, %r9
movq 0x290(%rsp), %r8
movq 0x8(%r8), %r8
leaq (%r8,%r9,4), %r9
movq %r9, 0x40(%rsp)
movslq %ecx, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x38(%rsp)
movslq 0x98(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x30(%rsp)
movslq 0xa0(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x68(%rsp)
movslq 0xa8(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x60(%rsp)
movslq 0xb0(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x58(%rsp)
movslq 0x28(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x28(%rsp)
movslq 0x90(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x50(%rsp)
movslq 0x20(%rsp), %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x20(%rsp)
movslq %r12d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0xb0(%rsp)
movslq %r13d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0xa8(%rsp)
movslq %r14d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0xa0(%rsp)
movslq %ebx, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x98(%rsp)
movslq %r10d, %rcx
leaq (%r8,%rcx,4), %rcx
movq %rcx, 0x90(%rsp)
cltq
leaq (%r8,%rax,4), %rax
movq %rax, 0x1f8(%rsp)
movslq %edi, %rax
leaq (%r8,%rax,4), %rax
movq %rax, 0x1f0(%rsp)
leaq 0x10(%r11), %rax
movq %rax, 0x110(%rsp)
movq 0x88(%rsp), %rdi
imull %edi, %eax
movl 0x1c(%rsp), %r8d
movl %r8d, %ecx
subl %eax, %ecx
movdqa 0x200(%rsp), %xmm11
movdqa %xmm11, %xmm3
movq 0xe8(%rsp), %r13
pinsrb $0xf, 0xe(%r13), %xmm3
movb %cl, 0xe(%r13)
movl %r11d, %eax
imull %edi, %eax
movl %r8d, %ecx
subl %eax, %ecx
pinsrb $0xf, %ecx, %xmm11
movq %r11, %rax
orq $0x1, %rax
movq %rax, 0x1e8(%rsp)
movq %r11, %rax
orq $0x2, %rax
movq %rax, 0x1e0(%rsp)
movq %r11, %rax
orq $0x3, %rax
movq %rax, 0x1d8(%rsp)
movq %r11, %rax
orq $0x4, %rax
movq %rax, 0x1d0(%rsp)
movq %r11, %rax
orq $0x5, %rax
movq %rax, 0x1c8(%rsp)
movq %r11, %rax
orq $0x6, %rax
movq %rax, 0x1c0(%rsp)
movq %r11, %rax
orq $0x7, %rax
movq %rax, 0x1b8(%rsp)
movq %r11, %rax
orq $0x8, %rax
movq %rax, 0x1b0(%rsp)
movq %r11, %rax
orq $0x9, %rax
movq %rax, 0x1a8(%rsp)
movq %r11, %rax
orq $0xa, %rax
movq %rax, 0x1a0(%rsp)
movq %r11, %rax
orq $0xb, %rax
movq %rax, 0x198(%rsp)
movq %r11, %r14
orq $0xc, %r14
movq %r11, %rbx
orq $0xd, %rbx
movq %r11, %rax
orq $0xe, %rax
movq %r11, %rcx
orq $0xf, %rcx
movdqa %xmm5, %xmm12
pcmpeqb 0x210(%rsp), %xmm12
movdqa 0x1d3147(%rip), %xmm13  # 0x629ee0
movdqa 0x70(%rsp), %xmm15
movdqa %xmm15, %xmm14
xorl %r12d, %r12d
movq 0xb8(%rsp), %rdi
movsbq (%r15,%r12), %r8
movq 0x1f0(%rsp), %r9
movd (%r9,%r8,4), %xmm0
movsbq 0x1(%r15,%r12), %r8
movq 0x1f8(%rsp), %r9
pinsrb $0x1, (%r9,%r8,4), %xmm0
movsbq 0x2(%r15,%r12), %r8
movq 0x40(%rsp), %r9
pinsrb $0x2, (%r9,%r8,4), %xmm0
movsbq 0x3(%r15,%r12), %r8
movq 0x90(%rsp), %r9
pinsrb $0x3, (%r9,%r8,4), %xmm0
movsbq 0x4(%r15,%r12), %r8
movq 0x38(%rsp), %r9
pinsrb $0x4, (%r9,%r8,4), %xmm0
movsbq 0x5(%r15,%r12), %r8
movq 0x98(%rsp), %r9
pinsrb $0x5, (%r9,%r8,4), %xmm0
movsbq 0x6(%r15,%r12), %r8
movq 0x30(%rsp), %r9
pinsrb $0x6, (%r9,%r8,4), %xmm0
movsbq 0x7(%r15,%r12), %r8
movq 0xa0(%rsp), %r9
pinsrb $0x7, (%r9,%r8,4), %xmm0
movsbq 0x8(%r15,%r12), %r8
movq 0x68(%rsp), %r9
pinsrb $0x8, (%r9,%r8,4), %xmm0
movsbq 0x9(%r15,%r12), %r8
movq 0xa8(%rsp), %r9
pinsrb $0x9, (%r9,%r8,4), %xmm0
movsbq 0xa(%r15,%r12), %r8
movq 0x60(%rsp), %r9
pinsrb $0xa, (%r9,%r8,4), %xmm0
movsbq 0xb(%r15,%r12), %r8
movq 0xb0(%rsp), %r9
pinsrb $0xb, (%r9,%r8,4), %xmm0
movsbq 0xc(%r15,%r12), %r8
movq 0x58(%rsp), %r9
pinsrb $0xc, (%r9,%r8,4), %xmm0
movsbq 0xd(%r15,%r12), %r8
movq 0x20(%rsp), %r9
pinsrb $0xd, (%r9,%r8,4), %xmm0
movsbq 0xe(%r15,%r12), %r8
movq 0x28(%rsp), %r9
pinsrb $0xe, (%r9,%r8,4), %xmm0
movsbq 0xf(%r15,%r12), %r8
movq 0x50(%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(%r13,%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 %xmm9, %xmm10
movdqa 0x100(%rsp), %xmm6
psubsb %xmm6, %xmm14
pmaxsb %xmm10, %xmm14
psubsb %xmm9, %xmm11
psubsb %xmm6, %xmm15
pmaxsb %xmm11, %xmm15
movdqa %xmm15, %xmm11
pmaxsb %xmm14, %xmm11
pmaxsb %xmm0, %xmm11
movdqa %xmm13, %xmm0
pcmpeqb %xmm7, %xmm0
pblendvb %xmm0, 0xc0(%rsp), %xmm11
setne %r10b
movdqa 0x70(%rsp), %xmm6
pblendvb %xmm0, %xmm6, %xmm14
pblendvb %xmm0, %xmm6, %xmm15
cmpq $0x10, %r12
jb 0x456fa1
pminsb %xmm11, %xmm2
pmaxsb %xmm11, %xmm1
movq 0xe0(%rsp), %r8
movq 0x10(%r8), %r8
movq (%r8), %r9
movq 0x8(%r8), %r8
cmpq %rbp, %r12
setae %r11b
orb %r11b, %r10b
pextrb $0xf, %xmm11, %r10d
jne 0x456fcf
movsbl %r10b, %r11d
movl %r11d, (%r9,%r12,4)
cmpq %r12, 0x190(%rsp)
jne 0x456fe1
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1e8(%rsp), %rdi
cmpq %rsi, %rdi
setne %r10b
leaq -0x1(%r12), %r11
cmpq %rbp, %r11
setae %r11b
orb %r10b, %r11b
pextrb $0xe, %xmm11, %r10d
jne 0x457011
movsbl %r10b, %r11d
movl %r11d, -0x4(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r11b
cmpq %r12, %rbp
setne %r13b
orb %r11b, %r13b
jne 0x45702c
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1e0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x457066
leaq -0x2(%r12), %r10
cmpq $0x2, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457066
pextrb $0xd, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x8(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x180(%rsp)
setne %r11b
orb %r10b, %r11b
movq 0xe8(%rsp), %r13
jne 0x457095
pextrb $0xd, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1d8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x4570cf
leaq -0x3(%r12), %r10
cmpq $0x3, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x4570cf
pextrb $0xc, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0xc(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x178(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x4570f6
pextrb $0xc, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1d0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x457130
leaq -0x4(%r12), %r10
cmpq $0x4, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457130
pextrb $0xb, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x10(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x170(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x457157
pextrb $0xb, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1c8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x457191
leaq -0x5(%r12), %r10
cmpq $0x5, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457191
pextrb $0xa, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x14(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x168(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x4571b8
pextrb $0xa, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1c0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x4571f2
leaq -0x6(%r12), %r10
cmpq $0x6, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x4571f2
pextrb $0x9, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x18(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x160(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x457219
pextrb $0x9, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1b8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x457253
leaq -0x7(%r12), %r10
cmpq $0x7, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457253
pextrb $0x8, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x1c(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x158(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x45727a
pextrb $0x8, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1b0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x4572b4
leaq -0x8(%r12), %r10
cmpq $0x8, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x4572b4
pextrb $0x7, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x20(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x150(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x4572db
pextrb $0x7, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1a8(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x457315
leaq -0x9(%r12), %r10
cmpq $0x9, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457315
pextrb $0x6, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x24(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x148(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x45733c
pextrb $0x6, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x1a0(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x457376
leaq -0xa(%r12), %r10
cmpq $0xa, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457376
pextrb $0x5, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x28(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x140(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x45739d
pextrb $0x5, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
movq 0x198(%rsp), %rdi
cmpq %rsi, %rdi
jne 0x4573d7
leaq -0xb(%r12), %r10
cmpq $0xb, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x4573d7
pextrb $0x4, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x2c(%r9,%r12,4)
cmpq %rdx, %rdi
setae %r10b
cmpq %r12, 0x138(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x4573fe
pextrb $0x4, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rdi,4)
cmpq %rsi, %r14
jne 0x457430
leaq -0xc(%r12), %r10
cmpq $0xc, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457430
pextrb $0x3, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x30(%r9,%r12,4)
cmpq %rdx, %r14
setae %r10b
cmpq %r12, 0x130(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x457457
pextrb $0x3, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%r14,4)
cmpq %rsi, %rbx
jne 0x457489
leaq -0xd(%r12), %r10
cmpq $0xd, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x457489
pextrb $0x2, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x34(%r9,%r12,4)
cmpq %rdx, %rbx
setae %r10b
cmpq %r12, 0x128(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x4574b0
pextrb $0x2, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rbx,4)
cmpq %rsi, %rax
jne 0x4574e2
leaq -0xe(%r12), %r10
cmpq $0xe, %r12
setae %r11b
cmpq %rbp, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x4574e2
pextrb $0x1, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, -0x38(%r9,%r12,4)
cmpq %rdx, %rax
setae %r10b
cmpq %r12, 0x120(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x457509
pextrb $0x1, %xmm11, %r10d
movsbl %r10b, %r10d
movl %r10d, (%r8,%rax,4)
cmpq %rsi, %rcx
setne %r10b
cmpq $0xf, %r12
setb %r11b
orb %r10b, %r11b
movd %xmm11, %r10d
jne 0x45752b
movsbl %r10b, %r11d
movl %r11d, -0x3c(%r9,%r12,4)
cmpq %rdx, %rcx
setae %r9b
cmpq %r12, 0x118(%rsp)
setne %r11b
orb %r9b, %r11b
jne 0x45754b
movsbl %r10b, %r9d
movl %r9d, (%r8,%rcx,4)
movb %r10b, (%r13,%r12)
movq 0xb8(%rsp), %rdi
pextrb $0x0, %xmm14, (%rdi,%r12)
movdqa %xmm13, %xmm0
pcmpeqb 0x230(%rsp), %xmm0
pand %xmm12, %xmm0
pblendvb %xmm0, %xmm11, %xmm4
paddsb %xmm8, %xmm13
incq %r12
cmpq %r12, 0x188(%rsp)
jne 0x456db0
paddsb 0x172c29(%rip), %xmm5   # 0x5ca1c0
movdqa 0xc0(%rsp), %xmm0
psubsb 0x220(%rsp), %xmm0
movdqa %xmm0, 0xc0(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq %rdx, %rax
movq 0x290(%rsp), %r9
jb 0x456915
movl 0x4c(%rsp), %edx
jmp 0x4575e9
movdqa 0x70(%rsp), %xmm1
movdqa %xmm1, %xmm4
movdqa 0xf0(%rsp), %xmm2
movl $0x10, %eax
movq 0xe0(%rsp), %rbx
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 0x4575f6
movdqa 0x70(%rsp), %xmm0
pcmpgtb %xmm2, %xmm0
pcmpgtb 0xf0(%rsp), %xmm1
por %xmm0, %xmm1
pmovmskb %xmm1, %eax
testl %eax, %eax
je 0x457642
orb $0x40, 0xc(%rbx)
xorl %edx, %edx
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movsbl %dl, %eax
movl %eax, (%rbx)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rbx)
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rbx)
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x290(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4576b8
movq 0xd8(%rsp), %rdi
callq 0x20a60d
jmp 0x4576b8
callq 0x1d3683
jmp 0x4576b6
callq 0x1d365d
jmp 0x4576b6
callq 0x1d3637
jmp 0x4576b6
callq 0x1d3611
jmp 0x4576b6
callq 0x1d35eb
jmp 0x4576b6
callq 0x1d35c5
jmp 0x4576b6
callq 0x1d359f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)