// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_diag_avx2_256_16.c
// Function: parasail_sw_trace_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_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 s1Len = 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;
    __m256i vTDiag;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTZero;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i vTDelF;

    /* 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);
    vTDiag = _mm256_set1_epi16(PARASAIL_DIAG);
    vTIns = _mm256_set1_epi16(PARASAIL_INS);
    vTDel = _mm256_set1_epi16(PARASAIL_DEL);
    vTZero = _mm256_set1_epi16(PARASAIL_ZERO);
    vTDiagE = _mm256_set1_epi16(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi16(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi16(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi16(PARASAIL_DEL_F);

    /* initialize result */
    result = parasail_result_new_trace(s1Len, s2Len, 32, sizeof(int8_t));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SW | PARASAIL_FLAG_DIAG
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_16 | PARASAIL_FLAG_LANES_16;

    /* 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 vE_opn = vNegInf;
        __m256i vE_ext = vNegInf;
        __m256i vF = vNegInf;
        __m256i vF_opn = vNegInf;
        __m256i vF_ext = 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_opn = _mm256_subs_epi16(vNH, vOpen);
            vF_ext = _mm256_subs_epi16(vF, vGap);
            vF = _mm256_max_epi16(vF_opn, vF_ext);
            vE_opn = _mm256_subs_epi16(vWH, vOpen);
            vE_ext = _mm256_subs_epi16(vE, vGap);
            vE = _mm256_max_epi16(vE_opn, vE_ext);
            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);
            vNWH = _mm256_max_epi16(vNWH, vZero);
            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_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);
            }
            /* trace table */
            {
                __m256i cond_zero = _mm256_cmpeq_epi16(vWH, vZero);
                __m256i case1 = _mm256_cmpeq_epi16(vWH, vNWH);
                __m256i case2 = _mm256_cmpeq_epi16(vWH, vF);
                __m256i vT = _mm256_blendv_epi8(
                        _mm256_blendv_epi8(vTIns, vTDel, case2),
                        _mm256_blendv_epi8(vTDiag, vTZero, cond_zero),
                        case1);
                __m256i condE = _mm256_cmpgt_epi16(vE_opn, vE_ext);
                __m256i condF = _mm256_cmpgt_epi16(vF_opn, vF_ext);
                __m256i vET = _mm256_blendv_epi8(vTInsE, vTDiagE, condE);
                __m256i vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, condF);
                vT = _mm256_or_si256(vT, vET);
                vT = _mm256_or_si256(vT, vFT);
                arr_store_si256(result->trace->trace_table, vT, i, s1Len, j, s2Len);
            }
            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 $0x460, %rsp            # imm = 0x460
testq %rdx, %rdx
je 0x5b89c8
movl %ecx, %r13d
testl %ecx, %ecx
jle 0x5b89cf
testl %r8d, %r8d
js 0x5b89d6
movl %r9d, %r12d
testl %r9d, %r9d
js 0x5b89dd
movq %rdx, %r14
movq 0x10(%rbp), %rdx
testq %rdx, %rdx
je 0x5b89e4
cmpl $0x0, 0x30(%rdx)
je 0x5b7844
movl 0x34(%rdx), %ebx
jmp 0x5b7857
testq %rdi, %rdi
je 0x5b89eb
movl %esi, %ebx
testl %esi, %esi
jle 0x5b89f2
movq %rdi, 0x1e0(%rsp)
movl %r8d, %eax
negl %eax
movl 0x20(%rdx), %ecx
movl %ecx, %esi
negl %esi
cmpl %eax, %ecx
movl %r8d, 0x200(%rsp)
cmovgl %r8d, %esi
addl $0xffff8001, %esi       # imm = 0xFFFF8001
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x140(%rsp)
movl %esi, 0x24(%rsp)
vmovd %esi, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x2e0(%rsp)
vmovdqa %ymm0, 0x240(%rsp)
vmovdqa %ymm0, 0x2c0(%rsp)
vmovdqa %ymm0, 0x220(%rsp)
movl $0x20, %edx
movl $0x1, %ecx
movl %ebx, %edi
movl %r13d, %esi
vzeroupper
callq 0x20adf4
testq %rax, %rax
je 0x5b89f7
movq %rax, %r15
movl %r12d, 0x18(%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x120(%rsp)
orl $0x10281004, 0xc(%rax)  # imm = 0x10281004
leal 0x1e(%r13), %r12d
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a625
movq %rax, %r14
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a625
movq %rax, %rbx
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a625
movq %rax, %rdx
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
jne 0x5b89f7
movq %r15, 0x118(%rsp)
movq 0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
movq %rbx, 0x50(%rsp)
movq %rdx, 0x88(%rsp)
je 0x5b7985
movq $0x0, 0x58(%rsp)
movq 0x120(%rsp), %rbx
movq 0x8(%rsp), %r12
jmp 0x5b7a0b
movq 0x120(%rsp), %rbx
leal 0xf(%rbx), %r15d
movslq %r15d, %rsi
movl $0x20, %edi
callq 0x20a625
testq %rax, %rax
movq 0x8(%rsp), %r12
je 0x5b89f7
movq %rax, %rdi
testl %ebx, %ebx
movq 0x1e0(%rsp), %r8
jle 0x5b79dc
movq 0x10(%rbp), %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 0x5b79c7
movslq %ebx, %rax
leal 0x1(%rbx), %ecx
cmpl %ecx, %r15d
cmovgl %r15d, %ecx
movq %rdi, 0x58(%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 0x10(%rbp), %rax
leal 0xf(%r13), %r15d
vmovd 0x140(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x260(%rsp)
vmovdqa 0x2c0(%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, 0x320(%rsp)
vmovd 0x200(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x400(%rsp)
vmovd 0x18(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x3e0(%rsp)
vmovd %ebx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x300(%rsp)
vmovd %r13d, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x3c0(%rsp)
movq 0x10(%rax), %rax
movl %r13d, %ebx
xorl %ecx, %ecx
movzbl (%r12,%rcx), %edx
movzwl (%rax,%rdx,4), %edx
movw %dx, 0x1e(%r14,%rcx,2)
incq %rcx
cmpq %rcx, %rbx
jne 0x5b7aa0
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, 0xe(%r14)
vmovdqu %xmm0, (%r14)
leal 0x1(%r13), %eax
cmpl %eax, %r15d
cmovgl %r15d, %eax
leaq (%r14,%rbx,2), %rdi
addq $0x1e, %rdi
movl %r13d, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x2(,%rcx,2), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movl 0x24(%rsp), %r9d
movq 0x50(%rsp), %rcx
movq 0x88(%rsp), %rdi
movw $0x0, 0x1e(%rcx,%r12,2)
movw %r9w, 0x1e(%rdi,%r12,2)
incq %r12
cmpq %r12, %rbx
jne 0x5b7b07
xorl %eax, %eax
movw %r9w, (%rcx,%rax,2)
movw %r9w, (%rdi,%rax,2)
incq %rax
cmpq $0xf, %rax
jne 0x5b7b1f
leaq 0xf(%rbx), %rax
movq 0x10(%rbp), %r8
vmovdqa 0x2c0(%rsp), %ymm14
movq 0x120(%rsp), %rdx
movw %r9w, (%rcx,%rax,2)
movw %r9w, (%rdi,%rax,2)
incq %rax
incl %r13d
cmpl %r13d, %r15d
jg 0x5b7b4b
testl %edx, %edx
jle 0x5b88ec
leal -0x1(%rdx), %eax
movl %eax, 0x94(%rsp)
cmpl $0x2, %r15d
movl $0x1, %eax
cmovgel %r15d, %eax
movq %rax, 0x178(%rsp)
movl %edx, %edx
vmovdqa 0x2e0(%rsp), %ymm3
vmovdqa 0x220(%rsp), %ymm2
leaq (%rbx,%rbx,4), %rax
leaq (%rax,%rax,2), %rcx
addq $-0xf, %rcx
movq %rcx, 0x110(%rsp)
movq %rbx, %rsi
shlq $0x4, %rsi
leaq -0x1(%rbx), %rcx
movq %rcx, 0x108(%rsp)
leaq (%rbx,%rbx), %rcx
negq %rcx
movq %rsi, 0x160(%rsp)
addq %rsi, %rcx
addq $-0xe, %rcx
movq %rcx, 0xf8(%rsp)
leaq (%rbx,%rbx,2), %rcx
leaq -0xd(%rbx,%rcx,4), %rsi
movq %rsi, 0xf0(%rsp)
leaq -0xc(,%rcx,4), %rsi
movq %rsi, 0xe8(%rsp)
leaq -0xb(%rbx,%rax,2), %rsi
movq %rsi, 0xe0(%rsp)
leaq -0xa(,%rax,2), %rax
movq %rax, 0xd8(%rsp)
leaq (,%rbx,8), %rax
subq %rbx, %rax
addq $-0x7, %rax
movq %rax, 0xd0(%rsp)
vpbroadcastw 0x782ce(%rip), %ymm0 # 0x62ff0c
vmovdqa %ymm0, 0x200(%rsp)
leaq -0x6(,%rcx,2), %rax
movq %rax, 0xc8(%rsp)
vpbroadcastw 0x782ae(%rip), %ymm0 # 0x62ff0e
vmovdqa %ymm0, 0x3a0(%rsp)
vmovaps 0x761ef(%rip), %ymm0    # 0x62de60
vmovaps %ymm0, 0x120(%rsp)
vpbroadcastw 0x7828d(%rip), %ymm0 # 0x62ff10
vmovdqa %ymm0, 0x380(%rsp)
vpbroadcastw 0x7827d(%rip), %ymm0 # 0x62ff12
vmovdqa %ymm0, 0x1e0(%rsp)
vpbroadcastw 0x7826d(%rip), %ymm0 # 0x62ff14
vmovdqa %ymm0, 0x360(%rsp)
vpbroadcastw 0x7825d(%rip), %ymm0 # 0x62ff16
vmovdqa %ymm0, 0x340(%rsp)
vmovdqa 0x260(%rsp), %ymm0
vmovdqa %ymm0, 0x280(%rsp)
vmovdqa %ymm14, 0x2a0(%rsp)
vmovdqa %ymm14, %ymm7
leaq -0x9(%rbx,%rbx,8), %rax
movq %rax, 0xc0(%rsp)
leaq -0x8(,%rbx,8), %rax
movq %rax, 0xb8(%rsp)
leaq -0x5(%rbx,%rbx,4), %rax
movq %rax, 0xb0(%rsp)
leaq -0x4(,%rbx,4), %rax
movq %rax, 0xa8(%rsp)
leaq -0x3(%rbx,%rbx,2), %rax
movq %rax, 0xa0(%rsp)
leaq -0x2(,%rbx,2), %rax
movq %rax, 0x98(%rsp)
movq $0x0, 0x100(%rsp)
xorl %r11d, %r11d
cmpl $0x0, 0x30(%r8)
je 0x5b7e64
movq %r11, %rax
orq $0x1, %rax
cmpq %rdx, %rax
movl 0x94(%rsp), %r9d
cmovael %r9d, %eax
movq %rax, 0x140(%rsp)
movq %r11, %rax
orq $0x2, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x10(%rsp)
movq %r11, %r10
orq $0x3, %r10
cmpq %rdx, %r10
cmovael %r9d, %r10d
movq %r11, %rax
orq $0x4, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x8(%rsp)
movq %r11, %r15
orq $0x5, %r15
cmpq %rdx, %r15
cmovael %r9d, %r15d
movq %r11, %rax
orq $0x6, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x18(%rsp)
movq %r11, %r12
orq $0x7, %r12
cmpq %rdx, %r12
cmovael %r9d, %r12d
movq %r11, %rax
orq $0x8, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x48(%rsp)
movq %r11, %r13
orq $0x9, %r13
cmpq %rdx, %r13
cmovael %r9d, %r13d
movq %r11, %rax
orq $0xa, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x40(%rsp)
movq %r11, %rcx
orq $0xb, %rcx
cmpq %rdx, %rcx
cmovael %r9d, %ecx
movq %r11, %rax
orq $0xc, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x38(%rsp)
movq %r11, %rdi
orq $0xd, %rdi
cmpq %rdx, %rdi
cmovael %r9d, %edi
movq %r11, %rax
orq $0xe, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x30(%rsp)
movq %r11, %rax
orq $0xf, %rax
cmpq %rdx, %rax
cmovael %r9d, %eax
movq %rax, 0x28(%rsp)
movl %r11d, %r9d
jmp 0x5b7ef8
movq 0x58(%rsp), %rsi
movswl (%rsi,%r11,2), %r9d
movswl 0x2(%rsi,%r11,2), %eax
movq %rax, 0x140(%rsp)
movswl 0x4(%rsi,%r11,2), %eax
movq %rax, 0x10(%rsp)
movswl 0x6(%rsi,%r11,2), %r10d
movswl 0x8(%rsi,%r11,2), %eax
movq %rax, 0x8(%rsp)
movswl 0xa(%rsi,%r11,2), %r15d
movswl 0xc(%rsi,%r11,2), %eax
movq %rax, 0x18(%rsp)
movswl 0xe(%rsi,%r11,2), %r12d
movswl 0x10(%rsi,%r11,2), %eax
movq %rax, 0x48(%rsp)
movswl 0x12(%rsi,%r11,2), %r13d
movswl 0x14(%rsi,%r11,2), %eax
movq %rax, 0x40(%rsp)
movswl 0x16(%rsi,%r11,2), %ecx
movswl 0x18(%rsi,%r11,2), %eax
movq %rax, 0x38(%rsp)
movswl 0x1a(%rsi,%r11,2), %edi
movswl 0x1c(%rsi,%r11,2), %eax
movq %rax, 0x30(%rsp)
movswl 0x1e(%rsi,%r11,2), %eax
movq %rax, 0x28(%rsp)
movl 0x18(%r8), %r8d
imull %r8d, %edi
imull %r8d, %ecx
imull %r8d, %r13d
movq %r13, 0x68(%rsp)
imull %r8d, %r12d
movq %r12, 0x70(%rsp)
imull %r8d, %r15d
movq %r15, 0x78(%rsp)
imull %r8d, %r10d
movq %r10, 0x80(%rsp)
movq 0x140(%rsp), %rax
imull %r8d, %eax
movq %rax, 0x140(%rsp)
imull %r8d, %r9d
movl %r9d, 0x60(%rsp)
movq 0x10(%rsp), %rax
imull %r8d, %eax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %r12
imull %r8d, %r12d
movq 0x18(%rsp), %r13
imull %r8d, %r13d
movq 0x48(%rsp), %r15
imull %r8d, %r15d
movq 0x40(%rsp), %r10
imull %r8d, %r10d
movq 0x38(%rsp), %r9
imull %r8d, %r9d
movq 0x30(%rsp), %rax
imull %r8d, %eax
movq 0x28(%rsp), %rsi
imull %r8d, %esi
movslq %edi, %r8
movq 0x10(%rbp), %rdi
movq 0x8(%rdi), %rdi
leaq (%rdi,%r8,4), %r8
movq %r8, 0x168(%rsp)
movslq %ecx, %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x8(%rsp)
movslq 0x68(%rsp), %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x18(%rsp)
movslq 0x70(%rsp), %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x48(%rsp)
movslq 0x78(%rsp), %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x40(%rsp)
movslq 0x80(%rsp), %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x38(%rsp)
movslq 0x140(%rsp), %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x30(%rsp)
movslq 0x60(%rsp), %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x28(%rsp)
movslq 0x10(%rsp), %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x10(%rsp)
movslq %r12d, %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x80(%rsp)
movslq %r13d, %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x78(%rsp)
movslq %r15d, %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x70(%rsp)
movslq %r10d, %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x68(%rsp)
movslq %r9d, %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x60(%rsp)
cltq
leaq (%rdi,%rax,4), %rax
movq %rax, 0x1d8(%rsp)
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
movq %rax, 0x1d0(%rsp)
movq %r11, %rax
orq $0x1, %rax
movq %rax, 0x1c8(%rsp)
movq %r11, %rax
orq $0x2, %rax
movq %rax, 0x1c0(%rsp)
movq %r11, %rax
orq $0x3, %rax
movq %rax, 0x1b8(%rsp)
movq %r11, %rax
orq $0x4, %rax
movq %rax, 0x1b0(%rsp)
movq %r11, %rax
orq $0x5, %rax
movq %rax, 0x1a8(%rsp)
movq %r11, %rax
orq $0x6, %rax
movq %rax, 0x1a0(%rsp)
movq %r11, %rax
orq $0x7, %rax
movq %rax, 0x198(%rsp)
movq %r11, %rax
orq $0x8, %rax
movq %rax, 0x190(%rsp)
movq %r11, %rax
orq $0x9, %rax
movq %rax, 0x188(%rsp)
movq %r11, %rax
orq $0xa, %rax
movq %rax, 0x180(%rsp)
movq %r11, %rsi
orq $0xb, %rsi
movq %r11, %r8
orq $0xc, %r8
movq %r11, %r13
orq $0xd, %r13
movq %r11, %rcx
orq $0xe, %rcx
movq %r11, 0x170(%rsp)
movq %r11, %rax
movq 0x168(%rsp), %r11
orq $0xf, %rax
vmovdqa 0x300(%rsp), %ymm0
vpcmpgtw 0x120(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x420(%rsp)
vmovdqa 0x320(%rsp), %ymm0
vmovdqa %ymm0, %ymm12
vmovdqa %ymm14, %ymm5
vmovdqa %ymm14, %ymm1
vpmovsxbw 0x7609e(%rip), %ymm8 # 0x62e21c
xorl %r15d, %r15d
movq 0x50(%rsp), %r9
movq 0x88(%rsp), %rdi
vmovdqa %ymm7, 0x140(%rsp)
movswq 0x10(%r14,%r15,2), %r12
movq 0x48(%rsp), %r10
vmovd (%r10,%r12,4), %xmm6
movswq 0x12(%r14,%r15,2), %r12
movq 0x78(%rsp), %r10
vpinsrw $0x1, (%r10,%r12,4), %xmm6, %xmm6
movswq 0x14(%r14,%r15,2), %r12
movq 0x40(%rsp), %r10
vpinsrw $0x2, (%r10,%r12,4), %xmm6, %xmm6
movswq 0x16(%r14,%r15,2), %r12
movq 0x80(%rsp), %r10
vpinsrw $0x3, (%r10,%r12,4), %xmm6, %xmm6
movswq 0x18(%r14,%r15,2), %r12
movq 0x38(%rsp), %r10
vpinsrw $0x4, (%r10,%r12,4), %xmm6, %xmm6
movswq 0x1a(%r14,%r15,2), %r12
movq 0x10(%rsp), %r10
vpinsrw $0x5, (%r10,%r12,4), %xmm6, %xmm6
movswq 0x1c(%r14,%r15,2), %r12
movq 0x30(%rsp), %r10
vpinsrw $0x6, (%r10,%r12,4), %xmm6, %xmm6
movswq 0x1e(%r14,%r15,2), %r12
movq 0x28(%rsp), %r10
vpinsrw $0x7, (%r10,%r12,4), %xmm6, %xmm6
movswq (%r14,%r15,2), %r12
movq 0x1d0(%rsp), %r10
vmovd (%r10,%r12,4), %xmm7
movswq 0x2(%r14,%r15,2), %r12
movq 0x1d8(%rsp), %r10
vpinsrw $0x1, (%r10,%r12,4), %xmm7, %xmm7
movswq 0x4(%r14,%r15,2), %r12
vpinsrw $0x2, (%r11,%r12,4), %xmm7, %xmm7
movswq 0x6(%r14,%r15,2), %r12
movq 0x60(%rsp), %r10
vpinsrw $0x3, (%r10,%r12,4), %xmm7, %xmm7
movswq 0x8(%r14,%r15,2), %r12
movq 0x8(%rsp), %r10
vpinsrw $0x4, (%r10,%r12,4), %xmm7, %xmm7
movswq 0xa(%r14,%r15,2), %r12
movq 0x68(%rsp), %r10
vpinsrw $0x5, (%r10,%r12,4), %xmm7, %xmm7
movswq 0xc(%r14,%r15,2), %r12
movq 0x18(%rsp), %r10
vpinsrw $0x6, (%r10,%r12,4), %xmm7, %xmm7
movswq 0xe(%r14,%r15,2), %r12
movq 0x70(%rsp), %r10
vpinsrw $0x7, (%r10,%r12,4), %xmm7, %xmm7
vextracti128 $0x1, %ymm0, %xmm9
vpalignr $0x2, %ymm0, %ymm9, %ymm9 # ymm9 = ymm0[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm9[0,1],ymm0[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm9[16,17]
vpbroadcastw 0x1e(%r9,%r15,2), %ymm10
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]
vinserti128 $0x1, %xmm6, %ymm7, %ymm6
vpaddsw %ymm6, %ymm12, %ymm7
vpblendd $0xf0, %ymm10, %ymm9, %ymm12 # ymm12 = ymm9[0,1,2,3],ymm10[4,5,6,7]
vextracti128 $0x1, %ymm1, %xmm6
vpalignr $0x2, %ymm1, %ymm6, %ymm1 # ymm1 = ymm1[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm6[0,1],ymm1[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm6[16,17]
vpbroadcastw 0x1e(%rdi,%r15,2), %ymm6
vpblendw $0x80, %ymm6, %ymm1, %ymm6 # ymm6 = ymm1[0,1,2,3,4,5,6],ymm6[7],ymm1[8,9,10,11,12,13,14],ymm6[15]
vpblendd $0xf0, %ymm6, %ymm1, %ymm1 # ymm1 = ymm1[0,1,2,3],ymm6[4,5,6,7]
vmovdqa 0x400(%rsp), %ymm4
vpsubsw %ymm4, %ymm12, %ymm11
vmovdqa 0x3e0(%rsp), %ymm6
vpsubsw %ymm6, %ymm1, %ymm13
vpmaxsw %ymm13, %ymm11, %ymm1
vpsubsw %ymm4, %ymm0, %ymm9
vpsubsw %ymm6, %ymm5, %ymm6
vpmaxsw %ymm6, %ymm9, %ymm5
vpmaxsw 0x758ed(%rip), %ymm7, %ymm15 # 0x62dc20
vpmaxsw %ymm1, %ymm5, %ymm0
vpmaxsw %ymm0, %ymm15, %ymm10
vpcmpeqw 0x75f1d(%rip), %ymm8, %ymm7 # 0x62e260
vpandn %ymm10, %ymm7, %ymm0
vpblendvb %ymm7, %ymm14, %ymm1, %ymm1
cmpq $0x10, %r15
jb 0x5b8380
vmovdqa 0x280(%rsp), %ymm4
vpminsw %ymm0, %ymm4, %ymm4
vmovdqa %ymm4, 0x280(%rsp)
vmovdqa 0x2a0(%rsp), %ymm4
vpmaxsw %ymm0, %ymm4, %ymm4
vmovdqa %ymm4, 0x2a0(%rsp)
vpcmpeqw %ymm0, %ymm15, %ymm15
vpcmpeqw %ymm0, %ymm1, %ymm4
vmovdqa 0x200(%rsp), %ymm14
vpsubw %ymm4, %ymm14, %ymm4
vpcmpgtw 0x75883(%rip), %ymm0, %ymm14 # 0x62dc20
vpand 0x3a0(%rsp), %ymm14, %ymm14
vpblendvb %ymm15, %ymm14, %ymm4, %ymm4
vpcmpgtw %ymm6, %ymm9, %ymm6
vpcmpgtw %ymm13, %ymm11, %ymm9
vmovdqa 0x340(%rsp), %ymm11
vpblendvb %ymm9, 0x360(%rsp), %ymm11, %ymm9
vmovdqa 0x1e0(%rsp), %ymm11
vpblendvb %ymm6, 0x380(%rsp), %ymm11, %ymm6
vpor %ymm6, %ymm9, %ymm6
vpor %ymm4, %ymm6, %ymm11
movq 0x118(%rsp), %r9
movq 0x10(%r9), %r12
movq (%r12), %r12
vextracti128 $0x1, %ymm11, %xmm13
cmpq %rbx, %r15
jae 0x5b8413
movq 0x100(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0xe, %xmm13, (%r15,%r9)
cmpq %rdx, 0x1c8(%rsp)
setae %r9b
leaq -0x1(%r15), %r10
cmpq %rbx, %r10
setae %r10b
orb %r9b, %r10b
jne 0x5b8442
movq 0x108(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0xc, %xmm13, (%r15,%r9)
cmpq %rdx, 0x1c0(%rsp)
vmovdqa 0x2c0(%rsp), %ymm14
jae 0x5b8484
leaq -0x2(%r15), %r9
cmpq $0x2, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b8484
movq 0x98(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0xa, %xmm13, (%r15,%r9)
cmpq %rdx, 0x1b8(%rsp)
jae 0x5b84bd
leaq -0x3(%r15), %r9
cmpq $0x3, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b84bd
movq 0xa0(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x8, %xmm13, (%r15,%r9)
cmpq %rdx, 0x1b0(%rsp)
jae 0x5b84f6
leaq -0x4(%r15), %r9
cmpq $0x4, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b84f6
movq 0xa8(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x6, %xmm13, (%r15,%r9)
cmpq %rdx, 0x1a8(%rsp)
jae 0x5b852f
leaq -0x5(%r15), %r9
cmpq $0x5, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b852f
movq 0xb0(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x4, %xmm13, (%r15,%r9)
cmpq %rdx, 0x1a0(%rsp)
jae 0x5b8568
leaq -0x6(%r15), %r9
cmpq $0x6, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b8568
movq 0xc8(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x2, %xmm13, (%r15,%r9)
cmpq %rdx, 0x198(%rsp)
jae 0x5b85a1
leaq -0x7(%r15), %r9
cmpq $0x7, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b85a1
movq 0xd0(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x0, %xmm13, (%r15,%r9)
cmpq %rdx, 0x190(%rsp)
jae 0x5b85da
leaq -0x8(%r15), %r9
cmpq $0x8, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b85da
movq 0xb8(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0xe, %xmm11, (%r15,%r9)
cmpq %rdx, 0x188(%rsp)
jae 0x5b8613
leaq -0x9(%r15), %r9
cmpq $0x9, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b8613
movq 0xc0(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0xc, %xmm11, (%r15,%r9)
cmpq %rdx, 0x180(%rsp)
jae 0x5b864c
leaq -0xa(%r15), %r9
cmpq $0xa, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b864c
movq 0xd8(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0xa, %xmm11, (%r15,%r9)
cmpq %rdx, %rsi
jae 0x5b8680
leaq -0xb(%r15), %r9
cmpq $0xb, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b8680
movq 0xe0(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x8, %xmm11, (%r15,%r9)
cmpq %rdx, %r8
jae 0x5b86b4
leaq -0xc(%r15), %r9
cmpq $0xc, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b86b4
movq 0xe8(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x6, %xmm11, (%r15,%r9)
cmpq %rdx, %r13
jae 0x5b86e8
leaq -0xd(%r15), %r9
cmpq $0xd, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b86e8
movq 0xf0(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x4, %xmm11, (%r15,%r9)
cmpq %rdx, %rcx
jae 0x5b871c
leaq -0xe(%r15), %r9
cmpq $0xe, %r15
setae %r10b
cmpq %rbx, %r9
setl %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x5b871c
movq 0xf8(%rsp), %rdi
leaq (%r12,%rdi), %r9
vpextrb $0x2, %xmm11, (%r15,%r9)
cmpq %rdx, %rax
setae %r9b
cmpq $0xf, %r15
setb %r10b
orb %r9b, %r10b
jne 0x5b873f
addq 0x110(%rsp), %r12
vpextrb $0x0, %xmm11, (%r15,%r12)
vmovdqa 0x3c0(%rsp), %ymm4
vpcmpgtw %ymm8, %ymm4, %ymm4
vpand 0x420(%rsp), %ymm4, %ymm4
vpsraw $0xf, %ymm8, %ymm6
vpandn %ymm4, %ymm6, %ymm4
vextracti128 $0x1, %ymm4, %xmm6
vpacksswb %xmm6, %xmm4, %xmm6
vpcmpeqw %ymm3, %ymm0, %ymm9
vpcmpgtw %ymm3, %ymm0, %ymm11
vpand %ymm4, %ymm11, %ymm13
vpblendvb %ymm13, %ymm10, %ymm3, %ymm3
vextracti128 $0x1, %ymm13, %xmm10
vpacksswb %xmm10, %xmm13, %xmm10
vpcmpgtw %ymm8, %ymm2, %ymm13
vpand %ymm13, %ymm9, %ymm9
vextracti128 $0x1, %ymm9, %xmm13
vpacksswb %xmm13, %xmm9, %xmm13
vpblendvb %xmm13, %xmm6, %xmm10, %xmm6
vpblendvb %ymm7, %ymm14, %ymm5, %ymm5
vpmovsxbw %xmm6, %ymm6
vmovdqa 0x140(%rsp), %ymm7
vpblendvb %ymm6, 0x120(%rsp), %ymm7, %ymm7
vpor %ymm11, %ymm9, %ymm6
vpand %ymm6, %ymm4, %ymm4
vpblendvb %ymm4, %ymm8, %ymm2, %ymm2
movq 0x50(%rsp), %r9
vpextrw $0x0, %xmm0, (%r9,%r15,2)
movq 0x88(%rsp), %rdi
vpextrw $0x0, %xmm1, (%rdi,%r15,2)
vpaddsw 0x200(%rsp), %ymm8, %ymm8
incq %r15
cmpq %r15, 0x178(%rsp)
jne 0x5b818e
vmovdqa 0x120(%rsp), %ymm0
vpaddsw 0x1e0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x120(%rsp)
movq 0x170(%rsp), %r11
addq $0x10, %r11
movq 0x160(%rsp), %rax
addq %rax, 0x110(%rsp)
addq %rax, 0x100(%rsp)
addq %rax, 0x108(%rsp)
addq %rax, 0xf8(%rsp)
addq %rax, 0xf0(%rsp)
addq %rax, 0xe8(%rsp)
addq %rax, 0xe0(%rsp)
addq %rax, 0xd8(%rsp)
addq %rax, 0xc0(%rsp)
addq %rax, 0xb8(%rsp)
addq %rax, 0xd0(%rsp)
addq %rax, 0xc8(%rsp)
addq %rax, 0xb0(%rsp)
addq %rax, 0xa8(%rsp)
addq %rax, 0xa0(%rsp)
addq %rax, 0x98(%rsp)
cmpq %rdx, %r11
movq 0x10(%rbp), %r8
jb 0x5b7d47
vmovdqa %ymm3, 0x2e0(%rsp)
vmovdqa %ymm2, 0x220(%rsp)
movl 0x24(%rsp), %r9d
vmovdqa 0x2a0(%rsp), %ymm1
vmovdqa 0x280(%rsp), %ymm0
jmp 0x5b88fd
vmovdqa %ymm14, %ymm7
vmovdqa %ymm14, %ymm1
vmovdqa 0x260(%rsp), %ymm0
vmovdqa %ymm7, 0x240(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x118(%rsp), %rbx
movzwl 0x2e0(%rsp,%rdx,2), %esi
cmpw %r9w, %si
jle 0x5b8937
movswl 0x240(%rsp,%rdx,2), %eax
movswl 0x220(%rsp,%rdx,2), %ecx
movl %esi, %r9d
jmp 0x5b8960
jne 0x5b8960
movswl 0x220(%rsp,%rdx,2), %esi
cmpl %esi, %ecx
jle 0x5b8951
movswl 0x240(%rsp,%rdx,2), %eax
movl %esi, %ecx
jmp 0x5b8960
jne 0x5b8960
movswl 0x240(%rsp,%rdx,2), %esi
cmpl %esi, %eax
cmovgel %esi, %eax
incq %rdx
cmpl $0x10, %edx
jne 0x5b8914
vpcmpgtw %ymm0, %ymm14, %ymm0
vpcmpgtw 0x260(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vpmovmskb %ymm0, %edx
testl %edx, %edx
je 0x5b898c
orb $0x40, 0xc(%rbx)
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %eax, %eax
movswl %r9w, %edx
movl %edx, (%rbx)
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq 0x50(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5b89f9
movq 0x58(%rsp), %rdi
callq 0x20a60d
jmp 0x5b89f9
callq 0x1f9a71
jmp 0x5b89f7
callq 0x1f9a4b
jmp 0x5b89f7
callq 0x1f9a25
jmp 0x5b89f7
callq 0x1f99ff
jmp 0x5b89f7
callq 0x1f99d9
jmp 0x5b89f7
callq 0x1f99b3
jmp 0x5b89f7
callq 0x1f998d
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop