// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_diag_avx2_256_32.c
// Function: parasail_nw_trace_diag_avx2_256_32
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;
    int32_t * restrict s1 = NULL;
    int32_t * restrict s2B = NULL;
    int32_t * restrict _H_pr = NULL;
    int32_t * restrict _F_pr = NULL;
    int32_t * restrict s2 = NULL;
    int32_t * restrict H_pr = NULL;
    int32_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;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    int32_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 = 8; /* 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 ? INT32_MIN + open : INT32_MIN - matrix->min) + 1;
    POS_LIMIT = INT32_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInf = _mm256_set1_epi32(NEG_LIMIT);
    vOpen = _mm256_set1_epi32(open);
    vGap  = _mm256_set1_epi32(gap);
    vOne = _mm256_set1_epi32(1);
    vN = _mm256_set1_epi32(N);
    vGapN = _mm256_set1_epi32(gap*N);
    vNegOne = _mm256_set1_epi32(-1);
    vI = _mm256_set_epi32(0,1,2,3,4,5,6,7);
    vJreset = _mm256_set_epi32(0,-1,-2,-3,-4,-5,-6,-7);
    vMax = vNegInf;
    vILimit = _mm256_set1_epi32(s1Len);
    vILimit1 = _mm256_sub_epi32(vILimit, vOne);
    vJLimit = _mm256_set1_epi32(s2Len);
    vJLimit1 = _mm256_sub_epi32(vJLimit, vOne);
    vIBoundary = _mm256_set_epi32(
            -open-0*gap,
            -open-1*gap,
            -open-2*gap,
            -open-3*gap,
            -open-4*gap,
            -open-5*gap,
            -open-6*gap,
            -open-7*gap);
    vTDiag = _mm256_set1_epi32(PARASAIL_DIAG);
    vTIns = _mm256_set1_epi32(PARASAIL_INS);
    vTDel = _mm256_set1_epi32(PARASAIL_DEL);
    vTDiagE = _mm256_set1_epi32(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi32(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi32(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi32(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_32 | PARASAIL_FLAG_LANES_8;

    /* initialize heap variables */
    s2B= parasail_memalign_int32_t(32, s2Len+PAD2);
    _H_pr = parasail_memalign_int32_t(32, s2Len+PAD2);
    _F_pr = parasail_memalign_int32_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_int32_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))];
        vNH = _mm256_srli_si256_rpl(vNH, 4);
        vNH = _mm256_insert_epi32_rpl(vNH, H_pr[-1], 7);
        vWH = _mm256_srli_si256_rpl(vWH, 4);
        vWH = _mm256_insert_epi32_rpl(vWH, -open - i*gap, 7);
        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, 4);
            vNH = _mm256_insert_epi32_rpl(vNH, H_pr[j], 7);
            vF = _mm256_srli_si256_rpl(vF, 4);
            vF = _mm256_insert_epi32_rpl(vF, F_pr[j], 7);
            vF_opn = _mm256_sub_epi32(vNH, vOpen);
            vF_ext = _mm256_sub_epi32(vF, vGap);
            vF = _mm256_max_epi32(vF_opn, vF_ext);
            vE_opn = _mm256_sub_epi32(vWH, vOpen);
            vE_ext = _mm256_sub_epi32(vE, vGap);
            vE = _mm256_max_epi32(vE_opn, vE_ext);
            vMat = _mm256_set_epi32(
                    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]]
                    );
            vNWH = _mm256_add_epi32(vNWH, vMat);
            vWH = _mm256_max_epi32(vNWH, vE);
            vWH = _mm256_max_epi32(vWH, vF);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m256i cond = _mm256_cmpeq_epi32(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_epi32(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm256_max_epi32(vSaturationCheckMax, vWH);
            }
            /* trace table */
            {
                __m256i case1 = _mm256_cmpeq_epi32(vWH, vNWH);
                __m256i case2 = _mm256_cmpeq_epi32(vWH, vF);
                __m256i vT = _mm256_blendv_epi8(
                        _mm256_blendv_epi8(vTIns, vTDel, case2),
                        vTDiag,
                        case1);
                __m256i condE = _mm256_cmpgt_epi32(vE_opn, vE_ext);
                __m256i condF = _mm256_cmpgt_epi32(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-7] = (int32_t)_mm256_extract_epi32_rpl(vWH,0);
            F_pr[j-7] = (int32_t)_mm256_extract_epi32_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_epi32(vI, vILimit1);
                __m256i cond_valid_J = _mm256_cmpeq_epi32(vJ, vJLimit1);
                __m256i cond_all = _mm256_and_si256(cond_valid_I, cond_valid_J);
                vMax = _mm256_blendv_epi8(vMax, vWH, cond_all);
            }
            vJ = _mm256_add_epi32(vJ, vOne);
        }
        vI = _mm256_add_epi32(vI, vN);
        vIBoundary = _mm256_sub_epi32(vIBoundary, vGapN);
    }

    /* max in vMax */
    for (i=0; i<N; ++i) {
        int32_t value;
        value = (int32_t) _mm256_extract_epi32_rpl(vMax, 7);
        if (value > score) {
            score = value;
        }
        vMax = _mm256_slli_si256_rpl(vMax, 4);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi32_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi32(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 $0x318, %rsp            # imm = 0x318
testq %rdx, %rdx
je 0x5b31d8
movl %ecx, %ebp
testl %ecx, %ecx
jle 0x5b31df
movl %r8d, %r13d
testl %r8d, %r8d
js 0x5b31e6
movl %r9d, %r15d
testl %r9d, %r9d
js 0x5b31ed
movq 0x350(%rsp), %r8
testq %r8, %r8
je 0x5b31f4
movq %rdx, %r12
cmpl $0x0, 0x30(%r8)
je 0x5b26a1
movl 0x34(%r8), %esi
jmp 0x5b26b2
testq %rdi, %rdi
je 0x5b31fb
testl %esi, %esi
jle 0x5b3202
movq %rdi, 0x38(%rsp)
vmovd %r15d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x2f0(%rsp)
vpinsrd $0x1, %r13d, %xmm0, %xmm0
vpshufd $0x40, %xmm0, %xmm0     # xmm0 = xmm0[0,0,0,1]
vpmulld 0x7ba12(%rip), %xmm0, %xmm0 # 0x62e0f0
movl 0x20(%r8), %eax
vmovdqa %xmm0, 0xd0(%rsp)
vpextrd $0x3, %xmm0, %edi
movl $0x80000000, %edx       # imm = 0x80000000
movl %r13d, %ecx
orl %edx, %ecx
subl %eax, %edx
movl %edi, 0x4(%rsp)
cmpl %edi, %eax
cmovgl %ecx, %edx
movl %edx, (%rsp)
movl $0x7ffffffe, %r14d      # imm = 0x7FFFFFFE
subl 0x1c(%r8), %r14d
movl $0x20, %edx
movl $0x1, %ecx
movq %rsi, 0x8(%rsp)
movl %esi, %edi
movl %ebp, %esi
vzeroupper
callq 0x20adf4
testq %rax, %rax
je 0x5b3207
movq %rax, %rbx
movl %r13d, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq %r15, 0x20(%rsp)
orl $0x8481001, 0xc(%rax)   # imm = 0x8481001
leal 0xe(%rbp), %r13d
movl $0x20, %edi
movq %r13, %rsi
callq 0x20a62d
movq %rax, %r15
movl $0x20, %edi
movq %r13, %rsi
callq 0x20a62d
movq %rax, %r12
movl $0x20, %edi
movq %r13, %rsi
callq 0x20a62d
testq %r15, %r15
sete %dl
testq %r12, %r12
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x5b3207
movq %rbx, 0x10(%rsp)
movq 0x350(%rsp), %rcx
cmpl $0x0, 0x30(%rcx)
movq %r12, 0x18(%rsp)
movq %rax, 0x40(%rsp)
je 0x5b27c4
xorl %r12d, %r12d
movq 0x20(%rsp), %r13
jmp 0x5b2840
movq 0x8(%rsp), %rbx
leal 0x7(%rbx), %r13d
movslq %r13d, %rsi
movl $0x20, %edi
callq 0x20a62d
testq %rax, %rax
je 0x5b3207
movq %rax, %r12
movl %r13d, %r9d
testl %ebx, %ebx
movq 0x20(%rsp), %r13
movq 0x38(%rsp), %rdi
jle 0x5b281a
movq 0x350(%rsp), %rax
movq 0x10(%rax), %rax
movl %ebx, %ecx
xorl %edx, %edx
movzbl (%rdi,%rdx), %esi
movl (%rax,%rsi,4), %esi
movl %esi, (%r12,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x5b2807
movslq %ebx, %rax
leal 0x1(%rbx), %ecx
cmpl %ecx, %r9d
cmovgl %r9d, %ecx
leaq (%r12,%rax,4), %rdi
movl %ebx, %eax
notl %eax
addl %ecx, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x8(%rsp), %rax
movq %r12, 0x50(%rsp)
leal 0x7(%rbp), %ebx
vmovd %eax, %xmm0
vpinsrd $0x1, %ebp, %xmm0, %xmm0
vpcmpeqd %xmm1, %xmm1, %xmm1
vpaddd %xmm1, %xmm0, %xmm1
movl (%rsp), %eax
incl %eax
movl %eax, (%rsp)
vmovd %eax, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x170(%rsp)
vmovd %r14d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0xf0(%rsp)
movl 0x28(%rsp), %esi
vmovd %esi, %xmm0
vpbroadcastd %xmm0, %ymm2
leal (,%r13,8), %eax
vmovd %eax, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x1d0(%rsp)
vpbroadcastd %xmm1, %ymm0
vmovdqu %ymm0, 0x1b0(%rsp)
vpbroadcastd 0x77416(%rip), %ymm0 # 0x629ce0
vmovdqu %ymm1, 0x110(%rsp)
vmovdqu %ymm0, 0x2b0(%rsp)
vpermd %ymm1, %ymm0, %ymm0
vmovdqu %ymm0, 0x290(%rsp)
movl 0x4(%rsp), %edx
movl %edx, %eax
subl %r13d, %eax
subl %r13d, %edx
subl %r13d, %edx
leal (%r13,%r13,2), %ecx
addl %esi, %ecx
negl %ecx
leal (,%r13,4), %esi
vmovdqu %ymm2, 0x2d0(%rsp)
vpinsrd $0x1, %esi, %xmm2, %xmm0
vpshufd $0x40, %xmm0, %xmm0     # xmm0 = xmm0[0,0,0,1]
vmovdqa 0xd0(%rsp), %xmm3
vpsubd %xmm0, %xmm3, %xmm0
vmovd %ecx, %xmm1
vpbroadcastd %xmm1, %ymm1
vpblendd $0x10, %ymm1, %ymm0, %ymm1 # ymm1 = ymm0[0,1,2,3],ymm1[4],ymm0[5,6,7]
vmovd %edx, %xmm2
vpbroadcastd %xmm2, %ymm2
vpblendd $0x20, %ymm2, %ymm1, %ymm1 # ymm1 = ymm1[0,1,2,3,4],ymm2[5],ymm1[6,7]
vmovd %eax, %xmm2
vpbroadcastd %xmm2, %ymm2
vpblendd $0x40, %ymm2, %ymm1, %ymm1 # ymm1 = ymm1[0,1,2,3,4,5],ymm2[6],ymm1[7]
vinserti128 $0x1, %xmm3, %ymm0, %ymm0
vpblendd $0x88, %ymm0, %ymm1, %ymm0 # ymm0 = ymm1[0,1,2],ymm0[3],ymm1[4,5,6],ymm0[7]
vmovdqu %ymm0, 0xd0(%rsp)
movq 0x350(%rsp), %rax
movq 0x10(%rax), %rax
movl %ebp, %r14d
xorl %ecx, %ecx
movq 0x30(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0x1c(%r15,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x5b2983
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, 0xc(%r15)
vmovdqu %xmm0, (%r15)
leal 0x1(%rbp), %eax
cmpl %eax, %ebx
cmovgl %ebx, %eax
leaq (%r15,%r14,4), %rdi
addq $0x1c, %rdi
movl %ebp, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movl 0x4(%rsp), %eax
movl (%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rdi
movl %eax, 0x1c(%rcx,%r12,4)
movl %edx, 0x1c(%rdi,%r12,4)
incq %r12
subl %r13d, %eax
cmpq %r12, %r14
jne 0x5b29e2
xorl %eax, %eax
movl %edx, (%rcx,%rax,4)
movl %edx, (%rdi,%rax,4)
incq %rax
cmpq $0x7, %rax
jne 0x5b29f9
leaq 0x7(%r14), %rax
movq 0x350(%rsp), %r12
vmovdqu 0x170(%rsp), %ymm11
movq 0x8(%rsp), %rsi
movl %edx, (%rcx,%rax,4)
movl %edx, (%rdi,%rax,4)
incq %rax
incl %ebp
cmpl %ebp, %ebx
jg 0x5b2a22
movl $0x0, 0x18(%rcx)
testl %esi, %esi
jle 0x5b3133
vextracti128 $0x1, %ymm11, %xmm0
cmpl $0x2, %ebx
movl $0x1, %eax
cmovgel %ebx, %eax
movq %rax, 0xa8(%rsp)
vpalignr $0x4, %ymm11, %ymm0, %ymm0 # ymm0 = ymm11[4,5,6,7,8,9,10,11,12,13,14,15],ymm0[0,1,2,3],ymm11[20,21,22,23,24,25,26,27,28,29,30,31],ymm0[16,17,18,19]
vmovdqu %ymm0, 0x190(%rsp)
movl %esi, %ecx
vmovups 0x110(%rsp), %ymm0
vmovss %xmm0, 0x4c(%rsp)
leaq (,%r14,8), %rax
movq %rax, 0x98(%rsp)
subq %r14, %rax
addq $-0x7, %rax
movq %rax, 0x90(%rsp)
leaq -0x1(%r14), %rax
movq %rax, 0x88(%rsp)
leaq (%r14,%r14,2), %rax
leaq -0x6(%rax,%rax), %rax
movq %rax, 0x78(%rsp)
leaq -0x5(%r14,%r14,4), %rax
movq %rax, 0x70(%rsp)
leaq -0x4(,%r14,4), %rax
movq %rax, 0x68(%rsp)
leaq -0x3(%r14,%r14,2), %rax
movq %rax, 0x60(%rsp)
leaq -0x2(%r14,%r14), %rax
movq %rax, 0x58(%rsp)
vpmovsxbd 0x79430(%rip), %ymm4 # 0x62bf16
movq $0x0, 0x80(%rsp)
vpcmpeqd %ymm12, %ymm12, %ymm12
vbroadcastss 0x7b0c0(%rip), %ymm0 # 0x62dbc0
vmovups %ymm0, 0x270(%rsp)
vbroadcastss 0x7b1ce(%rip), %ymm9 # 0x62dce0
vbroadcastss 0x7b339(%rip), %ymm0 # 0x62de54
vmovups %ymm0, 0x250(%rsp)
vbroadcastss 0x7b4b3(%rip), %ymm0 # 0x62dfe0
vmovups %ymm0, 0x230(%rsp)
vbroadcastss 0x7d1ed(%rip), %ymm0 # 0x62fd2c
vmovups %ymm0, 0x210(%rsp)
xorl %ebp, %ebp
vmovdqu 0xf0(%rsp), %ymm0
vmovdqu %ymm0, 0x130(%rsp)
vmovdqu %ymm11, 0x150(%rsp)
vmovdqa %ymm11, %ymm3
movq %rbp, %rsi
orq $0x3, %rsi
cmpl $0x0, 0x30(%r12)
movq %rsi, 0x8(%rsp)
je 0x5b2be4
movq %rbp, %rdx
orq $0x1, %rdx
cmpq %rcx, %rdx
movl 0x4c(%rsp), %r11d
cmovael %r11d, %edx
movq %rbp, %rax
orq $0x2, %rax
cmpq %rcx, %rax
cmovael %r11d, %eax
cmpq %rcx, %rsi
movl %esi, %edi
cmovael %r11d, %edi
movq %rbp, %rsi
orq $0x4, %rsi
cmpq %rcx, %rsi
cmovael %r11d, %esi
movq %rbp, %r8
orq $0x5, %r8
cmpq %rcx, %r8
cmovael %r11d, %r8d
movq %rbp, %r9
orq $0x6, %r9
cmpq %rcx, %r9
cmovael %r11d, %r9d
movq %rbp, %r10
orq $0x7, %r10
cmpq %rcx, %r10
cmovael %r11d, %r10d
movl %ebp, %r11d
jmp 0x5b2c0f
movq 0x50(%rsp), %r10
movl (%r10,%rbp,4), %r11d
movl 0x4(%r10,%rbp,4), %edx
movl 0x8(%r10,%rbp,4), %eax
movl (%r10,%rsi,4), %edi
movl 0x10(%r10,%rbp,4), %esi
movl 0x14(%r10,%rbp,4), %r8d
movl 0x18(%r10,%rbp,4), %r9d
movl 0x1c(%r10,%rbp,4), %r10d
movq 0x8(%r12), %rbx
movl 0x18(%r12), %r12d
imull %r12d, %r8d
movslq %r8d, %r8
leaq (%rbx,%r8,4), %r8
movq %r8, 0x38(%rsp)
imull %r12d, %edi
movslq %edi, %rdi
leaq (%rbx,%rdi,4), %rdi
movq %rdi, 0x30(%rsp)
imull %r12d, %edx
movslq %edx, %rdx
leaq (%rbx,%rdx,4), %rdx
movq %rdx, 0x28(%rsp)
imull %r12d, %r11d
movslq %r11d, %rdx
leaq (%rbx,%rdx,4), %rdx
movq %rdx, 0xc8(%rsp)
imull %r12d, %eax
cltq
leaq (%rbx,%rax,4), %rax
movq %rax, 0xc0(%rsp)
imull %r12d, %esi
movslq %esi, %rax
leaq (%rbx,%rax,4), %rax
movq %rax, 0xb8(%rsp)
imull %r12d, %r9d
movslq %r9d, %rax
leaq (%rbx,%rax,4), %rax
movq %rax, 0xb0(%rsp)
imull %r12d, %r10d
movslq %r10d, %rax
leaq (%rbx,%rax,4), %rax
leaq 0x8(%rbp), %rdx
movq %rdx, 0xa0(%rsp)
imull %r13d, %edx
movl 0x4(%rsp), %edi
movl %edi, %r9d
subl %edx, %r9d
movq 0x18(%rsp), %r8
vpbroadcastd 0x18(%r8), %ymm0
movl %r9d, 0x18(%r8)
movl %ebp, %edx
imull %r13d, %edx
movl %edi, %r9d
subl %edx, %r9d
vmovd %r9d, %xmm1
vpbroadcastd %xmm1, %ymm1
vmovdqu 0x190(%rsp), %ymm2
vpblendd $0x80, %ymm1, %ymm2, %ymm13 # ymm13 = ymm2[0,1,2,3,4,5,6],ymm1[7]
vpblendd $0x80, %ymm0, %ymm2, %ymm14 # ymm14 = ymm2[0,1,2,3,4,5,6],ymm0[7]
movq %rbp, %r9
orq $0x1, %r9
movq %rbp, %r10
orq $0x2, %r10
movq %rbp, %r13
orq $0x4, %r13
movq %rbp, %r12
orq $0x5, %r12
movq %rbp, %r11
orq $0x6, %r11
orq $0x7, %rbp
vmovdqu %ymm4, 0x1f0(%rsp)
vpcmpeqd 0x1b0(%rsp), %ymm4, %ymm15
xorl %edx, %edx
vpmovsxbd 0x791ef(%rip), %ymm5 # 0x62bf26
vmovdqa %ymm11, %ymm1
vmovdqa %ymm11, %ymm0
movq 0x40(%rsp), %rdi
movslq 0x10(%r15,%rdx,4), %rbx
movq 0x30(%rsp), %rsi
vmovd (%rsi,%rbx,4), %xmm2
movslq 0x14(%r15,%rdx,4), %rbx
movq 0xc0(%rsp), %rsi
vpinsrd $0x1, (%rsi,%rbx,4), %xmm2, %xmm2
movslq 0x18(%r15,%rdx,4), %rbx
movq 0x28(%rsp), %rsi
vpinsrd $0x2, (%rsi,%rbx,4), %xmm2, %xmm2
movslq 0x1c(%r15,%rdx,4), %rbx
movq 0xc8(%rsp), %rsi
vpinsrd $0x3, (%rsi,%rbx,4), %xmm2, %xmm2
movslq (%r15,%rdx,4), %rbx
vmovd (%rax,%rbx,4), %xmm4
movslq 0x4(%r15,%rdx,4), %rbx
movq 0xb0(%rsp), %rsi
vpinsrd $0x1, (%rsi,%rbx,4), %xmm4, %xmm4
movslq 0x8(%r15,%rdx,4), %rbx
movq 0x38(%rsp), %rsi
vpinsrd $0x2, (%rsi,%rbx,4), %xmm4, %xmm4
movslq 0xc(%r15,%rdx,4), %rbx
movq 0xb8(%rsp), %rsi
vpinsrd $0x3, (%rsi,%rbx,4), %xmm4, %xmm4
vpmovsxbd 0x7b369(%rip), %ymm10 # 0x62e140
vpermd %ymm13, %ymm10, %ymm7
vpbroadcastd 0x1c(%r8,%rdx,4), %ymm8
vinserti128 $0x1, %xmm2, %ymm4, %ymm2
vpaddd %ymm2, %ymm14, %ymm6
vpblendd $0x80, %ymm8, %ymm7, %ymm14 # ymm14 = ymm7[0,1,2,3,4,5,6],ymm8[7]
vpermd %ymm1, %ymm10, %ymm1
vpbroadcastd 0x1c(%rdi,%rdx,4), %ymm2
vpblendd $0x80, %ymm2, %ymm1, %ymm1 # ymm1 = ymm1[0,1,2,3,4,5,6],ymm2[7]
vmovdqu 0x2d0(%rsp), %ymm8
vpsubd %ymm8, %ymm14, %ymm2
vmovdqu 0x2f0(%rsp), %ymm4
vpsubd %ymm4, %ymm1, %ymm7
vpmaxsd %ymm7, %ymm2, %ymm1
vpsubd %ymm8, %ymm13, %ymm8
vpsubd %ymm4, %ymm0, %ymm10
vpmaxsd %ymm10, %ymm8, %ymm4
vpmaxsd %ymm1, %ymm4, %ymm0
vpmaxsd %ymm0, %ymm6, %ymm13
vpcmpeqd %ymm5, %ymm12, %ymm0
vblendvps %ymm0, 0xd0(%rsp), %ymm13, %ymm13
vblendvps %ymm0, %ymm11, %ymm1, %ymm1
cmpq $0x8, %rdx
jb 0x5b2e86
vmovdqu 0x130(%rsp), %ymm11
vpminsd %ymm13, %ymm11, %ymm11
vmovdqu %ymm11, 0x130(%rsp)
vmovdqu 0x150(%rsp), %ymm11
vpmaxsd %ymm13, %ymm11, %ymm11
vmovdqu %ymm11, 0x150(%rsp)
movq 0x10(%rsp), %rdi
vpcmpeqd %ymm6, %ymm13, %ymm6
vpcmpeqd %ymm1, %ymm13, %ymm11
vmovdqu 0x2b0(%rsp), %ymm12
vpsubd %ymm11, %ymm12, %ymm11
vblendvps %ymm6, 0x270(%rsp), %ymm11, %ymm6
vpcmpgtd %ymm10, %ymm8, %ymm8
vpcmpgtd %ymm7, %ymm2, %ymm2
vmovups 0x210(%rsp), %ymm7
vblendvps %ymm2, 0x230(%rsp), %ymm7, %ymm2
vmovups 0x250(%rsp), %ymm7
vblendvps %ymm8, %ymm9, %ymm7, %ymm7
vorps %ymm7, %ymm2, %ymm2
vorps %ymm6, %ymm2, %ymm2
movq 0x10(%rdi), %rbx
movq (%rbx), %rbx
vextractf128 $0x1, %ymm2, %xmm6
cmpq %r14, %rdx
jae 0x5b2f05
movq 0x80(%rsp), %rdi
leaq (%rbx,%rdi), %r8
vpextrb $0xc, %xmm6, (%rdx,%r8)
cmpq %rcx, %r9
setae %r8b
leaq -0x1(%rdx), %rdi
cmpq %r14, %rdi
setae %dil
orb %r8b, %dil
jne 0x5b2f2e
movq 0x88(%rsp), %rdi
addq %rbx, %rdi
vpextrb $0x8, %xmm6, (%rdx,%rdi)
cmpq %rcx, %r10
vmovups 0x170(%rsp), %ymm11
vpcmpeqd %ymm12, %ymm12, %ymm12
jae 0x5b2f6c
leaq -0x2(%rdx), %rdi
cmpq $0x2, %rdx
setae %r8b
cmpq %r14, %rdi
setl %dil
andb %r8b, %dil
cmpb $0x1, %dil
jne 0x5b2f6c
movq 0x58(%rsp), %rdi
addq %rbx, %rdi
vpextrb $0x4, %xmm6, (%rdx,%rdi)
cmpq %rcx, 0x8(%rsp)
jae 0x5b2f9e
leaq -0x3(%rdx), %rdi
cmpq $0x3, %rdx
setae %r8b
cmpq %r14, %rdi
setl %dil
andb %r8b, %dil
cmpb $0x1, %dil
jne 0x5b2f9e
movq 0x60(%rsp), %rdi
addq %rbx, %rdi
vpextrb $0x0, %xmm6, (%rdx,%rdi)
cmpq %rcx, %r13
jae 0x5b2fce
leaq -0x4(%rdx), %rdi
cmpq $0x4, %rdx
setae %r8b
cmpq %r14, %rdi
setl %dil
andb %r8b, %dil
cmpb $0x1, %dil
jne 0x5b2fce
movq 0x68(%rsp), %rdi
addq %rbx, %rdi
vpextrb $0xc, %xmm2, (%rdx,%rdi)
cmpq %rcx, %r12
jae 0x5b2ffe
leaq -0x5(%rdx), %rdi
cmpq $0x5, %rdx
setae %r8b
cmpq %r14, %rdi
setl %dil
andb %r8b, %dil
cmpb $0x1, %dil
jne 0x5b2ffe
movq 0x70(%rsp), %rdi
addq %rbx, %rdi
vpextrb $0x8, %xmm2, (%rdx,%rdi)
cmpq %rcx, %r11
jae 0x5b302e
leaq -0x6(%rdx), %rdi
cmpq $0x6, %rdx
setae %r8b
cmpq %r14, %rdi
setl %dil
andb %r8b, %dil
cmpb $0x1, %dil
jne 0x5b302e
movq 0x78(%rsp), %rdi
addq %rbx, %rdi
vpextrb $0x4, %xmm2, (%rdx,%rdi)
cmpq %rcx, %rbp
setae %dil
cmpq $0x7, %rdx
setb %r8b
orb %dil, %r8b
jne 0x5b3051
addq 0x90(%rsp), %rbx
vpextrb $0x0, %xmm2, (%rdx,%rbx)
vblendvps %ymm0, %ymm11, %ymm4, %ymm0
movq 0x18(%rsp), %r8
vmovd %xmm13, (%r8,%rdx,4)
movq 0x40(%rsp), %rdi
vmovd %xmm1, (%rdi,%rdx,4)
vpcmpeqd 0x290(%rsp), %ymm5, %ymm2
vpand %ymm2, %ymm15, %ymm2
vblendvps %ymm2, %ymm13, %ymm3, %ymm3
vpsubd %ymm12, %ymm5, %ymm5
incq %rdx
cmpq %rdx, 0xa8(%rsp)
jne 0x5b2d44
vmovdqu 0x1f0(%rsp), %ymm4
vpaddd %ymm4, %ymm9, %ymm4
vmovdqu 0xd0(%rsp), %ymm0
vpsubd 0x1d0(%rsp), %ymm0, %ymm0
vmovdqu %ymm0, 0xd0(%rsp)
movq 0x98(%rsp), %rax
addq %rax, 0x90(%rsp)
addq %rax, 0x80(%rsp)
addq %rax, 0x88(%rsp)
addq %rax, 0x78(%rsp)
addq %rax, 0x70(%rsp)
addq %rax, 0x68(%rsp)
addq %rax, 0x60(%rsp)
addq %rax, 0x58(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, %rbp
cmpq %rcx, %rax
movq 0x350(%rsp), %r12
movq 0x20(%rsp), %r13
jb 0x5b2b69
movq 0x10(%rsp), %rbx
movl (%rsp), %edx
vmovdqu 0x150(%rsp), %ymm1
vmovdqu 0x130(%rsp), %ymm2
jmp 0x5b3149
vmovdqa %ymm11, %ymm3
vmovdqa %ymm11, %ymm1
vmovdqu 0xf0(%rsp), %ymm2
movq 0x10(%rsp), %rbx
movl $0x8, %eax
vextracti128 $0x1, %ymm3, %xmm0
vpextrd $0x3, %xmm0, %ecx
cmpl %edx, %ecx
cmovgl %ecx, %edx
vperm2i128 $0x28, %ymm3, %ymm3, %ymm0 # ymm0 = zero,zero,ymm3[0,1]
vpalignr $0xc, %ymm0, %ymm3, %ymm3 # ymm3 = ymm0[12,13,14,15],ymm3[0,1,2,3,4,5,6,7,8,9,10,11],ymm0[28,29,30,31],ymm3[16,17,18,19,20,21,22,23,24,25,26,27]
decl %eax
jne 0x5b314e
vpcmpgtd %ymm2, %ymm11, %ymm0
vpcmpgtd 0xf0(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestps %ymm0, %ymm0
je 0x5b319a
orb $0x40, 0xc(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x110(%rsp)
xorl %edx, %edx
movl %edx, (%rbx)
vmovdqu 0x110(%rsp), %ymm0
vmovq %xmm0, 0x4(%rbx)
vzeroupper
callq 0x20a60d
movq 0x18(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r12)
jne 0x5b3209
movq 0x50(%rsp), %rdi
callq 0x20a60d
jmp 0x5b3209
callq 0x1f953f
jmp 0x5b3207
callq 0x1f9519
jmp 0x5b3207
callq 0x1f94f3
jmp 0x5b3207
callq 0x1f94cd
jmp 0x5b3207
callq 0x1f94a7
jmp 0x5b3207
callq 0x1f9481
jmp 0x5b3207
callq 0x1f945b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop