// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_diag_avx2_256_16.c
// Function: parasail_sw_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 vNegInf0;
    __m256i vOpen;
    __m256i vGap;
    __m256i vZero;
    __m256i vOne;
    __m256i vN;
    __m256i vNegOne;
    __m256i vI;
    __m256i vJreset;
    __m256i vMaxH;
    __m256i vEndI;
    __m256i vEndJ;
    __m256i vILimit;
    __m256i vJLimit;

    /* 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 = 0;
    end_ref = 0;
    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);
    vNegInf0 = _mm256_srli_si256_rpl(vNegInf, 2); /* shift in a 0 */
    vOpen = _mm256_set1_epi16(open);
    vGap  = _mm256_set1_epi16(gap);
    vZero = _mm256_set1_epi16(0);
    vOne = _mm256_set1_epi16(1);
    vN = _mm256_set1_epi16(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);
    vMaxH = vNegInf;
    vEndI = vNegInf;
    vEndJ = vNegInf;
    vILimit = _mm256_set1_epi16(s1Len);
    vJLimit = _mm256_set1_epi16(s2Len);

    /* 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_SW | 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] = 0;
        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;
    }

    /* iterate over query sequence */
    for (i=0; i<s1Len; i+=N) {
        __m256i vNH = vNegInf0;
        __m256i vWH = vNegInf0;
        __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))];
        __m256i vIltLimit = _mm256_cmplt_epi16_rpl(vI, vILimit);
        /* 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);
            vWH = _mm256_max_epi16(vWH, vZero);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m256i cond = _mm256_cmpeq_epi16(vJ,vNegOne);
                vWH = _mm256_andnot_si256(cond, vWH);
                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
             * max values within the i,j bounds */
            {
                __m256i cond_valid_J = _mm256_and_si256(
                        _mm256_cmpgt_epi16(vJ, vNegOne),
                        _mm256_cmplt_epi16_rpl(vJ, vJLimit));
                __m256i cond_valid_IJ = _mm256_and_si256(cond_valid_J, vIltLimit);
                __m256i cond_eq = _mm256_cmpeq_epi16(vWH, vMaxH);
                __m256i cond_max = _mm256_cmpgt_epi16(vWH, vMaxH);
                __m256i cond_all = _mm256_and_si256(cond_max, cond_valid_IJ);
                __m256i cond_Jlt = _mm256_cmplt_epi16_rpl(vJ, vEndJ);
                vMaxH = _mm256_blendv_epi8(vMaxH, vWH, cond_all);
                vEndI = _mm256_blendv_epi8(vEndI, vI, cond_all);
                vEndJ = _mm256_blendv_epi8(vEndJ, vJ, cond_all);
                cond_all = _mm256_and_si256(cond_Jlt, cond_eq);
                cond_all = _mm256_and_si256(cond_all, cond_valid_IJ);
                vEndI = _mm256_blendv_epi8(vEndI, vI, cond_all);
                vEndJ = _mm256_blendv_epi8(vEndJ, vJ, cond_all);
            }
            vJ = _mm256_adds_epi16(vJ, vOne);
        }
        vI = _mm256_adds_epi16(vI, vN);
    }

    /* alignment ending position */
    {
        int16_t *t = (int16_t*)&vMaxH;
        int16_t *i = (int16_t*)&vEndI;
        int16_t *j = (int16_t*)&vEndJ;
        int32_t k;
        for (k=0; k<N; ++k, ++t, ++i, ++j) {
            if (*t > score) {
                score = *t;
                end_query = *i;
                end_ref = *j;
            }
            else if (*t == score) {
                if (*j < end_ref) {
                    end_query = *i;
                    end_ref = *j;
                }
                else if (*j == end_ref && *i < end_query) {
                    end_query = *i;
                    end_ref = *j;
                }
            }
        }
    }

    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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x3a0, %rsp            # imm = 0x3A0
testq %rdx, %rdx
je 0x560439
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x560440
testl %r8d, %r8d
js 0x560447
testl %r9d, %r9d
js 0x56044e
movq %rdx, %r12
movq 0x10(%rbp), %rdx
testq %rdx, %rdx
je 0x560455
cmpl $0x0, 0x30(%rdx)
je 0x55f266
movl 0x34(%rdx), %r15d
jmp 0x55f27a
testq %rdi, %rdi
je 0x56045c
movl %esi, %r15d
testl %esi, %esi
jle 0x560463
movq %rdi, 0x10(%rsp)
movl %r9d, 0x20(%rsp)
movl %r8d, %eax
negl %eax
movl 0x20(%rdx), %ecx
movl %ecx, %esi
negl %esi
cmpl %eax, %ecx
movl %r8d, 0x18(%rsp)
cmovgl %r8d, %esi
addl $0xffff8001, %esi       # imm = 0xFFFF8001
movw $0x7ffe, %bx            # imm = 0x7FFE
subw 0x1c(%rdx), %bx
movl %esi, 0x6c(%rsp)
vmovd %esi, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x280(%rsp)
vmovdqa %ymm0, 0x200(%rsp)
vmovdqa %ymm0, 0xa0(%rsp)
vmovdqa %ymm0, 0x1e0(%rsp)
movl %r15d, %edi
movl %r14d, %esi
vzeroupper
callq 0x20ac53
testq %rax, %rax
je 0x560468
movq %rax, %r13
movq %r12, 0x28(%rsp)
orl $0x10241004, 0xc(%rax)  # imm = 0x10241004
movq %r14, 0x58(%rsp)
leal 0x1e(%r14), %r12d
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a625
movq %rax, %r14
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a625
movl $0x20, %edi
movq %r12, %rsi
movq %rax, %r12
callq 0x20a625
testq %r14, %r14
sete %dl
testq %r12, %r12
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x560468
movq %rax, 0x70(%rsp)
movq 0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x55f36d
movq %r15, 0x8(%rsp)
xorl %ecx, %ecx
jmp 0x55f3f7
leal 0xf(%r15), %eax
movl %eax, 0x30(%rsp)
movslq %eax, %rsi
movl $0x20, %edi
callq 0x20a625
testq %rax, %rax
je 0x560468
movq %rax, %r8
movq %r15, 0x8(%rsp)
testl %r15d, %r15d
movq 0x10(%rsp), %rdi
jle 0x55f3c0
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rsp), %ecx
xorl %edx, %edx
movzbl (%rdi,%rdx), %esi
movzwl (%rax,%rsi,4), %esi
movw %si, (%r8,%rdx,2)
incq %rdx
cmpq %rdx, %rcx
jne 0x55f3ab
movq 0x8(%rsp), %rdx
movslq %edx, %rax
leal 0x1(%rdx), %ecx
movl 0x30(%rsp), %esi
cmpl %ecx, %esi
cmovgl %esi, %ecx
leaq (%r8,%rax,2), %rdi
movl %edx, %eax
notl %eax
addl %ecx, %eax
leaq 0x2(,%rax,2), %rdx
xorl %esi, %esi
movq %r8, %r15
callq 0x19e090
movq %r15, %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x90(%rsp)
movq %r12, 0x88(%rsp)
movq 0x58(%rsp), %rsi
leal 0xf(%rsi), %r15d
vmovd %ebx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x220(%rsp)
vmovdqa 0xa0(%rsp), %ymm1
vmovdqa %xmm1, %xmm0
vpslldq $0xe, %ymm0, %ymm0      # ymm0 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,ymm0[0,1],zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,ymm0[16,17]
vpblendw $0x80, %ymm0, %ymm1, %ymm0 # ymm0 = ymm1[0,1,2,3,4,5,6],ymm0[7],ymm1[8,9,10,11,12,13,14],ymm0[15]
vmovdqa %ymm0, 0x2e0(%rsp)
vmovd 0x18(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x360(%rsp)
vmovd 0x20(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x340(%rsp)
vmovd 0x8(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x2c0(%rsp)
vmovd %esi, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x320(%rsp)
movq 0x10(%rax), %rax
movl %esi, %ebx
xorl %ecx, %ecx
movq 0x28(%rsp), %rdi
movzbl (%rdi,%rcx), %edx
movzwl (%rax,%rdx,4), %edx
movw %dx, 0x1e(%r14,%rcx,2)
incq %rcx
cmpq %rcx, %rbx
jne 0x55f49e
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, 0xe(%r14)
vmovdqu %xmm0, (%r14)
leal 0x1(%rsi), %eax
cmpl %eax, %r15d
cmovgl %r15d, %eax
leaq (%r14,%rbx,2), %rdi
addq $0x1e, %rdi
movl %esi, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x2(,%rcx,2), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movl 0x6c(%rsp), %r8d
movq 0x88(%rsp), %rcx
movq 0x70(%rsp), %rdx
movw $0x0, 0x1e(%rcx,%r12,2)
movw %r8w, 0x1e(%rdx,%r12,2)
incq %r12
cmpq %r12, %rbx
jne 0x55f502
xorl %eax, %eax
movq %rcx, %r12
movw %r8w, (%r12,%rax,2)
movw %r8w, (%rdx,%rax,2)
incq %rax
cmpq $0xf, %rax
jne 0x55f51d
leaq 0xf(%rbx), %rax
movq 0x58(%rsp), %rcx
movq 0x10(%rbp), %r10
movw %r8w, (%r12,%rax,2)
movw %r8w, (%rdx,%rax,2)
incq %rax
incl %ecx
cmpl %ecx, %r15d
jg 0x55f53d
movq 0x8(%rsp), %rdx
testl %edx, %edx
jle 0x560348
movq %r13, 0x98(%rsp)
movq 0x8(%r10), %rax
movq %rax, 0xd0(%rsp)
leal -0x1(%rdx), %ecx
movq 0x58(%rsp), %rax
decl %eax
movq %rax, 0x58(%rsp)
cmpl $0x2, %r15d
movl $0x1, %eax
cmovgel %r15d, %eax
movq %rax, 0x148(%rsp)
movl %edx, %esi
vmovdqa 0x280(%rsp), %ymm3
vmovdqa 0x1e0(%rsp), %ymm2
leaq 0x1(%rbx), %rax
movq %rax, 0x140(%rsp)
leaq 0x2(%rbx), %rax
movq %rax, 0x138(%rsp)
leaq 0x3(%rbx), %rax
movq %rax, 0x130(%rsp)
leaq 0x4(%rbx), %rax
movq %rax, 0x128(%rsp)
leaq 0x5(%rbx), %rax
movq %rax, 0x120(%rsp)
leaq 0x6(%rbx), %rax
movq %rax, 0x118(%rsp)
leaq 0x7(%rbx), %rax
movq %rax, 0x110(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, 0x108(%rsp)
leaq 0x9(%rbx), %rax
movq %rax, 0x100(%rsp)
vmovaps 0xce842(%rip), %ymm0    # 0x62de60
vmovaps %ymm0, 0x1c0(%rsp)
vpbroadcastw 0xd006a(%rip), %ymm0 # 0x62f69a
vmovdqa %ymm0, 0x300(%rsp)
vpbroadcastw 0xd005a(%rip), %ymm0 # 0x62f69c
vmovdqa %ymm0, 0x2a0(%rsp)
vmovdqa 0x220(%rsp), %ymm0
vmovdqa %ymm0, 0x240(%rsp)
vmovdqa 0xa0(%rsp), %ymm5
vmovdqa %ymm5, 0x260(%rsp)
leaq 0xa(%rbx), %rax
movq %rax, 0xf8(%rsp)
leaq 0xb(%rbx), %rax
movq %rax, 0xf0(%rsp)
leaq 0xc(%rbx), %rax
movq %rax, 0xe8(%rsp)
leaq 0xd(%rbx), %rax
movq %rax, 0xe0(%rsp)
leaq 0xe(%rbx), %rax
movq %rax, 0xd8(%rsp)
xorl %r15d, %r15d
cmpl $0x0, 0x30(%r10)
je 0x55f7b7
movq %r15, %rax
orq $0x1, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
movq %rax, 0x20(%rsp)
movq %r15, %rax
orq $0x2, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
movq %rax, 0x18(%rsp)
movq %r15, %r11
orq $0x3, %r11
cmpq %rsi, %r11
cmovael %ecx, %r11d
movq %r15, %rax
orq $0x4, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
movq %rax, 0x10(%rsp)
movq %r15, %rdx
orq $0x5, %rdx
cmpq %rsi, %rdx
cmovael %ecx, %edx
movq %r15, %rax
orq $0x6, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
movq %rax, 0x8(%rsp)
movq %r15, %r12
orq $0x7, %r12
cmpq %rsi, %r12
cmovael %ecx, %r12d
movq %r15, %rax
orq $0x8, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
movq %rax, 0x30(%rsp)
movq %r15, %rax
orq $0x9, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
movq %r15, %rdi
orq $0xa, %rdi
cmpq %rsi, %rdi
cmovael %ecx, %edi
movq %rdi, 0x50(%rsp)
movq %r15, %rdi
orq $0xb, %rdi
cmpq %rsi, %rdi
cmovael %ecx, %edi
movq %r15, %r8
orq $0xc, %r8
cmpq %rsi, %r8
cmovael %ecx, %r8d
movq %r8, 0x48(%rsp)
movq %r15, %r9
orq $0xd, %r9
cmpq %rsi, %r9
cmovael %ecx, %r9d
movq %r15, %r8
orq $0xe, %r8
cmpq %rsi, %r8
cmovael %ecx, %r8d
movq %r8, 0x40(%rsp)
movq %r15, %r8
orq $0xf, %r8
cmpq %rsi, %r8
cmovael %ecx, %r8d
movq %r8, 0x38(%rsp)
movl %r15d, %r8d
jmp 0x55f854
movq 0x90(%rsp), %r8
movswl (%r8,%r15,2), %eax
movl %eax, 0x28(%rsp)
movswl 0x2(%r8,%r15,2), %eax
movq %rax, 0x20(%rsp)
movswl 0x4(%r8,%r15,2), %eax
movq %rax, 0x18(%rsp)
movswl 0x6(%r8,%r15,2), %r11d
movswl 0x8(%r8,%r15,2), %eax
movq %rax, 0x10(%rsp)
movswl 0xa(%r8,%r15,2), %edx
movswl 0xc(%r8,%r15,2), %eax
movq %rax, 0x8(%rsp)
movswl 0xe(%r8,%r15,2), %r12d
movswl 0x10(%r8,%r15,2), %eax
movq %rax, 0x30(%rsp)
movswl 0x12(%r8,%r15,2), %eax
movswl 0x14(%r8,%r15,2), %edi
movq %rdi, 0x50(%rsp)
movswl 0x16(%r8,%r15,2), %edi
movswl 0x18(%r8,%r15,2), %r9d
movq %r9, 0x48(%rsp)
movswl 0x1a(%r8,%r15,2), %r9d
movswl 0x1c(%r8,%r15,2), %r13d
movq %r13, 0x40(%rsp)
movswl 0x1e(%r8,%r15,2), %r8d
movq %r8, 0x38(%rsp)
movl 0x28(%rsp), %r8d
movl 0x18(%r10), %r10d
imull %r10d, %r9d
imull %r10d, %edi
imull %r10d, %eax
imull %r10d, %r12d
movq %r12, 0x80(%rsp)
imull %r10d, %edx
movq %rdx, 0x78(%rsp)
imull %r10d, %r11d
movq %r11, 0x60(%rsp)
movq 0x20(%rsp), %r11
imull %r10d, %r11d
movq %r11, 0x20(%rsp)
imull %r10d, %r8d
movl %r8d, 0x28(%rsp)
movq 0x18(%rsp), %r11
imull %r10d, %r11d
movq %r11, 0x18(%rsp)
movq 0x10(%rsp), %r11
imull %r10d, %r11d
movq %r11, 0x10(%rsp)
movq 0x8(%rsp), %rdx
imull %r10d, %edx
movq %rdx, 0x8(%rsp)
movq 0x30(%rsp), %r13
imull %r10d, %r13d
movq 0x50(%rsp), %r12
imull %r10d, %r12d
movq 0x48(%rsp), %r11
imull %r10d, %r11d
movq 0x40(%rsp), %r8
imull %r10d, %r8d
movq 0x38(%rsp), %rdx
imull %r10d, %edx
movslq %r9d, %r9
movq 0xd0(%rsp), %r10
leaq (%r10,%r9,4), %r9
movq %r9, 0x1b8(%rsp)
movslq %edi, %rdi
leaq (%r10,%rdi,4), %rdi
movq %rdi, 0x1b0(%rsp)
cltq
leaq (%r10,%rax,4), %rax
movq %rax, 0x1a8(%rsp)
movslq 0x80(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x80(%rsp)
movslq 0x78(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x78(%rsp)
movslq 0x60(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x1a0(%rsp)
movslq 0x20(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x198(%rsp)
movslq 0x28(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x190(%rsp)
movslq 0x18(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x188(%rsp)
movslq 0x10(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x180(%rsp)
movslq 0x8(%rsp), %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x178(%rsp)
movslq %r13d, %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x170(%rsp)
movslq %r12d, %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x168(%rsp)
movslq %r11d, %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x160(%rsp)
movslq %r8d, %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x158(%rsp)
movslq %edx, %rax
leaq (%r10,%rax,4), %rax
movq %rax, 0x150(%rsp)
movq %r15, %rax
orq $0x1, %rax
movq %rax, 0x20(%rsp)
movq %r15, %rax
orq $0x2, %rax
movq %rax, 0x18(%rsp)
movq %r15, %rax
orq $0x3, %rax
movq %rax, 0x10(%rsp)
movq %r15, %rax
orq $0x4, %rax
movq %rax, 0x8(%rsp)
movq %r15, %rax
orq $0x5, %rax
movq %rax, 0x28(%rsp)
movq %r15, %rax
orq $0x6, %rax
movq %rax, 0x30(%rsp)
movq %r15, %rax
orq $0x7, %rax
movq %rax, 0x50(%rsp)
movq %r15, %rax
orq $0x8, %rax
movq %rax, 0x48(%rsp)
movq %r15, %rax
orq $0x9, %rax
movq %rax, 0x40(%rsp)
movq %r15, %rax
orq $0xa, %rax
movq %rax, 0x38(%rsp)
movq %r15, %rax
orq $0xb, %rax
movq %rax, 0x60(%rsp)
movq %r15, %r8
orq $0xc, %r8
movq %r15, %r9
orq $0xd, %r9
movq %r15, %r10
orq $0xe, %r10
movq %r15, %r11
orq $0xf, %r11
vmovdqa 0x2c0(%rsp), %ymm0
vpcmpgtw 0x1c0(%rsp), %ymm0, %ymm11
vpmovsxbw 0xce76a(%rip), %ymm12 # 0x62e21c
vmovdqa 0xa0(%rsp), %ymm7
vmovdqa %ymm7, %ymm9
vmovdqa 0x2e0(%rsp), %ymm14
vmovdqa %ymm14, %ymm13
xorl %eax, %eax
movq 0x88(%rsp), %r12
movq 0x70(%rsp), %rdi
movswq 0x10(%r14,%rax,2), %rdx
movq 0x80(%rsp), %r13
vmovd (%r13,%rdx,4), %xmm8
movswq 0x12(%r14,%rax,2), %rdx
movq 0x178(%rsp), %r13
vpinsrw $0x1, (%r13,%rdx,4), %xmm8, %xmm8
movswq 0x14(%r14,%rax,2), %rdx
movq 0x78(%rsp), %r13
vpinsrw $0x2, (%r13,%rdx,4), %xmm8, %xmm8
movswq 0x16(%r14,%rax,2), %rdx
movq 0x180(%rsp), %r13
vpinsrw $0x3, (%r13,%rdx,4), %xmm8, %xmm8
movswq 0x18(%r14,%rax,2), %rdx
movq 0x1a0(%rsp), %r13
vpinsrw $0x4, (%r13,%rdx,4), %xmm8, %xmm8
movswq 0x1a(%r14,%rax,2), %rdx
movq 0x188(%rsp), %r13
vpinsrw $0x5, (%r13,%rdx,4), %xmm8, %xmm8
movswq 0x1c(%r14,%rax,2), %rdx
movq 0x198(%rsp), %r13
vpinsrw $0x6, (%r13,%rdx,4), %xmm8, %xmm8
movswq 0x1e(%r14,%rax,2), %rdx
movq 0x190(%rsp), %r13
vpinsrw $0x7, (%r13,%rdx,4), %xmm8, %xmm8
movswq (%r14,%rax,2), %rdx
movq 0x150(%rsp), %r13
vmovd (%r13,%rdx,4), %xmm10
movswq 0x2(%r14,%rax,2), %rdx
movq 0x158(%rsp), %r13
vpinsrw $0x1, (%r13,%rdx,4), %xmm10, %xmm10
movswq 0x4(%r14,%rax,2), %rdx
movq 0x1b8(%rsp), %r13
vpinsrw $0x2, (%r13,%rdx,4), %xmm10, %xmm10
movswq 0x6(%r14,%rax,2), %rdx
movq 0x160(%rsp), %r13
vpinsrw $0x3, (%r13,%rdx,4), %xmm10, %xmm10
movswq 0x8(%r14,%rax,2), %rdx
movq 0x1b0(%rsp), %r13
vpinsrw $0x4, (%r13,%rdx,4), %xmm10, %xmm10
movswq 0xa(%r14,%rax,2), %rdx
movq 0x168(%rsp), %r13
vpinsrw $0x5, (%r13,%rdx,4), %xmm10, %xmm10
movswq 0xc(%r14,%rax,2), %rdx
movq 0x1a8(%rsp), %r13
vpinsrw $0x6, (%r13,%rdx,4), %xmm10, %xmm10
movswq 0xe(%r14,%rax,2), %rdx
movq 0x170(%rsp), %r13
vpinsrw $0x7, (%r13,%rdx,4), %xmm10, %xmm10
vinserti128 $0x1, %xmm8, %ymm10, %ymm8
vextracti128 $0x1, %ymm13, %xmm10
vpaddsw %ymm8, %ymm14, %ymm8
vpbroadcastw 0x1e(%r12,%rax,2), %ymm14
vpalignr $0x2, %ymm13, %ymm10, %ymm10 # ymm10 = ymm13[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm10[0,1],ymm13[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm10[16,17]
vpblendw $0x80, %ymm14, %ymm10, %ymm14 # ymm14 = ymm10[0,1,2,3,4,5,6],ymm14[7],ymm10[8,9,10,11,12,13,14],ymm14[15]
vpblendd $0xf0, %ymm14, %ymm10, %ymm14 # ymm14 = ymm10[0,1,2,3],ymm14[4,5,6,7]
vextracti128 $0x1, %ymm9, %xmm10
vpalignr $0x2, %ymm9, %ymm10, %ymm9 # ymm9 = ymm9[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm10[0,1],ymm9[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm10[16,17]
vpbroadcastw 0x1e(%rdi,%rax,2), %ymm10
movq %r15, %r13
cmpq %rcx, %r15
setne %r15b
vpblendw $0x80, %ymm10, %ymm9, %ymm10 # ymm10 = ymm9[0,1,2,3,4,5,6],ymm10[7],ymm9[8,9,10,11,12,13,14],ymm10[15]
vpblendd $0xf0, %ymm10, %ymm9, %ymm9 # ymm9 = ymm9[0,1,2,3],ymm10[4,5,6,7]
vmovdqa 0x360(%rsp), %ymm0
vpsubsw %ymm0, %ymm14, %ymm10
vmovdqa 0x340(%rsp), %ymm1
vpsubsw %ymm1, %ymm9, %ymm9
vpmaxsw %ymm9, %ymm10, %ymm9
vpsubsw %ymm0, %ymm13, %ymm10
vpsubsw %ymm1, %ymm7, %ymm7
vpmaxsw %ymm7, %ymm10, %ymm15
vpmaxsw %ymm9, %ymm15, %ymm7
vpmaxsw 0xcdf5f(%rip), %ymm7, %ymm7 # 0x62dc20
vpmaxsw %ymm7, %ymm8, %ymm8
vpcmpeqw 0xce593(%rip), %ymm12, %ymm7 # 0x62e260
vpandn %ymm8, %ymm7, %ymm13
cmpq $0x10, %rax
jb 0x55fd04
vmovdqa 0x240(%rsp), %ymm0
vpminsw %ymm0, %ymm13, %ymm0
vmovdqa %ymm0, 0x240(%rsp)
vmovdqa 0x260(%rsp), %ymm0
vpmaxsw %ymm0, %ymm13, %ymm0
vmovdqa %ymm0, 0x260(%rsp)
movq 0x98(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
cmpq %rbx, %rax
setae %r12b
orb %r12b, %r15b
vextracti128 $0x1, %ymm13, %xmm10
jne 0x55fd33
vpextrw $0x7, %xmm10, %r15d
movl %r15d, (%rdi,%rax,4)
cmpq %rax, 0x58(%rsp)
jne 0x55fd44
vpextrw $0x7, %xmm10, %r15d
movl %r15d, (%rdx,%r13,4)
cmpq %rcx, 0x20(%rsp)
setne %r15b
leaq -0x1(%rax), %r12
cmpq %rbx, %r12
setae %r12b
orb %r15b, %r12b
jne 0x55fd68
vpextrw $0x6, %xmm10, %r15d
movl %r15d, -0x4(%rdi,%rax,4)
cmpq %rsi, 0x20(%rsp)
setae %r15b
cmpq %rax, %rbx
setne %r12b
orb %r15b, %r12b
jne 0x55fd8c
vpextrw $0x6, %xmm10, %r15d
movq 0x20(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x18(%rsp)
jne 0x55fdba
leaq -0x2(%rax), %r15
cmpq $0x2, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x55fdba
vpextrw $0x5, %xmm10, %r15d
movl %r15d, -0x8(%rdi,%rax,4)
cmpq %rsi, 0x18(%rsp)
setae %r15b
cmpq %rax, 0x140(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x55fde3
vpextrw $0x5, %xmm10, %r15d
movq 0x18(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x10(%rsp)
jne 0x55fe11
leaq -0x3(%rax), %r15
cmpq $0x3, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x55fe11
vpextrw $0x4, %xmm10, %r15d
movl %r15d, -0xc(%rdi,%rax,4)
cmpq %rsi, 0x10(%rsp)
setae %r15b
cmpq %rax, 0x138(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x55fe3a
vpextrw $0x4, %xmm10, %r15d
movq 0x10(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x8(%rsp)
jne 0x55fe68
leaq -0x4(%rax), %r15
cmpq $0x4, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x55fe68
vpextrw $0x3, %xmm10, %r15d
movl %r15d, -0x10(%rdi,%rax,4)
cmpq %rsi, 0x8(%rsp)
setae %r15b
cmpq %rax, 0x130(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x55fe91
vpextrw $0x3, %xmm10, %r15d
movq 0x8(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x28(%rsp)
jne 0x55febf
leaq -0x5(%rax), %r15
cmpq $0x5, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x55febf
vpextrw $0x2, %xmm10, %r15d
movl %r15d, -0x14(%rdi,%rax,4)
cmpq %rsi, 0x28(%rsp)
setae %r15b
cmpq %rax, 0x128(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x55fee8
vpextrw $0x2, %xmm10, %r15d
movq 0x28(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x30(%rsp)
jne 0x55ff16
leaq -0x6(%rax), %r15
cmpq $0x6, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x55ff16
vpextrw $0x1, %xmm10, %r15d
movl %r15d, -0x18(%rdi,%rax,4)
cmpq %rsi, 0x30(%rsp)
setae %r15b
cmpq %rax, 0x120(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x55ff3f
vpextrw $0x1, %xmm10, %r15d
movq 0x30(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x50(%rsp)
jne 0x55ff6d
leaq -0x7(%rax), %r15
cmpq $0x7, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x55ff6d
vpextrw $0x0, %xmm10, %r15d
movl %r15d, -0x1c(%rdi,%rax,4)
cmpq %rsi, 0x50(%rsp)
setae %r15b
cmpq %rax, 0x118(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x55ff96
vpextrw $0x0, %xmm10, %r15d
movq 0x50(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x48(%rsp)
jne 0x55ffc4
leaq -0x8(%rax), %r15
cmpq $0x8, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x55ffc4
vpextrw $0x7, %xmm13, %r15d
movl %r15d, -0x20(%rdi,%rax,4)
cmpq %rsi, 0x48(%rsp)
setae %r15b
cmpq %rax, 0x110(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x55ffed
vpextrw $0x7, %xmm13, %r15d
movq 0x48(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x40(%rsp)
jne 0x56001b
leaq -0x9(%rax), %r15
cmpq $0x9, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x56001b
vpextrw $0x6, %xmm13, %r15d
movl %r15d, -0x24(%rdi,%rax,4)
cmpq %rsi, 0x40(%rsp)
setae %r15b
cmpq %rax, 0x108(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x560044
vpextrw $0x6, %xmm13, %r15d
movq 0x40(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x38(%rsp)
jne 0x560072
leaq -0xa(%rax), %r15
cmpq $0xa, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x560072
vpextrw $0x5, %xmm13, %r15d
movl %r15d, -0x28(%rdi,%rax,4)
cmpq %rsi, 0x38(%rsp)
setae %r15b
cmpq %rax, 0x100(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x56009b
vpextrw $0x5, %xmm13, %r15d
movq 0x38(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, 0x60(%rsp)
jne 0x5600c9
leaq -0xb(%rax), %r15
cmpq $0xb, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x5600c9
vpextrw $0x4, %xmm13, %r15d
movl %r15d, -0x2c(%rdi,%rax,4)
cmpq %rsi, 0x60(%rsp)
setae %r15b
cmpq %rax, 0xf8(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x5600f2
vpextrw $0x4, %xmm13, %r15d
movq 0x60(%rsp), %r12
movl %r15d, (%rdx,%r12,4)
cmpq %rcx, %r8
jne 0x56011e
leaq -0xc(%rax), %r15
cmpq $0xc, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x56011e
vpextrw $0x3, %xmm13, %r15d
movl %r15d, -0x30(%rdi,%rax,4)
cmpq %rsi, %r8
setae %r15b
cmpq %rax, 0xf0(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x560140
vpextrw $0x3, %xmm13, %r15d
movl %r15d, (%rdx,%r8,4)
cmpq %rcx, %r9
jne 0x56016c
leaq -0xd(%rax), %r15
cmpq $0xd, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x56016c
vpextrw $0x2, %xmm13, %r15d
movl %r15d, -0x34(%rdi,%rax,4)
cmpq %rsi, %r9
setae %r15b
cmpq %rax, 0xe8(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x56018e
vpextrw $0x2, %xmm13, %r15d
movl %r15d, (%rdx,%r9,4)
cmpq %rcx, %r10
jne 0x5601ba
leaq -0xe(%rax), %r15
cmpq $0xe, %rax
setae %r12b
cmpq %rbx, %r15
setl %r15b
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x5601ba
vpextrw $0x1, %xmm13, %r15d
movl %r15d, -0x38(%rdi,%rax,4)
cmpq %rsi, %r10
setae %r15b
cmpq %rax, 0xe0(%rsp)
setne %r12b
orb %r15b, %r12b
jne 0x5601dc
vpextrw $0x1, %xmm13, %r15d
movl %r15d, (%rdx,%r10,4)
cmpq %rcx, %r11
setne %r15b
cmpq $0xf, %rax
setb %r12b
orb %r15b, %r12b
jne 0x5601fb
vpextrw $0x0, %xmm13, %r15d
movl %r15d, -0x3c(%rdi,%rax,4)
vpblendvb %ymm7, 0xa0(%rsp), %ymm9, %ymm9
cmpq %rsi, %r11
setae %r15b
cmpq %rax, 0xd8(%rsp)
setne %r12b
vmovd %xmm13, %edi
orb %r15b, %r12b
jne 0x56022a
movzwl %di, %r15d
movl %r15d, (%rdx,%r11,4)
vmovdqa 0x320(%rsp), %ymm0
vpcmpgtw %ymm12, %ymm0, %ymm10
vpand %ymm11, %ymm10, %ymm10
vpsraw $0xf, %ymm12, %ymm0
vpandn %ymm10, %ymm0, %ymm0
vextracti128 $0x1, %ymm0, %xmm10
vpacksswb %xmm10, %xmm0, %xmm10
vpcmpeqw %ymm3, %ymm13, %ymm1
vpcmpgtw %ymm3, %ymm13, %ymm6
vpand %ymm0, %ymm6, %ymm4
vpblendvb %ymm4, %ymm8, %ymm3, %ymm3
vextracti128 $0x1, %ymm4, %xmm8
vpacksswb %xmm8, %xmm4, %xmm4
vpcmpgtw %ymm12, %ymm2, %ymm8
vpand %ymm1, %ymm8, %ymm1
vextracti128 $0x1, %ymm1, %xmm8
vpacksswb %xmm8, %xmm1, %xmm8
vpblendvb %xmm8, %xmm10, %xmm4, %xmm4
vpblendvb %ymm7, 0xa0(%rsp), %ymm15, %ymm7
vpmovsxbw %xmm4, %ymm4
vpblendvb %ymm4, 0x1c0(%rsp), %ymm5, %ymm5
vpor %ymm6, %ymm1, %ymm1
vpand %ymm1, %ymm0, %ymm0
vpblendvb %ymm0, %ymm12, %ymm2, %ymm2
movq 0x88(%rsp), %r12
movw %di, (%r12,%rax,2)
movq 0x70(%rsp), %rdi
vpextrw $0x0, %xmm9, (%rdi,%rax,2)
vpaddsw 0x300(%rsp), %ymm12, %ymm12
incq %rax
cmpq %rax, 0x148(%rsp)
movq %r13, %r15
jne 0x55fadc
vmovdqa 0x1c0(%rsp), %ymm0
vpaddsw 0x2a0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x1c0(%rsp)
addq $0x10, %r15
cmpq %rsi, %r15
movq 0x10(%rbp), %r10
jb 0x55f6ae
vmovdqa %ymm3, 0x280(%rsp)
vmovdqa %ymm2, 0x1e0(%rsp)
movq 0x98(%rsp), %r13
movl 0x6c(%rsp), %r8d
vmovdqa 0x260(%rsp), %ymm1
vmovdqa 0x240(%rsp), %ymm2
jmp 0x560367
vmovdqa 0xa0(%rsp), %ymm0
vmovdqa %ymm0, %ymm5
vmovdqa %ymm0, %ymm1
vmovdqa 0x220(%rsp), %ymm2
movq 0x70(%rsp), %rdi
vmovdqa %ymm5, 0x200(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movzwl 0x280(%rsp,%rdx,2), %esi
cmpw %r8w, %si
jle 0x560399
movswl 0x200(%rsp,%rdx,2), %eax
movswl 0x1e0(%rsp,%rdx,2), %ecx
movl %esi, %r8d
jmp 0x5603c2
jne 0x5603c2
movswl 0x1e0(%rsp,%rdx,2), %esi
cmpl %esi, %ecx
jle 0x5603b3
movswl 0x200(%rsp,%rdx,2), %eax
movl %esi, %ecx
jmp 0x5603c2
jne 0x5603c2
movswl 0x200(%rsp,%rdx,2), %esi
cmpl %esi, %eax
cmovgel %esi, %eax
incq %rdx
cmpl $0x10, %edx
jne 0x560376
vmovdqa 0xa0(%rsp), %ymm0
vpcmpgtw %ymm2, %ymm0, %ymm0
vpcmpgtw 0x220(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vpmovmskb %ymm0, %edx
testl %edx, %edx
je 0x5603f8
orb $0x40, 0xc(%r13)
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %eax, %eax
movswl %r8w, %edx
movl %edx, (%r13)
movl %eax, 0x4(%r13)
movl %ecx, 0x8(%r13)
vzeroupper
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x56046b
movq 0x90(%rsp), %rdi
callq 0x20a60d
jmp 0x56046b
callq 0x1f1245
jmp 0x560468
callq 0x1f121f
jmp 0x560468
callq 0x1f11f9
jmp 0x560468
callq 0x1f11d3
jmp 0x560468
callq 0x1f11ad
jmp 0x560468
callq 0x1f1187
jmp 0x560468
callq 0x1f1161
xorl %r13d, %r13d
movq %r13, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)