// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_diag_avx2_256_32.c
// Function: parasail_sw_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 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 = 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 = 0;
    end_ref = 0;
    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);
    vNegInf0 = _mm256_srli_si256_rpl(vNegInf, 4); /* shift in a 0 */
    vOpen = _mm256_set1_epi32(open);
    vGap  = _mm256_set1_epi32(gap);
    vZero = _mm256_set1_epi32(0);
    vOne = _mm256_set1_epi32(1);
    vN = _mm256_set1_epi32(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);
    vMaxH = vNegInf;
    vEndI = vNegInf;
    vEndJ = vNegInf;
    vILimit = _mm256_set1_epi32(s1Len);
    vJLimit = _mm256_set1_epi32(s2Len);
    vTDiag = _mm256_set1_epi32(PARASAIL_DIAG);
    vTIns = _mm256_set1_epi32(PARASAIL_INS);
    vTDel = _mm256_set1_epi32(PARASAIL_DEL);
    vTZero = _mm256_set1_epi32(PARASAIL_ZERO);
    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_SW | 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] = 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))];
        __m256i vIltLimit = _mm256_cmplt_epi32_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, 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);
            vNWH = _mm256_max_epi32(vNWH, vZero);
            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_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_epi32(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm256_max_epi32(vSaturationCheckMax, vWH);
            }
            /* trace table */
            {
                __m256i cond_zero = _mm256_cmpeq_epi32(vWH, vZero);
                __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),
                        _mm256_blendv_epi8(vTDiag, vTZero, cond_zero),
                        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
             * max values within the i,j bounds */
            {
                __m256i cond_valid_J = _mm256_and_si256(
                        _mm256_cmpgt_epi32(vJ, vNegOne),
                        _mm256_cmplt_epi32_rpl(vJ, vJLimit));
                __m256i cond_valid_IJ = _mm256_and_si256(cond_valid_J, vIltLimit);
                __m256i cond_eq = _mm256_cmpeq_epi32(vWH, vMaxH);
                __m256i cond_max = _mm256_cmpgt_epi32(vWH, vMaxH);
                __m256i cond_all = _mm256_and_si256(cond_max, cond_valid_IJ);
                __m256i cond_Jlt = _mm256_cmplt_epi32_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_add_epi32(vJ, vOne);
        }
        vI = _mm256_add_epi32(vI, vN);
    }

    /* alignment ending position */
    {
        int32_t *t = (int32_t*)&vMaxH;
        int32_t *i = (int32_t*)&vEndI;
        int32_t *j = (int32_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_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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x3c0, %rsp            # imm = 0x3C0
testq %rdx, %rdx
je 0x5b4de7
movl %ecx, %r13d
testl %ecx, %ecx
jle 0x5b4dee
testl %r8d, %r8d
js 0x5b4df5
movl %r9d, %r12d
testl %r9d, %r9d
js 0x5b4dfc
movl %esi, %ebx
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0x5b4e03
movq %rdx, %r14
cmpl $0x0, 0x30(%rsi)
je 0x5b4296
movl 0x34(%rsi), %ebx
jmp 0x5b42a7
testq %rdi, %rdi
je 0x5b4e0a
testl %ebx, %ebx
jle 0x5b4e11
movq %rdi, 0x100(%rsp)
movl %r8d, %eax
negl %eax
movl 0x20(%rsi), %ecx
movl $0x80000000, %edi       # imm = 0x80000000
movl %r8d, 0x200(%rsp)
movl %r8d, %edx
orl %edi, %edx
subl %ecx, %edi
cmpl %eax, %ecx
cmovgl %edx, %edi
incl %edi
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rsi), %eax
movl %eax, 0x1e0(%rsp)
movl %edi, 0x4(%rsp)
vmovd %edi, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqa %ymm0, 0x220(%rsp)
vmovdqa %ymm0, 0x140(%rsp)
vmovdqa %ymm0, 0x1c0(%rsp)
vmovdqa %ymm0, 0x120(%rsp)
movl $0x20, %edx
movl $0x1, %ecx
movl %ebx, %edi
movl %r13d, %esi
vzeroupper
callq 0x20adf4
testq %rax, %rax
je 0x5b4e16
movq %rax, %r15
movl %r12d, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x80(%rsp)
orl $0x8481004, 0xc(%rax)   # imm = 0x8481004
leal 0xe(%r13), %r12d
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a62d
movq %rax, %r14
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a62d
movq %rax, %rbx
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a62d
testq %r14, %r14
sete %dl
testq %rbx, %rbx
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x5b4e16
movq %r15, 0x18(%rsp)
movq 0x10(%rbp), %r12
cmpl $0x0, 0x30(%r12)
movq %rbx, 0x8(%rsp)
movq %rax, 0x30(%rsp)
je 0x5b43c9
movq $0x0, 0x10(%rsp)
movq 0x80(%rsp), %rbx
jmp 0x5b443e
movq 0x80(%rsp), %rbx
leal 0x7(%rbx), %r15d
movslq %r15d, %rsi
movl $0x20, %edi
callq 0x20a62d
testq %rax, %rax
je 0x5b4e16
testl %ebx, %ebx
movq 0x100(%rsp), %r8
jle 0x5b4413
movq 0x10(%r12), %rdi
movl %ebx, %ecx
xorl %edx, %edx
movzbl (%r8,%rdx), %esi
movl (%rdi,%rsi,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x5b4400
movslq %ebx, %rsi
leal 0x1(%rbx), %ecx
cmpl %ecx, %r15d
cmovgl %r15d, %ecx
movq %rax, 0x10(%rsp)
leaq (%rax,%rsi,4), %rdi
movl %ebx, %eax
notl %eax
addl %ecx, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x19e090
leal 0x7(%r13), %r15d
vmovss 0x1e0(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovaps %ymm0, 0x160(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vblendps $0x7f, 0x1c0(%rsp), %ymm0, %ymm0 # ymm0 = mem[0,1,2,3,4,5,6],ymm0[7]
vmovaps %ymm0, 0x260(%rsp)
vmovss 0x200(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovaps %ymm0, 0x360(%rsp)
vmovss 0x20(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovaps %ymm0, 0x340(%rsp)
vmovd %ebx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqa %ymm0, 0x240(%rsp)
vmovd %r13d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqa %ymm0, 0x320(%rsp)
movq 0x10(%r12), %rax
movl %r13d, %ebx
xorl %ecx, %ecx
movq 0x28(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0x1c(%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rbx
jne 0x5b44d0
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, 0xc(%r14)
vmovdqu %xmm0, (%r14)
leal 0x1(%r13), %eax
cmpl %eax, %r15d
cmovgl %r15d, %eax
leaq (%r14,%rbx,4), %rdi
addq $0x1c, %rdi
movl %r13d, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movl 0x4(%rsp), %r8d
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rdi
movl $0x0, 0x1c(%rcx,%r12,4)
movl %r8d, 0x1c(%rdi,%r12,4)
incq %r12
cmpq %r12, %rbx
jne 0x5b4531
xorl %eax, %eax
movl %r8d, (%rcx,%rax,4)
movl %r8d, (%rdi,%rax,4)
incq %rax
cmpq $0x7, %rax
jne 0x5b4549
leaq 0x7(%rbx), %rax
movq 0x10(%rbp), %r12
vmovdqa 0x1c0(%rsp), %ymm14
movl %r8d, (%rcx,%rax,4)
movl %r8d, (%rdi,%rax,4)
incq %rax
incl %r13d
cmpl %r13d, %r15d
jg 0x5b456b
movq 0x80(%rsp), %rcx
testl %ecx, %ecx
jle 0x5b4d1a
leal -0x1(%rcx), %eax
movl %eax, 0x3c(%rsp)
cmpl $0x2, %r15d
movl $0x1, %eax
cmovgel %r15d, %eax
movq %rax, 0xc0(%rsp)
movl %ecx, %edx
vmovaps 0x220(%rsp), %ymm3
vmovdqa 0x120(%rsp), %ymm2
leaq (,%rbx,8), %rax
movq %rax, 0xb0(%rsp)
subq %rbx, %rax
addq $-0x7, %rax
movq %rax, 0x78(%rsp)
leaq -0x1(%rbx), %rax
movq %rax, 0x70(%rsp)
leaq (%rbx,%rbx,2), %rax
leaq -0x6(%rax,%rax), %rax
movq %rax, 0x60(%rsp)
leaq -0x5(%rbx,%rbx,4), %rax
movq %rax, 0x58(%rsp)
leaq -0x4(,%rbx,4), %rax
movq %rax, 0x50(%rsp)
leaq -0x3(%rbx,%rbx,2), %rax
movq %rax, 0x48(%rsp)
leaq -0x2(%rbx,%rbx), %rax
movq %rax, 0x40(%rsp)
vmovaps 0x796dc(%rip), %ymm0    # 0x62dd00
vmovaps %ymm0, 0x80(%rsp)
movq $0x0, 0x68(%rsp)
vbroadcastss 0x756a1(%rip), %ymm0 # 0x629ce0
vmovaps %ymm0, 0x300(%rsp)
vbroadcastss 0x7956f(%rip), %ymm0 # 0x62dbc0
vmovaps %ymm0, 0x2e0(%rsp)
vbroadcastss 0x7967d(%rip), %ymm0 # 0x62dce0
vmovaps %ymm0, 0x100(%rsp)
vbroadcastss 0x797df(%rip), %ymm0 # 0x62de54
vmovaps %ymm0, 0x2c0(%rsp)
vbroadcastss 0x79959(%rip), %ymm0 # 0x62dfe0
vmovaps %ymm0, 0x2a0(%rsp)
vbroadcastss 0x7b693(%rip), %ymm0 # 0x62fd2c
vmovaps %ymm0, 0x280(%rsp)
xorl %r13d, %r13d
vmovdqa 0x160(%rsp), %ymm0
vmovdqa %ymm0, 0x180(%rsp)
vmovdqa %ymm14, 0x1a0(%rsp)
vmovdqa %ymm14, %ymm9
movq %r13, %rsi
orq $0x3, %rsi
cmpl $0x0, 0x30(%r12)
movq %rsi, 0x28(%rsp)
je 0x5b4741
movq %r13, %rcx
orq $0x1, %rcx
cmpq %rdx, %rcx
movl 0x3c(%rsp), %r11d
cmovael %r11d, %ecx
movq %r13, %rax
orq $0x2, %rax
cmpq %rdx, %rax
cmovael %r11d, %eax
cmpq %rdx, %rsi
movl %esi, %r9d
cmovael %r11d, %r9d
movq %r13, %rsi
orq $0x4, %rsi
cmpq %rdx, %rsi
cmovael %r11d, %esi
movq %r13, %r10
orq $0x5, %r10
cmpq %rdx, %r10
cmovael %r11d, %r10d
movq %r13, %rdi
orq $0x6, %rdi
cmpq %rdx, %rdi
cmovael %r11d, %edi
movq %r13, %r8
orq $0x7, %r8
cmpq %rdx, %r8
cmovael %r11d, %r8d
movl %r13d, %r11d
jmp 0x5b476c
movq 0x10(%rsp), %r8
movl (%r8,%r13,4), %r11d
movl 0x4(%r8,%r13,4), %ecx
movl 0x8(%r8,%r13,4), %eax
movl (%r8,%rsi,4), %r9d
movl 0x10(%r8,%r13,4), %esi
movl 0x14(%r8,%r13,4), %r10d
movl 0x18(%r8,%r13,4), %edi
movl 0x1c(%r8,%r13,4), %r8d
movq 0x8(%r12), %r15
movl 0x18(%r12), %r12d
imull %r12d, %r10d
movslq %r10d, %r10
leaq (%r15,%r10,4), %r10
movq %r10, 0x20(%rsp)
imull %r12d, %r9d
movslq %r9d, %r9
leaq (%r15,%r9,4), %r9
movq %r9, 0xf8(%rsp)
imull %r12d, %ecx
movslq %ecx, %rcx
leaq (%r15,%rcx,4), %rcx
movq %rcx, 0xf0(%rsp)
imull %r12d, %r11d
movslq %r11d, %rcx
leaq (%r15,%rcx,4), %rcx
movq %rcx, 0xe8(%rsp)
imull %r12d, %eax
cltq
leaq (%r15,%rax,4), %rax
movq %rax, 0xe0(%rsp)
imull %r12d, %esi
movslq %esi, %rax
leaq (%r15,%rax,4), %rax
movq %rax, 0xd8(%rsp)
imull %r12d, %edi
movslq %edi, %rax
leaq (%r15,%rax,4), %rax
movq %rax, 0xd0(%rsp)
imull %r12d, %r8d
movslq %r8d, %rax
leaq (%r15,%rax,4), %rax
movq %rax, 0xc8(%rsp)
movq %r13, %r15
orq $0x1, %r15
movq %r13, %r12
orq $0x2, %r12
movq %r13, %r9
orq $0x4, %r9
movq %r13, %r11
orq $0x5, %r11
movq %r13, %rax
orq $0x6, %r13
movq %rax, 0xb8(%rsp)
orq $0x7, %rax
vmovdqa 0x240(%rsp), %ymm0
vpcmpgtd 0x80(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x380(%rsp)
vpmovsxbd 0x776c9(%rip), %ymm0 # 0x62bf26
vmovdqa %ymm14, %ymm7
vmovdqa %ymm14, %ymm8
vmovdqa 0x260(%rsp), %ymm6
vmovdqa %ymm6, %ymm1
xorl %r8d, %r8d
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdi
vmovdqa %ymm9, 0x1e0(%rsp)
vmovaps %ymm3, 0x200(%rsp)
vmovdqa %ymm2, %ymm3
movslq 0x10(%r14,%r8,4), %r10
vpcmpeqd %ymm2, %ymm2, %ymm2
movq 0xf8(%rsp), %rcx
vmovd (%rcx,%r10,4), %xmm4
movslq 0x14(%r14,%r8,4), %r10
movq 0xe0(%rsp), %rcx
vpinsrd $0x1, (%rcx,%r10,4), %xmm4, %xmm4
movslq 0x18(%r14,%r8,4), %r10
movq 0xf0(%rsp), %rcx
vpinsrd $0x2, (%rcx,%r10,4), %xmm4, %xmm4
movslq 0x1c(%r14,%r8,4), %r10
movq 0xe8(%rsp), %rcx
vpinsrd $0x3, (%rcx,%r10,4), %xmm4, %xmm4
movslq (%r14,%r8,4), %r10
movq 0xc8(%rsp), %rcx
vmovd (%rcx,%r10,4), %xmm9
movslq 0x4(%r14,%r8,4), %r10
movq 0xd0(%rsp), %rcx
vpinsrd $0x1, (%rcx,%r10,4), %xmm9, %xmm9
movslq 0x8(%r14,%r8,4), %r10
movq 0x20(%rsp), %rcx
vpinsrd $0x2, (%rcx,%r10,4), %xmm9, %xmm9
movslq 0xc(%r14,%r8,4), %r10
movq 0xd8(%rsp), %rcx
vpinsrd $0x3, (%rcx,%r10,4), %xmm9, %xmm9
vpmovsxbd 0x79803(%rip), %ymm5 # 0x62e140
vpermd %ymm1, %ymm5, %ymm10
vpbroadcastd 0x1c(%rsi,%r8,4), %ymm11
vinserti128 $0x1, %xmm4, %ymm9, %ymm4
vpaddd %ymm6, %ymm4, %ymm4
vpblendd $0x80, %ymm11, %ymm10, %ymm6 # ymm6 = ymm10[0,1,2,3,4,5,6],ymm11[7]
vpermd %ymm7, %ymm5, %ymm7
vpbroadcastd 0x1c(%rdi,%r8,4), %ymm9
vpblendd $0x80, %ymm9, %ymm7, %ymm7 # ymm7 = ymm7[0,1,2,3,4,5,6],ymm9[7]
vmovdqa 0x360(%rsp), %ymm5
vpsubd %ymm5, %ymm6, %ymm12
vmovdqa 0x340(%rsp), %ymm9
vpsubd %ymm9, %ymm7, %ymm13
vpmaxsd %ymm13, %ymm12, %ymm7
vpsubd %ymm5, %ymm1, %ymm15
vpsubd %ymm9, %ymm8, %ymm11
vpmaxsd %ymm11, %ymm15, %ymm8
vpmaxsd 0x7927e(%rip), %ymm4, %ymm4 # 0x62dc20
vpmaxsd %ymm7, %ymm8, %ymm1
vpmaxsd %ymm1, %ymm4, %ymm10
vpcmpeqd %ymm2, %ymm0, %ymm9
vpandn %ymm10, %ymm9, %ymm1
vblendvps %ymm9, %ymm14, %ymm7, %ymm7
cmpq $0x8, %r8
jb 0x5b49ef
vmovdqa 0x180(%rsp), %ymm5
vpminsd %ymm1, %ymm5, %ymm5
vmovdqa %ymm5, 0x180(%rsp)
vmovdqa 0x1a0(%rsp), %ymm5
vpmaxsd %ymm1, %ymm5, %ymm5
vmovdqa %ymm5, 0x1a0(%rsp)
vpcmpeqd %ymm1, %ymm4, %ymm4
vpcmpeqd %ymm1, %ymm7, %ymm5
vmovdqa 0x300(%rsp), %ymm2
vpsubd %ymm5, %ymm2, %ymm5
vpcmpgtd 0x79214(%rip), %ymm1, %ymm14 # 0x62dc20
vpand 0x2e0(%rsp), %ymm14, %ymm14
vblendvps %ymm4, %ymm14, %ymm5, %ymm4
vpcmpgtd %ymm11, %ymm15, %ymm5
vpcmpgtd %ymm13, %ymm12, %ymm11
vmovaps 0x280(%rsp), %ymm2
vblendvps %ymm11, 0x2a0(%rsp), %ymm2, %ymm11
vmovaps 0x2c0(%rsp), %ymm2
vblendvps %ymm5, 0x100(%rsp), %ymm2, %ymm5
vorps %ymm5, %ymm11, %ymm5
vorps %ymm4, %ymm5, %ymm12
movq 0x18(%rsp), %rsi
movq 0x10(%rsi), %rdi
movq (%rdi), %rdi
vextractf128 $0x1, %ymm12, %xmm13
cmpq %rbx, %r8
vmovdqa %ymm3, %ymm2
jae 0x5b4a7f
movq 0x68(%rsp), %rsi
addq %rdi, %rsi
vpextrb $0xc, %xmm13, (%r8,%rsi)
cmpq %rdx, %r15
setae %sil
leaq -0x1(%r8), %r10
cmpq %rbx, %r10
setae %r10b
orb %sil, %r10b
vmovdqa 0x200(%rsp), %ymm3
jne 0x5b4aae
movq 0x70(%rsp), %rsi
addq %rdi, %rsi
vpextrb $0x8, %xmm13, (%r8,%rsi)
cmpq %rdx, %r12
vmovaps 0x1c0(%rsp), %ymm14
jae 0x5b4ae7
leaq -0x2(%r8), %rsi
cmpq $0x2, %r8
setae %r10b
cmpq %rbx, %rsi
setl %sil
andb %r10b, %sil
cmpb $0x1, %sil
jne 0x5b4ae7
movq 0x40(%rsp), %rsi
addq %rdi, %rsi
vpextrb $0x4, %xmm13, (%r8,%rsi)
cmpq %rdx, 0x28(%rsp)
jae 0x5b4b19
leaq -0x3(%r8), %rsi
cmpq $0x3, %r8
setae %r10b
cmpq %rbx, %rsi
setl %sil
andb %r10b, %sil
cmpb $0x1, %sil
jne 0x5b4b19
movq 0x48(%rsp), %rsi
addq %rdi, %rsi
vpextrb $0x0, %xmm13, (%r8,%rsi)
cmpq %rdx, %r9
jae 0x5b4b49
leaq -0x4(%r8), %rsi
cmpq $0x4, %r8
setae %r10b
cmpq %rbx, %rsi
setl %sil
andb %r10b, %sil
cmpb $0x1, %sil
jne 0x5b4b49
movq 0x50(%rsp), %rsi
addq %rdi, %rsi
vpextrb $0xc, %xmm12, (%r8,%rsi)
cmpq %rdx, %r11
jae 0x5b4b79
leaq -0x5(%r8), %rsi
cmpq $0x5, %r8
setae %r10b
cmpq %rbx, %rsi
setl %sil
andb %r10b, %sil
cmpb $0x1, %sil
jne 0x5b4b79
movq 0x58(%rsp), %rsi
addq %rdi, %rsi
vpextrb $0x8, %xmm12, (%r8,%rsi)
cmpq %rdx, %r13
jae 0x5b4ba9
leaq -0x6(%r8), %rsi
cmpq $0x6, %r8
setae %r10b
cmpq %rbx, %rsi
setl %sil
andb %r10b, %sil
cmpb $0x1, %sil
jne 0x5b4ba9
movq 0x60(%rsp), %rsi
addq %rdi, %rsi
vpextrb $0x4, %xmm12, (%r8,%rsi)
cmpq %rdx, %rax
setae %sil
cmpq $0x7, %r8
setb %r10b
orb %sil, %r10b
jne 0x5b4bc9
addq 0x78(%rsp), %rdi
vpextrb $0x0, %xmm12, (%r8,%rdi)
vmovdqa 0x320(%rsp), %ymm4
vpcmpgtd %ymm0, %ymm4, %ymm4
vpand 0x380(%rsp), %ymm4, %ymm4
vpsrad $0x1f, %ymm0, %ymm5
vpandn %ymm4, %ymm5, %ymm4
vextracti128 $0x1, %ymm4, %xmm5
vpackssdw %xmm5, %xmm4, %xmm5
vpcmpeqd %ymm3, %ymm1, %ymm11
vpcmpgtd %ymm3, %ymm1, %ymm12
vpand %ymm4, %ymm12, %ymm13
vblendvps %ymm13, %ymm10, %ymm3, %ymm3
vextracti128 $0x1, %ymm13, %xmm10
vpackssdw %xmm10, %xmm13, %xmm10
vpcmpgtd %ymm0, %ymm2, %ymm13
vpand %ymm13, %ymm11, %ymm11
vextracti128 $0x1, %ymm11, %xmm13
vpackssdw %xmm13, %xmm11, %xmm13
vpblendvb %xmm13, %xmm5, %xmm10, %xmm5
vblendvps %ymm9, %ymm14, %ymm8, %ymm8
vpmovsxwd %xmm5, %ymm5
vmovaps 0x1e0(%rsp), %ymm9
vblendvps %ymm5, 0x80(%rsp), %ymm9, %ymm9
vpor %ymm12, %ymm11, %ymm5
vpand %ymm5, %ymm4, %ymm4
vblendvps %ymm4, %ymm0, %ymm2, %ymm2
movq 0x8(%rsp), %rsi
vmovd %xmm1, (%rsi,%r8,4)
movq 0x30(%rsp), %rdi
vmovd %xmm7, (%rdi,%r8,4)
vpcmpeqd %ymm4, %ymm4, %ymm4
vpsubd %ymm4, %ymm0, %ymm0
incq %r8
cmpq %r8, 0xc0(%rsp)
jne 0x5b4880
vmovdqa 0x80(%rsp), %ymm0
vpaddd 0x100(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x80(%rsp)
movq 0xb8(%rsp), %r13
addq $0x8, %r13
movq 0xb0(%rsp), %rax
addq %rax, 0x78(%rsp)
addq %rax, 0x68(%rsp)
addq %rax, 0x70(%rsp)
addq %rax, 0x60(%rsp)
addq %rax, 0x58(%rsp)
addq %rax, 0x50(%rsp)
addq %rax, 0x48(%rsp)
addq %rax, 0x40(%rsp)
cmpq %rdx, %r13
movq 0x10(%rbp), %r12
jb 0x5b46c5
vmovaps %ymm3, 0x220(%rsp)
vmovdqa %ymm2, 0x120(%rsp)
movq 0x18(%rsp), %rbx
movl 0x4(%rsp), %r8d
vmovdqa 0x1a0(%rsp), %ymm1
vmovdqa 0x180(%rsp), %ymm0
jmp 0x5b4d31
vmovdqa %ymm14, %ymm9
vmovdqa %ymm14, %ymm1
vmovdqa 0x160(%rsp), %ymm0
movq 0x18(%rsp), %rbx
vmovdqa %ymm9, 0x140(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movl 0x220(%rsp,%rdx,4), %esi
cmpl %r8d, %esi
jle 0x5b4d5f
movl 0x140(%rsp,%rdx,4), %eax
movl 0x120(%rsp,%rdx,4), %ecx
movl %esi, %r8d
jmp 0x5b4d85
jne 0x5b4d85
movl 0x120(%rsp,%rdx,4), %esi
cmpl %ecx, %esi
jge 0x5b4d77
movl 0x140(%rsp,%rdx,4), %eax
movl %esi, %ecx
jmp 0x5b4d85
jne 0x5b4d85
movl 0x140(%rsp,%rdx,4), %esi
cmpl %eax, %esi
cmovll %esi, %eax
incq %rdx
cmpl $0x8, %edx
jne 0x5b4d40
vpcmpgtd %ymm0, %ymm14, %ymm0
vpcmpgtd 0x160(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestps %ymm0, %ymm0
je 0x5b4db0
orb $0x40, 0xc(%rbx)
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %eax, %eax
movl %r8d, (%rbx)
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq 0x8(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r12)
jne 0x5b4e18
movq 0x10(%rsp), %rdi
callq 0x20a60d
jmp 0x5b4e18
callq 0x1f9753
jmp 0x5b4e16
callq 0x1f972d
jmp 0x5b4e16
callq 0x1f9707
jmp 0x5b4e16
callq 0x1f96e1
jmp 0x5b4e16
callq 0x1f96bb
jmp 0x5b4e16
callq 0x1f9695
jmp 0x5b4e16
callq 0x1f966f
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop