// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_diag_avx2_256_16.c
// Function: parasail_nw_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 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;
    __m256i vTDiag;
    __m256i vTIns;
    __m256i vTDel;
    __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 = 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);
    vTDiag = _mm256_set1_epi16(PARASAIL_DIAG);
    vTIns = _mm256_set1_epi16(PARASAIL_INS);
    vTDel = _mm256_set1_epi16(PARASAIL_DEL);
    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_NW | 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] = -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 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))];
        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_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);
            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);
            }
            /* trace table */
            {
                __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),
                        vTDiag,
                        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
               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 $0x3b8, %rsp            # imm = 0x3B8
testq %rdx, %rdx
je 0x5b6073
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x5b607a
movl %r8d, %ebp
testl %r8d, %r8d
js 0x5b6081
movl %r9d, %r15d
testl %r9d, %r9d
js 0x5b6088
movq 0x3f0(%rsp), %rcx
testq %rcx, %rcx
je 0x5b608f
cmpl $0x0, 0x30(%rcx)
je 0x5b4e86
movl 0x34(%rcx), %r13d
jmp 0x5b4e9a
testq %rdi, %rdi
je 0x5b6096
movl %esi, %r13d
testl %esi, %esi
jle 0x5b609d
movq %rdi, 0x28(%rsp)
movq %rdx, 0x1b0(%rsp)
vmovd %r15d, %xmm0
vpinsrd $0x1, %ebp, %xmm0, %xmm0
vpmovsxbd 0x79349(%rip), %ymm1 # 0x62e204
vpermd %ymm0, %ymm1, %ymm0
vpmulld 0x792d7(%rip), %ymm0, %ymm0 # 0x62e1a0
movl 0x20(%rcx), %eax
vmovdqu %ymm0, 0x190(%rsp)
vextracti128 $0x1, %ymm0, %xmm0
vpextrd $0x3, %xmm0, %esi
movl %eax, %edx
negl %edx
movl %esi, 0x14(%rsp)
cmpl %esi, %eax
cmovgl %ebp, %edx
movl %edx, 0xc(%rsp)
movw $0x7ffe, %bx            # imm = 0x7FFE
subw 0x1c(%rcx), %bx
movl $0x20, %edx
movl $0x1, %ecx
movl %r13d, %edi
movl %r14d, %esi
vzeroupper
callq 0x20adf4
testq %rax, %rax
je 0x5b60a2
movq %rax, %r12
movl %ebp, 0x20(%rsp)
movq %r13, (%rsp)
movq %r15, 0x60(%rsp)
orl $0x10281001, 0xc(%rax)  # imm = 0x10281001
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, %rbp
movl $0x20, %edi
movq %r13, %rsi
callq 0x20a625
testq %r15, %r15
sete %dl
movq %rbp, 0x90(%rsp)
testq %rbp, %rbp
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x5b60a2
movq %rax, 0x50(%rsp)
movq %r12, 0x120(%rsp)
movq 0x3f0(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x5b4fb5
movq $0x0, 0x58(%rsp)
movq 0x60(%rsp), %r13
jmp 0x5b5039
movq (%rsp), %r12
leal 0xf(%r12), %ebp
movslq %ebp, %rsi
movl $0x20, %edi
callq 0x20a625
testq %rax, %rax
je 0x5b60a2
movq %rax, %rdi
testl %r12d, %r12d
movq 0x60(%rsp), %r13
movq 0x28(%rsp), %r8
jle 0x5b500c
movq 0x3f0(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rsp), %ecx
xorl %edx, %edx
movzbl (%r8,%rdx), %esi
movzwl (%rax,%rsi,4), %esi
movw %si, (%rdi,%rdx,2)
incq %rdx
cmpq %rdx, %rcx
jne 0x5b4ff7
movq (%rsp), %rsi
movslq %esi, %rax
leal 0x1(%rsi), %ecx
cmpl %ecx, %ebp
cmovgl %ebp, %ecx
movq %rdi, 0x58(%rsp)
leaq (%rdi,%rax,2), %rdi
movl %esi, %eax
notl %eax
addl %ecx, %eax
leaq 0x2(,%rax,2), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x1b0(%rsp), %r10
vmovd %ebx, %xmm0
movl 0x20(%rsp), %r11d
vmovd %r11d, %xmm1
movl %r13d, %eax
shll $0x4, %eax
vmovd %eax, %xmm2
movl 0x14(%rsp), %r9d
movl %r9d, %eax
subl %r13d, %eax
subl %r13d, %eax
imull $0xfffd, %r13d, %ecx    # imm = 0xFFFD
subl %r11d, %ecx
leal (,%r13,4), %esi
movl %r9d, %edx
subl %esi, %edx
imull $0xfffb, %r13d, %esi    # imm = 0xFFFB
subl %r11d, %esi
imull $0xfffa, %r13d, %edi    # imm = 0xFFFA
subl %r11d, %edi
leal (,%r13,8), %r8d
vmovd %r11d, %xmm3
vpinsrd $0x1, %r8d, %xmm3, %xmm3
imull $0xfff9, %r13d, %r8d    # imm = 0xFFF9
subl %r11d, %r8d
vmovd %r8d, %xmm4
leal 0xf(%r14), %ebx
movq (%rsp), %r8
vmovd %r8d, %xmm5
vpbroadcastw %xmm5, %ymm5
vpcmpeqd %ymm6, %ymm6, %ymm6
vpaddsw %ymm6, %ymm5, %ymm5
vmovdqu %ymm5, 0x290(%rsp)
vmovd %r14d, %xmm5
vpbroadcastw %xmm5, %ymm5
vpaddsw %ymm6, %ymm5, %ymm5
vmovdqu %ymm5, 0x390(%rsp)
vmovd %edi, %xmm5
leal -0x1(%r8), %edi
movl %edi, 0x10(%rsp)
vpmovsxbd 0x79101(%rip), %ymm6 # 0x62e204
vpermd %ymm3, %ymm6, %ymm3
vmovd %esi, %xmm6
leal -0x1(%r14), %esi
movl %esi, 0x9c(%rsp)
movl 0xc(%rsp), %esi
addl $0xffff8001, %esi       # imm = 0xFFFF8001
vmovdqu 0x190(%rsp), %ymm7
vpsubd %ymm3, %ymm7, %ymm3
movl %esi, 0xc(%rsp)
vmovd %esi, %xmm7
vpbroadcastw %xmm7, %ymm7
vmovdqu %ymm7, 0x230(%rsp)
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x1d0(%rsp)
vpbroadcastw %xmm1, %ymm0
vmovdqu %ymm0, 0x370(%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 %r13d, %xmm1
vpbroadcastw %xmm1, %ymm1
vmovdqu %ymm1, 0x350(%rsp)
vpbroadcastw %xmm2, %ymm1
vmovdqu %ymm1, 0x270(%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 %r9d, %edx
vpshufb 0x79014(%rip), %ymm3, %ymm2 # 0x62e1c0
subl %r13d, %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 %r9d, %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, 0x1b0(%rsp)
movq 0x3f0(%rsp), %rax
movq 0x10(%rax), %rax
movl %r14d, %ebp
xorl %ecx, %ecx
movzbl (%r10,%rcx), %edx
movzwl (%rax,%rdx,4), %edx
movw %dx, 0x1e(%r15,%rcx,2)
incq %rcx
cmpq %rcx, %rbp
jne 0x5b521d
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 0x14(%rsp), %eax
movl 0xc(%rsp), %edx
movq 0x90(%rsp), %rcx
movq 0x50(%rsp), %rsi
movw %ax, 0x1e(%rcx,%r12,2)
subl %r13d, %eax
movw %dx, 0x1e(%rsi,%r12,2)
incq %r12
cmpq %r12, %rbp
jne 0x5b5285
xorl %eax, %eax
movq %rcx, %r12
movw %dx, (%r12,%rax,2)
movw %dx, (%rsi,%rax,2)
incq %rax
cmpq $0xf, %rax
jne 0x5b52a1
leaq 0xf(%rbp), %rax
movq 0x3f0(%rsp), %r8
vmovdqu 0x230(%rsp), %ymm12
movq (%rsp), %rcx
movw %dx, (%r12,%rax,2)
movw %dx, (%rsi,%rax,2)
incq %rax
incl %r14d
cmpl %r14d, %ebx
jg 0x5b52cc
movw $0x0, 0x1c(%r12)
testl %ecx, %ecx
jle 0x5b5fbc
vextracti128 $0x1, %ymm12, %xmm0
vpalignr $0x2, %ymm12, %ymm0, %ymm0 # ymm0 = ymm12[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm0[0,1],ymm12[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm0[16,17]
vmovdqu %ymm0, 0x250(%rsp)
cmpl $0x2, %ebx
movl $0x1, %eax
cmovgel %ebx, %eax
movq %rax, 0x138(%rsp)
movl %ecx, %ecx
leaq (%rbp,%rbp,4), %rax
leaq (%rax,%rax,2), %rdx
addq $-0xf, %rdx
movq %rdx, 0x118(%rsp)
movq %rbp, %rsi
shlq $0x4, %rsi
leaq -0x1(%rbp), %rdx
movq %rdx, 0x110(%rsp)
leaq (,%rbp,2), %rdx
negq %rdx
movq %rsi, 0x128(%rsp)
addq %rsi, %rdx
addq $-0xe, %rdx
movq %rdx, 0x100(%rsp)
leaq (%rbp,%rbp,2), %rdx
leaq -0xd(%rbp,%rdx,4), %rsi
movq %rsi, 0xf8(%rsp)
leaq -0xc(,%rdx,4), %rsi
movq %rsi, 0xf0(%rsp)
leaq -0xb(%rbp,%rax,2), %rsi
movq %rsi, 0xe8(%rsp)
leaq -0xa(%rax,%rax), %rax
movq %rax, 0xe0(%rsp)
leaq -0x9(%rbp,%rbp,8), %rax
movq %rax, 0xd8(%rsp)
leaq (,%rbp,8), %rax
leaq -0x8(,%rbp,8), %rsi
movq %rsi, 0xc8(%rsp)
subq %rbp, %rax
addq $-0x7, %rax
movq %rax, 0xd0(%rsp)
leaq -0x6(,%rdx,2), %rax
movq %rax, 0xc0(%rsp)
vpbroadcastw 0x7aadd(%rip), %ymm4 # 0x62feca
leaq -0x5(%rbp,%rbp,4), %rax
movq %rax, 0xb8(%rsp)
vpbroadcastw 0x7aac9(%rip), %ymm0 # 0x62fecc
vmovdqu %ymm0, 0x330(%rsp)
vpmovsxbw 0x78df7(%rip), %ymm5 # 0x62e20c
vpbroadcastw 0x7aab0(%rip), %ymm0 # 0x62fece
vmovdqu %ymm0, 0x310(%rsp)
vpbroadcastw 0x7aaa0(%rip), %ymm9 # 0x62fed0
vpbroadcastw 0x7aa99(%rip), %ymm0 # 0x62fed2
vmovdqu %ymm0, 0x2f0(%rsp)
vpbroadcastw 0x7aa89(%rip), %ymm0 # 0x62fed4
vmovdqu %ymm0, 0x2d0(%rsp)
vmovdqu 0x1d0(%rsp), %ymm0
vmovdqu %ymm0, 0x1f0(%rsp)
vmovdqu %ymm12, 0x210(%rsp)
vmovdqa %ymm12, %ymm3
leaq -0x4(,%rbp,4), %rax
movq %rax, 0xb0(%rsp)
leaq -0x3(%rbp,%rbp,2), %rax
movq %rax, 0xa8(%rsp)
leaq -0x2(,%rbp,2), %rax
movq %rax, 0xa0(%rsp)
movq $0x0, 0x108(%rsp)
xorl %r14d, %r14d
cmpl $0x0, 0x30(%r8)
je 0x5b55c8
movq %r14, %rax
orq $0x1, %rax
cmpq %rcx, %rax
movl 0x10(%rsp), %r9d
cmovael %r9d, %eax
movq %rax, 0x18(%rsp)
movq %r14, %rax
orq $0x2, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, (%rsp)
movq %r14, %r10
orq $0x3, %r10
cmpq %rcx, %r10
cmovael %r9d, %r10d
movq %r14, %rax
orq $0x4, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x190(%rsp)
movq %r14, %r11
orq $0x5, %r11
cmpq %rcx, %r11
cmovael %r9d, %r11d
movq %r14, %rax
orq $0x6, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x28(%rsp)
movq %r14, %rbx
orq $0x7, %rbx
cmpq %rcx, %rbx
cmovael %r9d, %ebx
movq %r14, %rax
orq $0x8, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x20(%rsp)
movq %r14, %r12
orq $0x9, %r12
cmpq %rcx, %r12
cmovael %r9d, %r12d
movq %r14, %rax
orq $0xa, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x48(%rsp)
movq %r14, %rdx
orq $0xb, %rdx
cmpq %rcx, %rdx
cmovael %r9d, %edx
movq %r14, %rax
orq $0xc, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x40(%rsp)
movq %r14, %rdi
orq $0xd, %rdi
cmpq %rcx, %rdi
cmovael %r9d, %edi
movq %r14, %rax
orq $0xe, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x38(%rsp)
movq %r14, %rax
orq $0xf, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x30(%rsp)
movl %r14d, %r9d
jmp 0x5b565b
movq 0x58(%rsp), %rsi
movswl (%rsi,%r14,2), %r9d
movswl 0x2(%rsi,%r14,2), %eax
movq %rax, 0x18(%rsp)
movswl 0x4(%rsi,%r14,2), %eax
movq %rax, (%rsp)
movswl 0x6(%rsi,%r14,2), %r10d
movswl 0x8(%rsi,%r14,2), %eax
movq %rax, 0x190(%rsp)
movswl 0xa(%rsi,%r14,2), %r11d
movswl 0xc(%rsi,%r14,2), %eax
movq %rax, 0x28(%rsp)
movswl 0xe(%rsi,%r14,2), %ebx
movswl 0x10(%rsi,%r14,2), %eax
movq %rax, 0x20(%rsp)
movswl 0x12(%rsi,%r14,2), %r12d
movswl 0x14(%rsi,%r14,2), %eax
movq %rax, 0x48(%rsp)
movswl 0x16(%rsi,%r14,2), %edx
movswl 0x18(%rsi,%r14,2), %eax
movq %rax, 0x40(%rsp)
movswl 0x1a(%rsi,%r14,2), %edi
movswl 0x1c(%rsi,%r14,2), %eax
movq %rax, 0x38(%rsp)
movswl 0x1e(%rsi,%r14,2), %eax
movq %rax, 0x30(%rsp)
movl 0x18(%r8), %r8d
imull %r8d, %edi
imull %r8d, %edx
imull %r8d, %r12d
movq %r12, 0x70(%rsp)
imull %r8d, %ebx
movq %rbx, 0x78(%rsp)
imull %r8d, %r11d
movq %r11, 0x80(%rsp)
imull %r8d, %r10d
movq %r10, 0x88(%rsp)
movq 0x18(%rsp), %rax
imull %r8d, %eax
movq %rax, 0x18(%rsp)
imull %r8d, %r9d
movl %r9d, 0x68(%rsp)
movq (%rsp), %r11
imull %r8d, %r11d
movq 0x190(%rsp), %rbx
imull %r8d, %ebx
movq 0x28(%rsp), %r12
imull %r8d, %r12d
movq 0x20(%rsp), %r13
imull %r8d, %r13d
movq 0x48(%rsp), %r10
imull %r8d, %r10d
movq 0x40(%rsp), %r9
imull %r8d, %r9d
movq 0x38(%rsp), %rax
imull %r8d, %eax
movq 0x30(%rsp), %rsi
imull %r8d, %esi
movslq %edi, %r8
movq 0x3f0(%rsp), %rdi
movq 0x8(%rdi), %rdi
leaq (%rdi,%r8,4), %r8
movq %r8, (%rsp)
movslq %edx, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x190(%rsp)
movslq 0x70(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x28(%rsp)
movslq 0x78(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x20(%rsp)
movslq 0x80(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x48(%rsp)
movslq 0x88(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x40(%rsp)
movslq 0x18(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x18(%rsp)
movslq 0x68(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x38(%rsp)
movslq %r11d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x30(%rsp)
movslq %ebx, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x88(%rsp)
movslq %r12d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x80(%rsp)
movslq %r13d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x78(%rsp)
movslq %r10d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x70(%rsp)
movslq %r9d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x68(%rsp)
cltq
leaq (%rdi,%rax,4), %rax
movq %rax, 0x188(%rsp)
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
movq %rax, 0x180(%rsp)
movq 0x90(%rsp), %r12
vpbroadcastw 0x1c(%r12), %ymm0
leaq 0x10(%r14), %rax
movq %rax, 0x130(%rsp)
movq 0x60(%rsp), %rsi
imull %esi, %eax
movl 0x14(%rsp), %edi
movl %edi, %edx
subl %eax, %edx
movw %dx, 0x1c(%r12)
movl %r14d, %eax
imull %esi, %eax
movl %edi, %edx
subl %eax, %edx
vmovd %edx, %xmm1
vpbroadcastw %xmm1, %ymm1
vmovdqu 0x250(%rsp), %ymm2
vpblendw $0x80, %ymm1, %ymm2, %ymm1 # ymm1 = ymm2[0,1,2,3,4,5,6],ymm1[7],ymm2[8,9,10,11,12,13,14],ymm1[15]
vpblendd $0xf0, %ymm1, %ymm2, %ymm13 # ymm13 = ymm2[0,1,2,3],ymm1[4,5,6,7]
vpblendw $0x80, %ymm0, %ymm2, %ymm0 # ymm0 = ymm2[0,1,2,3,4,5,6],ymm0[7],ymm2[8,9,10,11,12,13,14],ymm0[15]
vpblendd $0xf0, %ymm0, %ymm2, %ymm14 # ymm14 = ymm2[0,1,2,3],ymm0[4,5,6,7]
movq %r14, %rax
orq $0x1, %rax
movq %rax, 0x178(%rsp)
movq %r14, %rax
orq $0x2, %rax
movq %rax, 0x170(%rsp)
movq %r14, %rax
orq $0x3, %rax
movq %rax, 0x168(%rsp)
movq %r14, %rax
orq $0x4, %rax
movq %rax, 0x160(%rsp)
movq %r14, %rax
orq $0x5, %rax
movq %rax, 0x158(%rsp)
movq %r14, %rax
orq $0x6, %rax
movq %rax, 0x150(%rsp)
movq %r14, %rax
orq $0x7, %rax
movq %rax, 0x148(%rsp)
movq %r14, %rax
orq $0x8, %rax
movq %rax, 0x140(%rsp)
movq %r14, %r11
orq $0x9, %r11
movq %r14, %rsi
orq $0xa, %rsi
movq %r14, %rbx
orq $0xb, %rbx
movq %r14, %rdx
orq $0xc, %rdx
movq %r14, %rdi
orq $0xd, %rdi
movq %r14, %r9
orq $0xe, %r9
orq $0xf, %r14
vmovdqu %ymm5, 0x2b0(%rsp)
vpcmpeqw 0x290(%rsp), %ymm5, %ymm15
vpmovsxbw 0x78919(%rip), %ymm8 # 0x62e21c
vmovdqa %ymm12, %ymm0
vmovdqa %ymm12, %ymm1
xorl %eax, %eax
movq 0x50(%rsp), %r8
movswq 0x10(%r15,%rax,2), %r13
movq 0x20(%rsp), %r10
vmovd (%r10,%r13,4), %xmm2
movswq 0x12(%r15,%rax,2), %r13
movq 0x80(%rsp), %r10
vpinsrw $0x1, (%r10,%r13,4), %xmm2, %xmm2
movswq 0x14(%r15,%rax,2), %r13
movq 0x48(%rsp), %r10
vpinsrw $0x2, (%r10,%r13,4), %xmm2, %xmm2
movswq 0x16(%r15,%rax,2), %r13
movq 0x88(%rsp), %r10
vpinsrw $0x3, (%r10,%r13,4), %xmm2, %xmm2
movswq 0x18(%r15,%rax,2), %r13
movq 0x40(%rsp), %r10
vpinsrw $0x4, (%r10,%r13,4), %xmm2, %xmm2
movswq 0x1a(%r15,%rax,2), %r13
movq 0x30(%rsp), %r10
vpinsrw $0x5, (%r10,%r13,4), %xmm2, %xmm2
movswq 0x1c(%r15,%rax,2), %r13
movq 0x18(%rsp), %r10
vpinsrw $0x6, (%r10,%r13,4), %xmm2, %xmm2
movswq 0x1e(%r15,%rax,2), %r13
movq 0x38(%rsp), %r10
vpinsrw $0x7, (%r10,%r13,4), %xmm2, %xmm2
movswq (%r15,%rax,2), %r13
movq 0x180(%rsp), %r10
vmovd (%r10,%r13,4), %xmm5
movswq 0x2(%r15,%rax,2), %r13
movq 0x188(%rsp), %r10
vpinsrw $0x1, (%r10,%r13,4), %xmm5, %xmm5
movswq 0x4(%r15,%rax,2), %r13
movq (%rsp), %r10
vpinsrw $0x2, (%r10,%r13,4), %xmm5, %xmm5
movswq 0x6(%r15,%rax,2), %r13
movq 0x68(%rsp), %r10
vpinsrw $0x3, (%r10,%r13,4), %xmm5, %xmm5
movswq 0x8(%r15,%rax,2), %r13
movq 0x190(%rsp), %r10
vpinsrw $0x4, (%r10,%r13,4), %xmm5, %xmm5
movswq 0xa(%r15,%rax,2), %r13
movq 0x70(%rsp), %r10
vpinsrw $0x5, (%r10,%r13,4), %xmm5, %xmm5
movswq 0xc(%r15,%rax,2), %r13
movq 0x28(%rsp), %r10
vpinsrw $0x6, (%r10,%r13,4), %xmm5, %xmm5
movswq 0xe(%r15,%rax,2), %r13
movq 0x78(%rsp), %r10
vpinsrw $0x7, (%r10,%r13,4), %xmm5, %xmm5
vpbroadcastw 0x1e(%r12,%rax,2), %ymm6
vextracti128 $0x1, %ymm13, %xmm7
vpalignr $0x2, %ymm13, %ymm7, %ymm7 # ymm7 = ymm13[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm7[0,1],ymm13[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm7[16,17]
vpblendw $0x80, %ymm6, %ymm7, %ymm6 # ymm6 = ymm7[0,1,2,3,4,5,6],ymm6[7],ymm7[8,9,10,11,12,13,14],ymm6[15]
vinserti128 $0x1, %xmm2, %ymm5, %ymm2
vpaddsw %ymm2, %ymm14, %ymm2
vpblendd $0xf0, %ymm6, %ymm7, %ymm14 # ymm14 = ymm7[0,1,2,3],ymm6[4,5,6,7]
vextracti128 $0x1, %ymm0, %xmm5
vpalignr $0x2, %ymm0, %ymm5, %ymm0 # ymm0 = ymm0[2,3,4,5,6,7,8,9,10,11,12,13,14,15],ymm5[0,1],ymm0[18,19,20,21,22,23,24,25,26,27,28,29,30,31],ymm5[16,17]
vpbroadcastw 0x1e(%r8,%rax,2), %ymm5
vpblendw $0x80, %ymm5, %ymm0, %ymm5 # ymm5 = ymm0[0,1,2,3,4,5,6],ymm5[7],ymm0[8,9,10,11,12,13,14],ymm5[15]
vpblendd $0xf0, %ymm5, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3],ymm5[4,5,6,7]
vmovdqu 0x370(%rsp), %ymm6
vpsubsw %ymm6, %ymm14, %ymm5
vmovdqu 0x350(%rsp), %ymm10
vpsubsw %ymm10, %ymm0, %ymm7
vpmaxsw %ymm7, %ymm5, %ymm0
vpsubsw %ymm6, %ymm13, %ymm11
vpsubsw %ymm10, %ymm1, %ymm1
vpmaxsw %ymm1, %ymm11, %ymm6
vpmaxsw %ymm0, %ymm6, %ymm10
vpmaxsw %ymm2, %ymm10, %ymm13
vpcmpeqw 0x7879f(%rip), %ymm8, %ymm10 # 0x62e260
vpblendvb %ymm10, 0x1b0(%rsp), %ymm13, %ymm13
vpblendvb %ymm10, %ymm12, %ymm0, %ymm0
cmpq $0x10, %rax
jb 0x5b5b06
vmovdqu 0x1f0(%rsp), %ymm12
vpminsw %ymm13, %ymm12, %ymm12
vmovdqu %ymm12, 0x1f0(%rsp)
vmovdqu 0x210(%rsp), %ymm12
vpmaxsw %ymm13, %ymm12, %ymm12
vmovdqu %ymm12, 0x210(%rsp)
vpcmpeqw %ymm2, %ymm13, %ymm2
vpcmpeqw %ymm0, %ymm13, %ymm12
vpsubw %ymm12, %ymm4, %ymm12
vpblendvb %ymm2, 0x330(%rsp), %ymm12, %ymm2
vpcmpgtw %ymm1, %ymm11, %ymm1
vpcmpgtw %ymm7, %ymm5, %ymm5
vmovdqu 0x2d0(%rsp), %ymm7
vpblendvb %ymm5, 0x2f0(%rsp), %ymm7, %ymm5
vpblendvb %ymm1, 0x310(%rsp), %ymm9, %ymm1
vpor %ymm1, %ymm5, %ymm1
vpor %ymm2, %ymm1, %ymm1
movq 0x120(%rsp), %r8
movq 0x10(%r8), %r13
movq (%r13), %r13
vextracti128 $0x1, %ymm1, %xmm2
cmpq %rbp, %rax
jae 0x5b5b7b
movq 0x108(%rsp), %r8
leaq (%r8,%r13), %r12
vpextrb $0xe, %xmm2, (%rax,%r12)
cmpq %rcx, 0x178(%rsp)
setae %r12b
leaq -0x1(%rax), %r8
cmpq %rbp, %r8
setae %r8b
orb %r12b, %r8b
jne 0x5b5ba9
movq 0x110(%rsp), %r8
addq %r13, %r8
vpextrb $0xc, %xmm2, (%rax,%r8)
cmpq %rcx, 0x170(%rsp)
vmovdqu 0x230(%rsp), %ymm12
jae 0x5b5bea
leaq -0x2(%rax), %r8
cmpq $0x2, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5bea
movq 0xa0(%rsp), %r8
addq %r13, %r8
vpextrb $0xa, %xmm2, (%rax,%r8)
cmpq %rcx, 0x168(%rsp)
jae 0x5b5c22
leaq -0x3(%rax), %r8
cmpq $0x3, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5c22
movq 0xa8(%rsp), %r8
addq %r13, %r8
vpextrb $0x8, %xmm2, (%rax,%r8)
cmpq %rcx, 0x160(%rsp)
jae 0x5b5c5a
leaq -0x4(%rax), %r8
cmpq $0x4, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5c5a
movq 0xb0(%rsp), %r8
addq %r13, %r8
vpextrb $0x6, %xmm2, (%rax,%r8)
cmpq %rcx, 0x158(%rsp)
jae 0x5b5c92
leaq -0x5(%rax), %r8
cmpq $0x5, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5c92
movq 0xb8(%rsp), %r8
addq %r13, %r8
vpextrb $0x4, %xmm2, (%rax,%r8)
cmpq %rcx, 0x150(%rsp)
jae 0x5b5cca
leaq -0x6(%rax), %r8
cmpq $0x6, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5cca
movq 0xc0(%rsp), %r8
addq %r13, %r8
vpextrb $0x2, %xmm2, (%rax,%r8)
cmpq %rcx, 0x148(%rsp)
jae 0x5b5d02
leaq -0x7(%rax), %r8
cmpq $0x7, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5d02
movq 0xd0(%rsp), %r8
addq %r13, %r8
vpextrb $0x0, %xmm2, (%rax,%r8)
cmpq %rcx, 0x140(%rsp)
jae 0x5b5d3a
leaq -0x8(%rax), %r8
cmpq $0x8, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5d3a
movq 0xc8(%rsp), %r8
addq %r13, %r8
vpextrb $0xe, %xmm1, (%rax,%r8)
cmpq %rcx, %r11
jae 0x5b5d6d
leaq -0x9(%rax), %r8
cmpq $0x9, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5d6d
movq 0xd8(%rsp), %r8
addq %r13, %r8
vpextrb $0xc, %xmm1, (%rax,%r8)
cmpq %rcx, %rsi
jae 0x5b5da0
leaq -0xa(%rax), %r8
cmpq $0xa, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5da0
movq 0xe0(%rsp), %r8
addq %r13, %r8
vpextrb $0xa, %xmm1, (%rax,%r8)
cmpq %rcx, %rbx
jae 0x5b5dd3
leaq -0xb(%rax), %r8
cmpq $0xb, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5dd3
movq 0xe8(%rsp), %r8
addq %r13, %r8
vpextrb $0x8, %xmm1, (%rax,%r8)
cmpq %rcx, %rdx
jae 0x5b5e06
leaq -0xc(%rax), %r8
cmpq $0xc, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5e06
movq 0xf0(%rsp), %r8
addq %r13, %r8
vpextrb $0x6, %xmm1, (%rax,%r8)
cmpq %rcx, %rdi
jae 0x5b5e39
leaq -0xd(%rax), %r8
cmpq $0xd, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5e39
movq 0xf8(%rsp), %r8
addq %r13, %r8
vpextrb $0x4, %xmm1, (%rax,%r8)
cmpq %rcx, %r9
jae 0x5b5e6c
leaq -0xe(%rax), %r8
cmpq $0xe, %rax
setae %r12b
cmpq %rbp, %r8
setl %r8b
andb %r12b, %r8b
cmpb $0x1, %r8b
jne 0x5b5e6c
movq 0x100(%rsp), %r8
addq %r13, %r8
vpextrb $0x2, %xmm1, (%rax,%r8)
cmpq %rcx, %r14
setae %r8b
cmpq $0xf, %rax
setb %r12b
orb %r8b, %r12b
jne 0x5b5e8f
addq 0x118(%rsp), %r13
vpextrb $0x0, %xmm1, (%rax,%r13)
vpblendvb %ymm10, %ymm12, %ymm6, %ymm1
movq 0x90(%rsp), %r12
vpextrw $0x0, %xmm13, (%r12,%rax,2)
movq 0x50(%rsp), %r8
vpextrw $0x0, %xmm0, (%r8,%rax,2)
vpcmpeqw 0x390(%rsp), %ymm8, %ymm2
vpand %ymm2, %ymm15, %ymm2
vpblendvb %ymm2, %ymm13, %ymm3, %ymm3
vpaddsw %ymm4, %ymm8, %ymm8
incq %rax
cmpq %rax, 0x138(%rsp)
jne 0x5b5912
vmovdqu 0x2b0(%rsp), %ymm5
vpaddsw %ymm5, %ymm9, %ymm5
vmovdqu 0x1b0(%rsp), %ymm0
vpsubsw 0x270(%rsp), %ymm0, %ymm0
vmovdqu %ymm0, 0x1b0(%rsp)
movq 0x128(%rsp), %rax
addq %rax, 0x118(%rsp)
addq %rax, 0x108(%rsp)
addq %rax, 0x110(%rsp)
addq %rax, 0x100(%rsp)
addq %rax, 0xf8(%rsp)
addq %rax, 0xf0(%rsp)
addq %rax, 0xe8(%rsp)
addq %rax, 0xe0(%rsp)
addq %rax, 0xd8(%rsp)
addq %rax, 0xc8(%rsp)
addq %rax, 0xd0(%rsp)
addq %rax, 0xc0(%rsp)
addq %rax, 0xb8(%rsp)
addq %rax, 0xb0(%rsp)
addq %rax, 0xa8(%rsp)
addq %rax, 0xa0(%rsp)
movq 0x130(%rsp), %rax
movq %rax, %r14
cmpq %rcx, %rax
movq 0x3f0(%rsp), %r8
jb 0x5b54af
movl 0xc(%rsp), %edx
vmovdqu 0x210(%rsp), %ymm1
vmovdqu 0x1f0(%rsp), %ymm2
jmp 0x5b5fcd
vmovdqa %ymm12, %ymm3
vmovdqa %ymm12, %ymm1
vmovdqu 0x1d0(%rsp), %ymm2
movl $0x10, %eax
movq 0x120(%rsp), %rbx
movq 0x50(%rsp), %rdi
vextracti128 $0x1, %ymm3, %xmm0
vpextrw $0x7, %xmm0, %ecx
cmpw %dx, %cx
cmovlel %edx, %ecx
movl %ecx, %edx
vperm2i128 $0x28, %ymm3, %ymm3, %ymm0 # ymm0 = zero,zero,ymm3[0,1]
vpalignr $0xe, %ymm0, %ymm3, %ymm3 # ymm3 = ymm0[14,15],ymm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm3[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
decl %eax
jne 0x5b5fdf
vpcmpgtw %ymm2, %ymm12, %ymm0
vpcmpgtw 0x1d0(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
movl 0x9c(%rsp), %ecx
je 0x5b6032
orb $0x40, 0xc(%rbx)
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x0, 0x10(%rsp)
movswl %dx, %eax
movl %eax, (%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x3f0(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5b60a4
movq 0x58(%rsp), %rdi
callq 0x20a60d
jmp 0x5b60a4
callq 0x1f985d
jmp 0x5b60a2
callq 0x1f9837
jmp 0x5b60a2
callq 0x1f9811
jmp 0x5b60a2
callq 0x1f97eb
jmp 0x5b60a2
callq 0x1f97c5
jmp 0x5b60a2
callq 0x1f979f
jmp 0x5b60a2
callq 0x1f9779
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)