// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_diag_avx2_256_16.c
// Function: parasail_nw_rowcol_diag_avx2_256_16
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;
    int16_t * restrict s1 = NULL;
    int16_t * restrict s2B = NULL;
    int16_t * restrict _H_pr = NULL;
    int16_t * restrict _F_pr = NULL;
    int16_t * restrict s2 = NULL;
    int16_t * restrict H_pr = NULL;
    int16_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;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    int16_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    __m256i vNegInf;
    __m256i vOpen;
    __m256i vGap;
    __m256i vOne;
    __m256i vN;
    __m256i vGapN;
    __m256i vNegOne;
    __m256i vI;
    __m256i vJreset;
    __m256i vMax;
    __m256i vILimit;
    __m256i vILimit1;
    __m256i vJLimit;
    __m256i vJLimit1;
    __m256i 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 ? INT16_MIN + open : INT16_MIN - matrix->min) + 1;
    POS_LIMIT = INT16_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi16(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInf = _mm256_set1_epi16(NEG_LIMIT);
    vOpen = _mm256_set1_epi16(open);
    vGap  = _mm256_set1_epi16(gap);
    vOne = _mm256_set1_epi16(1);
    vN = _mm256_set1_epi16(N);
    vGapN = _mm256_set1_epi16(gap*N);
    vNegOne = _mm256_set1_epi16(-1);
    vI = _mm256_set_epi16(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);
    vJreset = _mm256_set_epi16(0,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15);
    vMax = vNegInf;
    vILimit = _mm256_set1_epi16(s1Len);
    vILimit1 = _mm256_subs_epi16(vILimit, vOne);
    vJLimit = _mm256_set1_epi16(s2Len);
    vJLimit1 = _mm256_subs_epi16(vJLimit, vOne);
    vIBoundary = _mm256_set_epi16(
            -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_16 | 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_int16_t(32, s2Len+PAD2);
    _H_pr = parasail_memalign_int16_t(32, s2Len+PAD2);
    _F_pr = parasail_memalign_int16_t(32, 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_int16_t(32, 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) {
        __m256i vNH = vNegInf;
        __m256i vWH = vNegInf;
        __m256i vE = vNegInf;
        __m256i vF = vNegInf;
        __m256i 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 = _mm256_srli_si256_rpl(vNH, 2);
        vNH = _mm256_insert_epi16_rpl(vNH, H_pr[-1], 15);
        vWH = _mm256_srli_si256_rpl(vWH, 2);
        vWH = _mm256_insert_epi16_rpl(vWH, -open - i*gap, 15);
        H_pr[-1] = -open - (i+N)*gap;
        /* iterate over database sequence */
        for (j=0; j<s2Len+PAD; ++j) {
            __m256i vMat;
            __m256i vNWH = vNH;
            vNH = _mm256_srli_si256_rpl(vWH, 2);
            vNH = _mm256_insert_epi16_rpl(vNH, H_pr[j], 15);
            vF = _mm256_srli_si256_rpl(vF, 2);
            vF = _mm256_insert_epi16_rpl(vF, F_pr[j], 15);
            vF = _mm256_max_epi16(
                    _mm256_subs_epi16(vNH, vOpen),
                    _mm256_subs_epi16(vF, vGap));
            vE = _mm256_max_epi16(
                    _mm256_subs_epi16(vWH, vOpen),
                    _mm256_subs_epi16(vE, vGap));
            vMat = _mm256_set_epi16(
                    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 = _mm256_adds_epi16(vNWH, vMat);
            vWH = _mm256_max_epi16(vNWH, vE);
            vWH = _mm256_max_epi16(vWH, vF);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m256i cond = _mm256_cmpeq_epi16(vJ,vNegOne);
                vWH = _mm256_blendv_epi8(vWH, vIBoundary, cond);
                vF = _mm256_blendv_epi8(vF, vNegInf, cond);
                vE = _mm256_blendv_epi8(vE, vNegInf, cond);
            }
            /* cannot start checking sat until after J clears boundary */
            if (j > PAD) {
                vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm256_max_epi16(vSaturationCheckMax, vWH);
            }
#ifdef PARASAIL_TABLE
            arr_store_si256(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] = (int16_t)_mm256_extract_epi16_rpl(vWH,0);
            F_pr[j-15] = (int16_t)_mm256_extract_epi16_rpl(vF,0);
            /* as minor diagonal vector passes across table, extract
               last table value at the i,j bound */
            {
                __m256i cond_valid_I = _mm256_cmpeq_epi16(vI, vILimit1);
                __m256i cond_valid_J = _mm256_cmpeq_epi16(vJ, vJLimit1);
                __m256i cond_all = _mm256_and_si256(cond_valid_I, cond_valid_J);
                vMax = _mm256_blendv_epi8(vMax, vWH, cond_all);
            }
            vJ = _mm256_adds_epi16(vJ, vOne);
        }
        vI = _mm256_adds_epi16(vI, vN);
        vIBoundary = _mm256_subs_epi16(vIBoundary, vGapN);
    }

    /* max in vMax */
    for (i=0; i<N; ++i) {
        int16_t value;
        value = (int16_t) _mm256_extract_epi16_rpl(vMax, 15);
        if (value > score) {
            score = value;
        }
        vMax = _mm256_slli_si256_rpl(vMax, 2);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi16_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi16(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 $0x2f8, %rsp            # imm = 0x2F8
testq %rdx, %rdx
je 0x55d9ce
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x55d9d5
movl %r8d, %r15d
testl %r8d, %r8d
js 0x55d9dc
testl %r9d, %r9d
js 0x55d9e3
movq 0x330(%rsp), %rcx
testq %rcx, %rcx
je 0x55d9ea
cmpl $0x0, 0x30(%rcx)
je 0x55c6ce
movl 0x34(%rcx), %ebx
jmp 0x55c6e1
testq %rdi, %rdi
je 0x55d9f1
movl %esi, %ebx
testl %esi, %esi
jle 0x55d9f8
movq %rdi, 0xc0(%rsp)
movq %rdx, 0x60(%rsp)
movq %r9, 0x80(%rsp)
vmovd %r9d, %xmm0
vpinsrd $0x1, %r15d, %xmm0, %xmm0
vpmovsxbd 0xd1afa(%rip), %ymm1 # 0x62e204
vpermd %ymm0, %ymm1, %ymm0
vpmulld 0xd1a88(%rip), %ymm0, %ymm0 # 0x62e1a0
movl 0x20(%rcx), %eax
vmovdqu %ymm0, 0x1d0(%rsp)
vextracti128 $0x1, %ymm0, %xmm0
vpextrd $0x3, %xmm0, %edx
movl %eax, %ebp
negl %ebp
movl %edx, 0x1c(%rsp)
cmpl %edx, %eax
cmovgl %r15d, %ebp
movw $0x7ffe, %r13w          # imm = 0x7FFE
subw 0x1c(%rcx), %r13w
movl %ebx, %edi
movl %r14d, %esi
vzeroupper
callq 0x20ac53
testq %rax, %rax
je 0x55d9fd
movq %rax, %r12
movl %r13d, 0x50(%rsp)
movl %r15d, 0x58(%rsp)
movq %rbx, 0x10(%rsp)
orl $0x10241001, 0xc(%rax)  # imm = 0x10241001
leal 0x1e(%r14), %r13d
movl $0x20, %edi
movq %r13, %rsi
callq 0x20a625
movq %rax, %r15
movl $0x20, %edi
movq %r13, %rsi
callq 0x20a625
movq %rax, %rbx
movl $0x20, %edi
movq %r13, %rsi
callq 0x20a625
testq %r15, %r15
sete %dl
testq %rbx, %rbx
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x55d9fd
movq %rbx, 0x70(%rsp)
movq %r12, 0xb8(%rsp)
movq 0x330(%rsp), %r9
cmpl $0x0, 0x30(%r9)
movq %rax, 0xa8(%rsp)
je 0x55c7f9
movq $0x0, 0x78(%rsp)
movl %ebp, %r13d
jmp 0x55c882
movq 0x10(%rsp), %rbx
leal 0xf(%rbx), %r12d
movslq %r12d, %rsi
movl $0x20, %edi
callq 0x20a625
testq %rax, %rax
je 0x55d9fd
movq %rax, %rdi
testl %ebx, %ebx
movl %ebp, %r13d
movq 0xc0(%rsp), %r8
jle 0x55c84f
movq 0x330(%rsp), %rax
movq 0x10(%rax), %rax
movl %ebx, %ecx
xorl %edx, %edx
movzbl (%r8,%rdx), %esi
movzwl (%rax,%rsi,4), %esi
movw %si, (%rdi,%rdx,2)
incq %rdx
cmpq %rdx, %rcx
jne 0x55c83a
movslq %ebx, %rax
leal 0x1(%rbx), %ecx
cmpl %ecx, %r12d
cmovgl %r12d, %ecx
movq %rdi, 0x78(%rsp)
leaq (%rdi,%rax,2), %rdi
movl %ebx, %eax
notl %eax
addl %ecx, %eax
leaq 0x2(,%rax,2), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x330(%rsp), %r9
vmovd 0x50(%rsp), %xmm0
movl 0x58(%rsp), %ebx
vmovd %ebx, %xmm1
movq 0x80(%rsp), %r10
movl %r10d, %eax
shll $0x4, %eax
vmovd %eax, %xmm2
movl 0x1c(%rsp), %r11d
movl %r11d, %eax
subl %r10d, %eax
subl %r10d, %eax
imull $0xfffd, %r10d, %ecx    # imm = 0xFFFD
subl %ebx, %ecx
leal (,%r10,4), %esi
movl %r11d, %edx
subl %esi, %edx
imull $0xfffb, %r10d, %esi    # imm = 0xFFFB
subl %ebx, %esi
imull $0xfffa, %r10d, %edi    # imm = 0xFFFA
subl %ebx, %edi
leal (,%r10,8), %r8d
vmovd %ebx, %xmm3
vpinsrd $0x1, %r8d, %xmm3, %xmm3
imull $0xfff9, %r10d, %r8d    # imm = 0xFFF9
subl %ebx, %r8d
vmovd %r8d, %xmm4
leal 0xf(%r14), %ebx
movq 0x10(%rsp), %r8
vmovd %r8d, %xmm5
vpbroadcastw %xmm5, %ymm5
vpcmpeqd %ymm6, %ymm6, %ymm6
vpaddsw %ymm6, %ymm5, %ymm5
vmovdqu %ymm5, 0x270(%rsp)
vmovd %r14d, %xmm5
vpbroadcastw %xmm5, %ymm5
vpaddsw %ymm6, %ymm5, %ymm5
vmovdqu %ymm5, 0x2d0(%rsp)
vmovd %edi, %xmm5
leal -0x1(%r8), %edi
movl %edi, 0xc(%rsp)
vpmovsxbd 0xd18bb(%rip), %ymm6 # 0x62e204
vpermd %ymm3, %ymm6, %ymm3
vmovd %esi, %xmm6
leal -0x1(%r14), %esi
movl %esi, 0x18(%rsp)
addl $0xffff8001, %r13d      # imm = 0xFFFF8001
vmovdqu 0x1d0(%rsp), %ymm7
vpsubd %ymm3, %ymm7, %ymm3
vmovd %r13d, %xmm7
vpbroadcastw %xmm7, %ymm7
vmovdqu %ymm7, 0xc0(%rsp)
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x1f0(%rsp)
vpbroadcastw %xmm1, %ymm0
vmovdqu %ymm0, 0x2b0(%rsp)
vpbroadcastw %xmm4, %ymm0
vpbroadcastw %xmm5, %ymm1
vpblendw $0x2, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0],ymm1[1],ymm0[2,3,4,5,6,7,8],ymm1[9],ymm0[10,11,12,13,14,15]
vmovd %r10d, %xmm1
vpbroadcastw %xmm1, %ymm1
vmovdqu %ymm1, 0x290(%rsp)
vpbroadcastw %xmm2, %ymm1
vmovdqu %ymm1, 0x250(%rsp)
vpbroadcastw %xmm6, %ymm1
vpblendw $0x4, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1],ymm1[2],ymm0[3,4,5,6,7,8,9],ymm1[10],ymm0[11,12,13,14,15]
vmovd %edx, %xmm1
movl %r11d, %edx
vpshufb 0xd17d7(%rip), %ymm3, %ymm2 # 0x62e1c0
subl %r10d, %edx
vpermq $0xe8, %ymm2, %ymm2     # ymm2 = ymm2[0,2,2,3]
vpbroadcastw %xmm1, %ymm1
vpblendw $0x8, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2],ymm1[3],ymm0[4,5,6,7,8,9,10],ymm1[11],ymm0[12,13,14,15]
vmovd %ecx, %xmm1
vpbroadcastw %xmm1, %ymm1
vpblendw $0x10, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3],ymm1[4],ymm0[5,6,7,8,9,10,11],ymm1[12],ymm0[13,14,15]
vmovd %eax, %xmm1
vpbroadcastw %xmm1, %ymm1
vpblendw $0x20, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3,4],ymm1[5],ymm0[6,7,8,9,10,11,12],ymm1[13],ymm0[14,15]
vmovd %edx, %xmm1
vpbroadcastw %xmm1, %ymm1
vpblendw $0x40, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3,4,5],ymm1[6],ymm0[7,8,9,10,11,12,13],ymm1[14],ymm0[15]
vmovd %r11d, %xmm1
vpbroadcastw %xmm1, %ymm1
vpblendw $0x80, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3,4,5,6],ymm1[7],ymm0[8,9,10,11,12,13,14],ymm1[15]
vpblendd $0xf0, %ymm0, %ymm2, %ymm0 # ymm0 = ymm2[0,1,2,3],ymm0[4,5,6,7]
vmovdqu %ymm0, 0x1d0(%rsp)
movq 0x10(%r9), %rax
movl %r14d, %ebp
xorl %ecx, %ecx
movq 0x60(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movzwl (%rax,%rdx,4), %edx
movw %dx, 0x1e(%r15,%rcx,2)
incq %rcx
cmpq %rcx, %rbp
jne 0x55ca57
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, 0xe(%r15)
vmovdqu %xmm0, (%r15)
leal 0x1(%r14), %eax
cmpl %eax, %ebx
cmovgl %ebx, %eax
leaq (%r15,%rbp,2), %rdi
addq $0x1e, %rdi
movl %r14d, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x2(,%rcx,2), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movl 0x1c(%rsp), %eax
movq 0x80(%rsp), %rcx
movq 0x70(%rsp), %r10
movq 0xa8(%rsp), %rdi
movw %ax, 0x1e(%r10,%r12,2)
subl %ecx, %eax
movw %r13w, 0x1e(%rdi,%r12,2)
incq %r12
cmpq %r12, %rbp
jne 0x55cac2
xorl %eax, %eax
movw %r13w, (%r10,%rax,2)
movw %r13w, (%rdi,%rax,2)
incq %rax
cmpq $0xf, %rax
jne 0x55cada
leaq 0xf(%rbp), %rax
movq 0x330(%rsp), %r9
movw %r13w, (%r10,%rax,2)
movw %r13w, (%rdi,%rax,2)
incq %rax
incl %r14d
cmpl %r14d, %ebx
jg 0x55caf9
movw $0x0, 0x1c(%r10)
movq 0x10(%rsp), %rcx
testl %ecx, %ecx
jle 0x55d904
movl %r13d, 0xb4(%rsp)
movq 0x8(%r9), %rax
movq %rax, 0xe0(%rsp)
vmovdqu 0xc0(%rsp), %ymm2
vextracti128 $0x1, %ymm2, %xmm0
vpalignr $0x2, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm0[0,1],ymm2[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm0[16,17]
vmovdqu %ymm0, 0x230(%rsp)
movl 0x18(%rsp), %eax
movq %rax, 0x168(%rsp)
cmpl $0x2, %ebx
movl $0x1, %eax
cmovgel %ebx, %eax
movq %rax, 0x160(%rsp)
movl %ecx, %esi
movl 0xc(%rsp), %r13d
leaq 0x1(%rbp), %rax
movq %rax, 0x158(%rsp)
leaq 0x2(%rbp), %rax
movq %rax, 0x150(%rsp)
leaq 0x3(%rbp), %rax
movq %rax, 0x148(%rsp)
leaq 0x4(%rbp), %rax
movq %rax, 0x140(%rsp)
leaq 0x5(%rbp), %rax
movq %rax, 0x138(%rsp)
leaq 0x6(%rbp), %rax
movq %rax, 0x130(%rsp)
leaq 0x7(%rbp), %rax
movq %rax, 0x128(%rsp)
leaq 0x8(%rbp), %rax
movq %rax, 0x120(%rsp)
leaq 0x9(%rbp), %rax
movq %rax, 0x118(%rsp)
leaq 0xa(%rbp), %rax
movq %rax, 0x110(%rsp)
vpmovsxbw 0xd1611(%rip), %ymm4 # 0x62e20c
vpcmpeqd %ymm6, %ymm6, %ymm6
vpbroadcastw 0xd2a60(%rip), %ymm7 # 0x62f668
vpbroadcastw 0xd2a59(%rip), %ymm0 # 0x62f66a
vmovdqu %ymm0, 0x210(%rsp)
vmovdqu 0x1f0(%rsp), %ymm0
vmovdqa %ymm2, %ymm1
leaq 0xb(%rbp), %rax
movq %rax, 0x108(%rsp)
leaq 0xc(%rbp), %rax
movq %rax, 0x100(%rsp)
leaq 0xd(%rbp), %rax
movq %rax, 0xf8(%rsp)
leaq 0xe(%rbp), %rax
movq %rax, 0xf0(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x30(%r9)
je 0x55cd7b
movq 0x10(%rsp), %rdi
movq %rdi, %rax
orq $0x1, %rax
cmpq %rsi, %rax
movl 0xc(%rsp), %r11d
cmovael %r11d, %eax
movq %rax, 0x58(%rsp)
movq %rdi, %rax
orq $0x2, %rax
cmpq %rsi, %rax
cmovael %r11d, %eax
movq %rax, 0x60(%rsp)
movq %rdi, %rax
orq $0x3, %rax
cmpq %rsi, %rax
cmovael %r11d, %eax
movq %rdi, %rcx
orq $0x4, %rcx
cmpq %rsi, %rcx
cmovael %r11d, %ecx
movq %rcx, 0x40(%rsp)
movq %rdi, %rcx
orq $0x5, %rcx
cmpq %rsi, %rcx
cmovael %r11d, %ecx
movq %rcx, 0x48(%rsp)
movq %rdi, %rbx
orq $0x6, %rbx
cmpq %rsi, %rbx
cmovael %r11d, %ebx
movq %rdi, %rdx
orq $0x7, %rdx
cmpq %rsi, %rdx
cmovael %r11d, %edx
movq %rdi, %rcx
orq $0x8, %rcx
cmpq %rsi, %rcx
cmovael %r11d, %ecx
movq %rcx, 0x38(%rsp)
movq %rdi, %r12
orq $0x9, %r12
cmpq %rsi, %r12
cmovael %r11d, %r12d
movq %rdi, %rcx
orq $0xa, %rcx
cmpq %rsi, %rcx
cmovael %r11d, %ecx
movq %rcx, 0x30(%rsp)
movq %rdi, %r14
orq $0xb, %r14
cmpq %rsi, %r14
cmovael %r11d, %r14d
movq %rdi, %rcx
orq $0xc, %rcx
cmpq %rsi, %rcx
cmovael %r11d, %ecx
movq %rcx, 0x28(%rsp)
movq %rdi, %r8
orq $0xd, %r8
cmpq %rsi, %r8
cmovael %r11d, %r8d
movq %rdi, %rcx
orq $0xe, %rcx
cmpq %rsi, %rcx
cmovael %r11d, %ecx
movq %rcx, 0x20(%rsp)
movq %rdi, %rcx
orq $0xf, %rcx
cmpq %rsi, %rcx
cmovael %r11d, %ecx
movq %rcx, 0x50(%rsp)
movl %edi, %ecx
jmp 0x55ce13
movq 0x78(%rsp), %rdx
movq 0x10(%rsp), %rdi
movswl (%rdx,%rdi,2), %eax
movl %eax, 0x68(%rsp)
movswl 0x2(%rdx,%rdi,2), %eax
movq %rax, 0x58(%rsp)
movswl 0x4(%rdx,%rdi,2), %eax
movq %rax, 0x60(%rsp)
movswl 0x6(%rdx,%rdi,2), %eax
movswl 0x8(%rdx,%rdi,2), %ecx
movq %rcx, 0x40(%rsp)
movswl 0xa(%rdx,%rdi,2), %ecx
movq %rcx, 0x48(%rsp)
movswl 0xc(%rdx,%rdi,2), %r11d
movswl 0xe(%rdx,%rdi,2), %ebx
movswl 0x10(%rdx,%rdi,2), %ecx
movq %rcx, 0x38(%rsp)
movswl 0x12(%rdx,%rdi,2), %r12d
movswl 0x14(%rdx,%rdi,2), %ecx
movq %rcx, 0x30(%rsp)
movswl 0x16(%rdx,%rdi,2), %r14d
movswl 0x18(%rdx,%rdi,2), %ecx
movq %rcx, 0x28(%rsp)
movswl 0x1a(%rdx,%rdi,2), %r8d
movswl 0x1c(%rdx,%rdi,2), %ecx
movq %rcx, 0x20(%rsp)
movswl 0x1e(%rdx,%rdi,2), %ecx
movq %rcx, 0x50(%rsp)
movl 0x68(%rsp), %ecx
movq %rbx, %rdx
movq %r11, %rbx
movl 0x18(%r9), %r9d
imull %r9d, %r8d
imull %r9d, %r14d
movq %r14, 0xa0(%rsp)
imull %r9d, %r12d
movq %r12, 0x98(%rsp)
imull %r9d, %edx
movq %rdx, 0x90(%rsp)
movq 0x48(%rsp), %r11
imull %r9d, %r11d
movq %r11, 0x48(%rsp)
imull %r9d, %eax
movq 0x58(%rsp), %r12
imull %r9d, %r12d
imull %r9d, %ecx
movl %ecx, 0x68(%rsp)
movq 0x60(%rsp), %r14
imull %r9d, %r14d
movq 0x40(%rsp), %rcx
imull %r9d, %ecx
movq %rcx, 0x40(%rsp)
imull %r9d, %ebx
movq %rbx, 0x88(%rsp)
movq 0x38(%rsp), %rdx
imull %r9d, %edx
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rdx
imull %r9d, %edx
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rdx
imull %r9d, %edx
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rdx
imull %r9d, %edx
movq %rdx, 0x20(%rsp)
movq 0x50(%rsp), %rdx
imull %r9d, %edx
vpbroadcastw 0x1c(%r10), %ymm5
leaq 0x10(%rdi), %r9
movq %r9, 0xe8(%rsp)
movq 0x80(%rsp), %r11
imull %r11d, %r9d
movl 0x1c(%rsp), %ebx
movl %ebx, %r10d
subl %r9d, %r10d
movq 0x70(%rsp), %r9
movw %r10w, 0x1c(%r9)
movl %edi, %r9d
imull %r11d, %r9d
subl %r9d, %ebx
vmovd %ebx, %xmm9
movq 0x70(%rsp), %r10
movslq %r8d, %r8
movq 0xe0(%rsp), %r9
leaq (%r9,%r8,4), %r8
movq %r8, 0x60(%rsp)
movslq 0xa0(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x58(%rsp)
movslq 0x98(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x50(%rsp)
movslq 0x90(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0xa0(%rsp)
movslq 0x48(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x48(%rsp)
movslq %eax, %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x98(%rsp)
movslq %r12d, %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x90(%rsp)
movslq 0x68(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x68(%rsp)
movslq %r14d, %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x1c8(%rsp)
movslq 0x40(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x40(%rsp)
movslq 0x88(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x88(%rsp)
movslq 0x38(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x38(%rsp)
movslq 0x30(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x30(%rsp)
movslq 0x28(%rsp), %rcx
leaq (%r9,%rcx,4), %rcx
movq %rcx, 0x28(%rsp)
movslq 0x20(%rsp), %rax
leaq (%r9,%rax,4), %rax
movq %rax, 0x20(%rsp)
movslq %edx, %rax
leaq (%r9,%rax,4), %rax
movq %rax, 0x1c0(%rsp)
vpbroadcastw %xmm9, %ymm9
vmovdqu 0x230(%rsp), %ymm3
vpblendw $0x80, %ymm9, %ymm3, %ymm9 # ymm9 = ymm3[0,1,2,3,4,5,6],ymm9[7],ymm3[8,9,10,11,12,13,14],ymm9[15]
vpblendd $0xf0, %ymm9, %ymm3, %ymm9 # ymm9 = ymm3[0,1,2,3],ymm9[4,5,6,7]
vpblendw $0x80, %ymm5, %ymm3, %ymm5 # ymm5 = ymm3[0,1,2,3,4,5,6],ymm5[7],ymm3[8,9,10,11,12,13,14],ymm5[15]
vpblendd $0xf0, %ymm5, %ymm3, %ymm10 # ymm10 = ymm3[0,1,2,3],ymm5[4,5,6,7]
movq %rdi, %rax
orq $0x1, %rax
movq %rax, 0x1b8(%rsp)
movq %rdi, %rax
orq $0x2, %rax
movq %rax, 0x1b0(%rsp)
movq %rdi, %rax
orq $0x3, %rax
movq %rax, 0x1a8(%rsp)
movq %rdi, %rax
orq $0x4, %rax
movq %rax, 0x1a0(%rsp)
movq %rdi, %rax
orq $0x5, %rax
movq %rax, 0x198(%rsp)
movq %rdi, %rax
orq $0x6, %rax
movq %rax, 0x190(%rsp)
movq %rdi, %rax
orq $0x7, %rax
movq %rax, 0x188(%rsp)
movq %rdi, %rax
orq $0x8, %rax
movq %rax, 0x180(%rsp)
movq %rdi, %rax
orq $0x9, %rax
movq %rax, 0x178(%rsp)
movq %rdi, %rax
orq $0xa, %rax
movq %rax, 0x170(%rsp)
movq %rdi, %r12
orq $0xb, %r12
movq %rdi, %rax
orq $0xc, %rax
movq %rdi, %rbx
orq $0xd, %rbx
movq %rdi, %rcx
orq $0xe, %rcx
movq %rdi, %rdx
orq $0xf, %rdx
vpcmpeqw 0x270(%rsp), %ymm4, %ymm11
vpmovsxbw 0xd1124(%rip), %ymm12 # 0x62e21c
vmovdqu 0xc0(%rsp), %ymm5
vmovdqa %ymm5, %ymm13
xorl %r8d, %r8d
movq 0xa8(%rsp), %rdi
movswq 0x10(%r15,%r8,2), %r9
movq 0xa0(%rsp), %r11
vmovd (%r11,%r9,4), %xmm14
movswq 0x12(%r15,%r8,2), %r9
movq 0x88(%rsp), %r11
vpinsrw $0x1, (%r11,%r9,4), %xmm14, %xmm14
movswq 0x14(%r15,%r8,2), %r9
movq 0x48(%rsp), %r11
vpinsrw $0x2, (%r11,%r9,4), %xmm14, %xmm14
movswq 0x16(%r15,%r8,2), %r9
movq 0x40(%rsp), %r11
vpinsrw $0x3, (%r11,%r9,4), %xmm14, %xmm14
movswq 0x18(%r15,%r8,2), %r9
movq 0x98(%rsp), %r11
vpinsrw $0x4, (%r11,%r9,4), %xmm14, %xmm14
movswq 0x1a(%r15,%r8,2), %r9
movq 0x1c8(%rsp), %r11
vpinsrw $0x5, (%r11,%r9,4), %xmm14, %xmm14
movswq 0x1c(%r15,%r8,2), %r9
movq 0x90(%rsp), %r11
vpinsrw $0x6, (%r11,%r9,4), %xmm14, %xmm14
movswq 0x1e(%r15,%r8,2), %r9
movq 0x68(%rsp), %r11
vpinsrw $0x7, (%r11,%r9,4), %xmm14, %xmm14
movswq (%r15,%r8,2), %r9
movq 0x1c0(%rsp), %r11
vmovd (%r11,%r9,4), %xmm15
movswq 0x2(%r15,%r8,2), %r9
movq 0x20(%rsp), %r11
vpinsrw $0x1, (%r11,%r9,4), %xmm15, %xmm15
movswq 0x4(%r15,%r8,2), %r9
movq 0x60(%rsp), %r11
vpinsrw $0x2, (%r11,%r9,4), %xmm15, %xmm15
movswq 0x6(%r15,%r8,2), %r9
movq 0x28(%rsp), %r11
vpinsrw $0x3, (%r11,%r9,4), %xmm15, %xmm15
movswq 0x8(%r15,%r8,2), %r9
movq 0x58(%rsp), %r11
vpinsrw $0x4, (%r11,%r9,4), %xmm15, %xmm15
movswq 0xa(%r15,%r8,2), %r9
movq 0x30(%rsp), %r11
vpinsrw $0x5, (%r11,%r9,4), %xmm15, %xmm15
movswq 0xc(%r15,%r8,2), %r9
movq 0x50(%rsp), %r11
vpinsrw $0x6, (%r11,%r9,4), %xmm15, %xmm15
movswq 0xe(%r15,%r8,2), %r9
movq 0x38(%rsp), %r11
vpinsrw $0x7, (%r11,%r9,4), %xmm15, %xmm15
vinserti128 $0x1, %xmm14, %ymm15, %ymm14
vextracti128 $0x1, %ymm9, %xmm15
vpaddsw %ymm14, %ymm10, %ymm8
vpbroadcastw 0x1e(%r10,%r8,2), %ymm10
vpalignr $0x2, %ymm9, %ymm15, %ymm14 # ymm14 = ymm9[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm15[0,1],ymm9[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm15[16,17]
vpblendw $0x80, %ymm10, %ymm14, %ymm10 # ymm10 = ymm14[0,1,2,3,4,5,6],ymm10[7],ymm14[8,9,10,11,12,13,14],ymm10[15]
vpblendd $0xf0, %ymm10, %ymm14, %ymm10 # ymm10 = ymm14[0,1,2,3],ymm10[4,5,6,7]
vextracti128 $0x1, %ymm13, %xmm14
vpalignr $0x2, %ymm13, %ymm14, %ymm13 # ymm13 = ymm13[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm14[0,1],ymm13[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm14[16,17]
vpbroadcastw 0x1e(%rdi,%r8,2), %ymm14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
setne %r11b
vpblendw $0x80, %ymm14, %ymm13, %ymm14 # ymm14 = ymm13[0,1,2,3,4,5,6],ymm14[7],ymm13[8,9,10,11,12,13,14],ymm14[15]
vpblendd $0xf0, %ymm14, %ymm13, %ymm13 # ymm13 = ymm13[0,1,2,3],ymm14[4,5,6,7]
vmovdqu 0x2b0(%rsp), %ymm15
vpsubsw %ymm15, %ymm10, %ymm14
vmovdqu 0x290(%rsp), %ymm3
vpsubsw %ymm3, %ymm13, %ymm13
vpmaxsw %ymm13, %ymm14, %ymm13
vpsubsw %ymm15, %ymm9, %ymm9
vpsubsw %ymm3, %ymm5, %ymm5
vpmaxsw %ymm5, %ymm9, %ymm14
vpmaxsw %ymm13, %ymm14, %ymm5
vpmaxsw %ymm5, %ymm8, %ymm5
vpcmpeqw %ymm6, %ymm12, %ymm15
vpblendvb %ymm15, 0x1d0(%rsp), %ymm5, %ymm9
cmpq $0x10, %r8
jb 0x55d2e7
vpminsw %ymm0, %ymm9, %ymm0
vpmaxsw %ymm1, %ymm9, %ymm1
movq 0xb8(%rsp), %r9
movq 0x10(%r9), %r9
movq (%r9), %r10
movq 0x8(%r9), %r9
cmpq %rbp, %r8
setae %r14b
orb %r14b, %r11b
vextracti128 $0x1, %ymm9, %xmm5
jne 0x55d319
vpextrw $0x7, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r10,%r8,4)
cmpq %r8, 0x168(%rsp)
jne 0x55d330
vpextrw $0x7, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x1b8(%rsp), %rdi
cmpq %r13, %rdi
setne %r11b
leaq -0x1(%r8), %r14
cmpq %rbp, %r14
setae %r14b
orb %r11b, %r14b
jne 0x55d35d
vpextrw $0x6, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, -0x4(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, %rbp
setne %r14b
orb %r11b, %r14b
jne 0x55d37d
vpextrw $0x6, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x1b0(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d3b4
leaq -0x2(%r8), %r11
cmpq $0x2, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d3b4
vpextrw $0x5, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, -0x8(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x158(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d3d9
vpextrw $0x5, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x1a8(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d410
leaq -0x3(%r8), %r11
cmpq $0x3, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d410
vpextrw $0x4, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, -0xc(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x150(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d435
vpextrw $0x4, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x1a0(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d46c
leaq -0x4(%r8), %r11
cmpq $0x4, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d46c
vpextrw $0x3, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, -0x10(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x148(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d491
vpextrw $0x3, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x198(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d4c8
leaq -0x5(%r8), %r11
cmpq $0x5, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d4c8
vpextrw $0x2, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, -0x14(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x140(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d4ed
vpextrw $0x2, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x190(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d524
leaq -0x6(%r8), %r11
cmpq $0x6, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d524
vpextrw $0x1, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, -0x18(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x138(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d549
vpextrw $0x1, %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x188(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d580
leaq -0x7(%r8), %r11
cmpq $0x7, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d580
vmovd %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, -0x1c(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x130(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d5a5
vmovd %xmm5, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x180(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d5dd
leaq -0x8(%r8), %r11
cmpq $0x8, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d5dd
vpextrw $0x7, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x20(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x128(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d603
vpextrw $0x7, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x178(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d63b
leaq -0x9(%r8), %r11
cmpq $0x9, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d63b
vpextrw $0x6, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x24(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x120(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d661
vpextrw $0x6, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
movq 0x170(%rsp), %rdi
cmpq %r13, %rdi
jne 0x55d699
leaq -0xa(%r8), %r11
cmpq $0xa, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d699
vpextrw $0x5, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x28(%r10,%r8,4)
cmpq %rsi, %rdi
setae %r11b
cmpq %r8, 0x118(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d6bf
vpextrw $0x5, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rdi,4)
cmpq %r13, %r12
jne 0x55d6ef
leaq -0xb(%r8), %r11
cmpq $0xb, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d6ef
vpextrw $0x4, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x2c(%r10,%r8,4)
cmpq %rsi, %r12
setae %r11b
cmpq %r8, 0x110(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d715
vpextrw $0x4, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%r12,4)
cmpq %r13, %rax
jne 0x55d745
leaq -0xc(%r8), %r11
cmpq $0xc, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d745
vpextrw $0x3, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x30(%r10,%r8,4)
cmpq %rsi, %rax
setae %r11b
cmpq %r8, 0x108(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d76b
vpextrw $0x3, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rax,4)
cmpq %r13, %rbx
jne 0x55d79b
leaq -0xd(%r8), %r11
cmpq $0xd, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d79b
vpextrw $0x2, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x34(%r10,%r8,4)
cmpq %rsi, %rbx
setae %r11b
cmpq %r8, 0x100(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d7c1
vpextrw $0x2, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rbx,4)
cmpq %r13, %rcx
jne 0x55d7f1
leaq -0xe(%r8), %r11
cmpq $0xe, %r8
setae %r14b
cmpq %rbp, %r11
setl %r11b
andb %r14b, %r11b
cmpb $0x1, %r11b
jne 0x55d7f1
vpextrw $0x1, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x38(%r10,%r8,4)
cmpq %rsi, %rcx
setae %r11b
cmpq %r8, 0xf8(%rsp)
setne %r14b
orb %r11b, %r14b
jne 0x55d817
vpextrw $0x1, %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, (%r9,%rcx,4)
cmpq %r13, %rdx
setne %r11b
cmpq $0xf, %r8
setb %r14b
orb %r11b, %r14b
jne 0x55d839
vmovd %xmm9, %r11d
movswl %r11w, %r11d
movl %r11d, -0x3c(%r10,%r8,4)
cmpq %rsi, %rdx
setae %r11b
cmpq %r8, 0xf0(%rsp)
setne %r14b
vmovd %xmm9, %r10d
orb %r11b, %r14b
jne 0x55d85e
movswl %r10w, %r11d
movl %r11d, (%r9,%rdx,4)
vmovdqu 0xc0(%rsp), %ymm5
vpblendvb %ymm15, %ymm5, %ymm13, %ymm13
vpblendvb %ymm15, %ymm5, %ymm14, %ymm5
movq 0x70(%rsp), %r9
movw %r10w, (%r9,%r8,2)
movq %r9, %r10
movq 0xa8(%rsp), %rdi
vpextrw $0x0, %xmm13, (%rdi,%r8,2)
vpcmpeqw 0x2d0(%rsp), %ymm12, %ymm8
vpand %ymm11, %ymm8, %ymm8
vpblendvb %ymm8, %ymm9, %ymm2, %ymm2
vpaddsw %ymm7, %ymm12, %ymm12
incq %r8
cmpq %r8, 0x160(%rsp)
jne 0x55d110
vpaddsw 0x210(%rsp), %ymm4, %ymm4
vmovdqu 0x1d0(%rsp), %ymm3
vpsubsw 0x250(%rsp), %ymm3, %ymm3
vmovdqu %ymm3, 0x1d0(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq %rsi, %rax
movq 0x330(%rsp), %r9
jb 0x55cc60
movl 0xb4(%rsp), %r13d
jmp 0x55d91a
vmovdqu 0xc0(%rsp), %ymm1
vmovdqa %ymm1, %ymm2
vmovdqu 0x1f0(%rsp), %ymm0
movl $0x10, %eax
movq 0xb8(%rsp), %rbx
vextracti128 $0x1, %ymm2, %xmm3
vpextrw $0x7, %xmm3, %ecx
cmpw %r13w, %cx
cmovlel %r13d, %ecx
movl %ecx, %r13d
vperm2i128 $0x28, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0xe, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm3[30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
decl %eax
jne 0x55d927
vmovdqu 0xc0(%rsp), %ymm2
vpcmpgtw %ymm0, %ymm2, %ymm0
vpcmpgtw 0x1f0(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
je 0x55d986
orb $0x40, 0xc(%rbx)
xorl %r13d, %r13d
movl $0x0, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movswl %r13w, %eax
movl %eax, (%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rbx)
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq 0x70(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x330(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x55d9ff
movq 0x78(%rsp), %rdi
callq 0x20a60d
jmp 0x55d9ff
callq 0x1f1031
jmp 0x55d9fd
callq 0x1f100b
jmp 0x55d9fd
callq 0x1f0fe5
jmp 0x55d9fd
callq 0x1f0fbf
jmp 0x55d9fd
callq 0x1f0f99
jmp 0x55d9fd
callq 0x1f0f73
jmp 0x55d9fd
callq 0x1f0f4d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq