// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_diag_avx2_256_64.c
// Function: parasail_sw_trace_diag_avx2_256_64
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;
    int64_t * restrict s1 = NULL;
    int64_t * restrict s2B = NULL;
    int64_t * restrict _H_pr = NULL;
    int64_t * restrict _F_pr = NULL;
    int64_t * restrict s2 = NULL;
    int64_t * restrict H_pr = NULL;
    int64_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;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    int64_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 = 4; /* 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 ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInf = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vNegInf0 = _mm256_srli_si256_rpl(vNegInf, 8); /* shift in a 0 */
    vOpen = _mm256_set1_epi64x_rpl(open);
    vGap  = _mm256_set1_epi64x_rpl(gap);
    vZero = _mm256_set1_epi64x_rpl(0);
    vOne = _mm256_set1_epi64x_rpl(1);
    vN = _mm256_set1_epi64x_rpl(N);
    vNegOne = _mm256_set1_epi64x_rpl(-1);
    vI = _mm256_set_epi64x_rpl(0,1,2,3);
    vJreset = _mm256_set_epi64x_rpl(0,-1,-2,-3);
    vMaxH = vNegInf;
    vEndI = vNegInf;
    vEndJ = vNegInf;
    vILimit = _mm256_set1_epi64x_rpl(s1Len);
    vJLimit = _mm256_set1_epi64x_rpl(s2Len);
    vTDiag = _mm256_set1_epi64x_rpl(PARASAIL_DIAG);
    vTIns = _mm256_set1_epi64x_rpl(PARASAIL_INS);
    vTDel = _mm256_set1_epi64x_rpl(PARASAIL_DEL);
    vTZero = _mm256_set1_epi64x_rpl(PARASAIL_ZERO);
    vTDiagE = _mm256_set1_epi64x_rpl(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi64x_rpl(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi64x_rpl(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi64x_rpl(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_64 | PARASAIL_FLAG_LANES_4;

    /* initialize heap variables */
    s2B= parasail_memalign_int64_t(32, s2Len+PAD2);
    _H_pr = parasail_memalign_int64_t(32, s2Len+PAD2);
    _F_pr = parasail_memalign_int64_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_int64_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))];
        __m256i vIltLimit = _mm256_cmplt_epi64_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, 8);
            vNH = _mm256_insert_epi64_rpl(vNH, H_pr[j], 3);
            vF = _mm256_srli_si256_rpl(vF, 8);
            vF = _mm256_insert_epi64_rpl(vF, F_pr[j], 3);
            vF_opn = _mm256_sub_epi64(vNH, vOpen);
            vF_ext = _mm256_sub_epi64(vF, vGap);
            vF = _mm256_max_epi64_rpl(vF_opn, vF_ext);
            vE_opn = _mm256_sub_epi64(vWH, vOpen);
            vE_ext = _mm256_sub_epi64(vE, vGap);
            vE = _mm256_max_epi64_rpl(vE_opn, vE_ext);
            vMat = _mm256_set_epi64x_rpl(
                    matrow0[s2[j-0]],
                    matrow1[s2[j-1]],
                    matrow2[s2[j-2]],
                    matrow3[s2[j-3]]
                    );
            vNWH = _mm256_add_epi64(vNWH, vMat);
            vNWH = _mm256_max_epi64_rpl(vNWH, vZero);
            vWH = _mm256_max_epi64_rpl(vNWH, vE);
            vWH = _mm256_max_epi64_rpl(vWH, vF);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m256i cond = _mm256_cmpeq_epi64(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_epi64_rpl(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vWH);
            }
            /* trace table */
            {
                __m256i cond_zero = _mm256_cmpeq_epi64(vWH, vZero);
                __m256i case1 = _mm256_cmpeq_epi64(vWH, vNWH);
                __m256i case2 = _mm256_cmpeq_epi64(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_epi64(vE_opn, vE_ext);
                __m256i condF = _mm256_cmpgt_epi64(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-3] = (int64_t)_mm256_extract_epi64_rpl(vWH,0);
            F_pr[j-3] = (int64_t)_mm256_extract_epi64_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_epi64(vJ, vNegOne),
                        _mm256_cmplt_epi64_rpl(vJ, vJLimit));
                __m256i cond_valid_IJ = _mm256_and_si256(cond_valid_J, vIltLimit);
                __m256i cond_eq = _mm256_cmpeq_epi64(vWH, vMaxH);
                __m256i cond_max = _mm256_cmpgt_epi64(vWH, vMaxH);
                __m256i cond_all = _mm256_and_si256(cond_max, cond_valid_IJ);
                __m256i cond_Jlt = _mm256_cmplt_epi64_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_epi64(vJ, vOne);
        }
        vI = _mm256_add_epi64(vI, vN);
    }

    /* alignment ending position */
    {
        int64_t *t = (int64_t*)&vMaxH;
        int64_t *i = (int64_t*)&vEndI;
        int64_t *j = (int64_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_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi64(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 $0x320, %rsp            # imm = 0x320
testq %rdx, %rdx
je 0x5b2601
movl %r9d, %r12d
movl %ecx, %r9d
testl %ecx, %ecx
jle 0x5b2608
testl %r8d, %r8d
js 0x5b260f
testl %r12d, %r12d
js 0x5b2616
movl %esi, %r14d
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0x5b261d
cmpl $0x0, 0x30(%rsi)
je 0x5b1ca5
movl 0x34(%rsi), %r14d
jmp 0x5b1cb7
testq %rdi, %rdi
je 0x5b2624
testl %r14d, %r14d
jle 0x5b262b
movq %rdi, 0x20(%rsp)
movq %rdx, 0x60(%rsp)
movslq 0x20(%rsi), %rax
movl %r8d, %ecx
negl %r8d
movq %rcx, 0xc0(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
movq %rbx, %rdx
subq %rax, %rdx
cmpl %r8d, %eax
cmovgq %rcx, %rdx
incq %rdx
movslq 0x1c(%rsi), %rax
movq %rax, 0x18(%rsp)
movq %rdx, 0x30(%rsp)
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x1a0(%rsp)
vmovdqa %ymm0, 0x100(%rsp)
vmovdqa %ymm0, 0x140(%rsp)
vmovdqa %ymm0, 0x180(%rsp)
movl $0x20, %edx
movl $0x1, %ecx
movl %r14d, %edi
movl %r9d, %esi
movq %r9, %r15
vzeroupper
callq 0x20adf4
testq %rax, %rax
je 0x5b2630
movq %rax, %r13
movl %r12d, 0x160(%rsp)
movq %r14, (%rsp)
orl $0x4881004, 0xc(%rax)   # imm = 0x4881004
movq %r15, 0x10(%rsp)
leal 0x6(%r15), %r12d
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a636
movq %rax, %r14
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a636
movl $0x20, %edi
movq %r12, %rsi
movq %rax, %r12
callq 0x20a636
testq %r14, %r14
sete %dl
testq %r12, %r12
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x5b2630
movq %r13, 0x58(%rsp)
movq (%rsp), %r15
movslq %r15d, %r13
movq 0x10(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
movq %rax, 0x28(%rsp)
je 0x5b1de1
xorl %eax, %eax
movq 0x60(%rsp), %rdi
jmp 0x5b1e6c
leal 0x3(%r15), %eax
movl %eax, 0xa0(%rsp)
movslq %eax, %rsi
movl $0x20, %edi
callq 0x20a636
testq %rax, %rax
je 0x5b2630
testl %r15d, %r15d
movq 0x20(%rsp), %rdi
jle 0x5b1e2a
movq 0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
movslq (%rsi,%rdx,4), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x5b1e16
movq (%rsp), %rcx
leal 0x1(%rcx), %edx
movl 0xa0(%rsp), %esi
cmpl %edx, %esi
cmovgl %esi, %edx
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
leaq (%rax,%r13,8), %rdi
notl %ecx
addl %edx, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x8(%rsp), %rax
movq 0x60(%rsp), %rdi
movq 0x10(%rbp), %rcx
movq 0xc0(%rsp), %rdx
movq 0x18(%rsp), %r9
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
leal 0x3(%rsi), %r8d
subq %r9, %rbx
addq $-0x2, %rbx
vmovq %rbx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x120(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vpblendd $0x3f, 0x140(%rsp), %ymm0, %ymm0 # ymm0 = mem[0,1,2,3,4,5],ymm0[6,7]
vmovdqa %ymm0, 0x1e0(%rsp)
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x2e0(%rsp)
movl 0x160(%rsp), %eax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x2c0(%rsp)
vmovq %r13, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x1c0(%rsp)
movl %esi, %ebx
vmovq %rbx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x2a0(%rsp)
movq 0x10(%rcx), %rax
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
movslq (%rax,%rdx,4), %rdx
movq %rdx, 0x18(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x5b1f14
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leal 0x1(%rsi), %eax
cmpl %eax, %r8d
movl %r8d, 0x60(%rsp)
cmovgl %r8d, %eax
leaq (%r14,%rbx,8), %rdi
addq $0x18, %rdi
movl %esi, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %r15d, %r15d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %rdi
movq $0x0, 0x18(%r12,%r15,8)
movq %r9, 0x18(%rdi,%r15,8)
incq %r15
cmpq %r15, %rbx
jne 0x5b1f76
xorl %eax, %eax
movq %r9, (%r12,%rax,8)
movq %r9, (%rdi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x5b1f8e
leaq 0x3(%rbx), %rax
movq 0x10(%rbp), %r15
vmovdqa 0x140(%rsp), %ymm5
movq 0x10(%rsp), %rcx
movl 0x60(%rsp), %edx
movq %r9, (%r12,%rax,8)
movq %r9, (%rdi,%rax,8)
incq %rax
incl %ecx
cmpl %ecx, %edx
jg 0x5b1fb9
vmovdqa %ymm5, %ymm7
vmovdqa %ymm5, %ymm9
vmovdqa %ymm5, %ymm11
vmovdqa %ymm5, 0xa0(%rsp)
vmovdqa 0x120(%rsp), %ymm0
vmovdqa %ymm0, 0xe0(%rsp)
cmpl $0x0, (%rsp)
jle 0x5b2518
movq (%rsp), %rax
decl %eax
movq %rax, (%rsp)
cmpl $0x2, %edx
movl $0x1, %eax
cmovgel %edx, %eax
movq %rax, 0x98(%rsp)
leaq -0x3(%rbx,%rbx,2), %rax
movq %rax, 0x50(%rsp)
leaq (,%rbx,4), %rax
movq %rax, 0x88(%rsp)
leaq -0x2(%rbx,%rbx), %rax
movq %rax, 0x38(%rsp)
leaq -0x1(%rbx), %rax
movq %rax, 0x48(%rsp)
vmovaps 0x7bb53(%rip), %ymm0    # 0x62dba0
vmovaps %ymm0, 0x60(%rsp)
movq $0x0, 0x40(%rsp)
vbroadcastsd 0x782eb(%rip), %ymm0 # 0x62a350
vmovaps %ymm0, 0x280(%rsp)
vbroadcastsd 0x7bb11(%rip), %ymm0 # 0x62db88
vmovaps %ymm0, 0xc0(%rsp)
vbroadcastsd 0x7dc1f(%rip), %ymm0 # 0x62fca8
vmovaps %ymm0, 0x260(%rsp)
vbroadcastsd 0x7dc15(%rip), %ymm0 # 0x62fcb0
vmovaps %ymm0, 0x240(%rsp)
vbroadcastsd 0x7dc0b(%rip), %ymm0 # 0x62fcb8
vmovaps %ymm0, 0x220(%rsp)
vbroadcastsd 0x7dc01(%rip), %ymm0 # 0x62fcc0
vmovaps %ymm0, 0x200(%rsp)
xorl %r10d, %r10d
vmovdqa 0x120(%rsp), %ymm0
vmovdqa %ymm0, 0xe0(%rsp)
vmovdqa %ymm5, 0xa0(%rsp)
vmovdqa %ymm5, %ymm11
vmovdqa %ymm5, %ymm9
vmovdqa %ymm5, %ymm7
movq %r10, %r9
orq $0x2, %r9
cmpl $0x0, 0x30(%r15)
je 0x5b2134
movq %r10, %rax
orq $0x1, %rax
cmpq %r13, %rax
movq (%rsp), %rsi
cmovgel %esi, %eax
movslq %eax, %rcx
cmpq %r13, %r9
movl %r9d, %eax
cmovgel %esi, %eax
cltq
movq %r10, %rdx
orq $0x3, %rdx
cmpq %r13, %rdx
cmovgel %esi, %edx
movslq %edx, %rsi
movq %r10, %rdx
jmp 0x5b214b
movq 0x8(%rsp), %rsi
movq (%rsi,%r10,8), %rdx
movq 0x8(%rsi,%r10,8), %rcx
movq (%rsi,%r9,8), %rax
movq 0x18(%rsi,%r10,8), %rsi
movq 0x8(%r15), %rdi
movslq 0x18(%r15), %r8
imulq %r8, %rcx
leaq (%rdi,%rcx,4), %rcx
movq %rcx, 0x18(%rsp)
imulq %r8, %rdx
leaq (%rdi,%rdx,4), %rcx
movq %rcx, 0x10(%rsp)
imulq %r8, %rax
leaq (%rdi,%rax,4), %rax
movq %rax, 0x20(%rsp)
imulq %r8, %rsi
leaq (%rdi,%rsi,4), %rsi
movq %r10, %rcx
orq $0x1, %rcx
movq %r10, 0x90(%rsp)
movq %r10, %rdx
orq $0x3, %rdx
vmovdqa 0x1c0(%rsp), %ymm0
vpcmpgtq 0x60(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x160(%rsp)
xorl %r8d, %r8d
vpmovsxbq 0x79d31(%rip), %ymm3 # 0x62beee
vmovdqa %ymm5, %ymm6
vmovdqa %ymm5, %ymm12
vmovdqa 0x1e0(%rsp), %ymm10
vmovdqa %ymm10, %ymm4
vpcmpeqd %ymm15, %ymm15, %ymm15
vpermq $0xf9, %ymm4, %ymm0     # ymm0 = ymm4[1,2,3,3]
movq %r12, %r11
vpbroadcastq 0x18(%r12,%r8,8), %ymm2
movq 0x18(%r14,%r8,8), %rax
movq 0x10(%rsp), %rdi
movslq (%rdi,%rax,4), %rax
movq 0x10(%r14,%r8,8), %r15
movq 0x18(%rsp), %rdi
movslq (%rdi,%r15,4), %r15
movq (%r14,%r8,8), %r12
movq 0x8(%r14,%r8,8), %r10
movq 0x20(%rsp), %rdi
movslq (%rdi,%r10,4), %r10
movslq (%rsi,%r12,4), %r12
vmovq %rax, %xmm8
vmovq %r15, %xmm13
vpunpcklqdq %xmm8, %xmm13, %xmm8 # xmm8 = xmm13[0],xmm8[0]
vmovq %r10, %xmm13
vmovq %r12, %xmm14
vpunpcklqdq %xmm13, %xmm14, %xmm13 # xmm13 = xmm14[0],xmm13[0]
vinserti128 $0x1, %xmm8, %ymm13, %ymm8
vpaddq %ymm10, %ymm8, %ymm13
vpblendd $0xc0, %ymm2, %ymm0, %ymm10 # ymm10 = ymm0[0,1,2,3,4,5],ymm2[6,7]
vpermq $0xf9, %ymm6, %ymm0     # ymm0 = ymm6[1,2,3,3]
movq 0x28(%rsp), %rax
vpbroadcastq 0x18(%rax,%r8,8), %ymm2
vpblendd $0xc0, %ymm2, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3,4,5],ymm2[6,7]
vmovdqa 0x2e0(%rsp), %ymm1
vpsubq %ymm1, %ymm10, %ymm2
vmovdqa 0x2c0(%rsp), %ymm6
vpsubq %ymm6, %ymm0, %ymm0
vpsubq %ymm1, %ymm4, %ymm4
vpsubq %ymm6, %ymm12, %ymm6
vpcmpgtq %ymm0, %ymm2, %ymm8
vblendvpd %ymm8, %ymm2, %ymm0, %ymm1
vpcmpgtq %ymm6, %ymm4, %ymm2
vblendvpd %ymm2, %ymm4, %ymm6, %ymm12
vpcmpgtq 0x7b97f(%rip), %ymm13, %ymm0 # 0x62dc20
vpand %ymm0, %ymm13, %ymm0
vpcmpgtq %ymm12, %ymm0, %ymm4
vblendvpd %ymm4, %ymm0, %ymm12, %ymm4
vpcmpgtq %ymm1, %ymm4, %ymm6
vblendvpd %ymm6, %ymm4, %ymm1, %ymm14
vpcmpeqq %ymm15, %ymm3, %ymm13
vpandn %ymm14, %ymm13, %ymm4
vblendvpd %ymm13, %ymm5, %ymm1, %ymm6
cmpq $0x4, %r8
jb 0x5b230b
vmovdqa 0xe0(%rsp), %ymm5
vpcmpgtq %ymm5, %ymm4, %ymm1
vblendvpd %ymm1, %ymm5, %ymm4, %ymm5
vmovapd %ymm5, 0xe0(%rsp)
vmovdqa 0xa0(%rsp), %ymm5
vpcmpgtq %ymm4, %ymm5, %ymm1
vblendvpd %ymm1, %ymm5, %ymm4, %ymm5
vmovapd %ymm5, 0xa0(%rsp)
vpcmpeqq %ymm0, %ymm4, %ymm0
vpcmpeqq %ymm6, %ymm4, %ymm1
vmovdqa 0x280(%rsp), %ymm5
vpsubq %ymm1, %ymm5, %ymm1
vpcmpeqq 0x7b8f5(%rip), %ymm4, %ymm5 # 0x62dc20
vpandn 0xc0(%rsp), %ymm5, %ymm5
vblendvpd %ymm0, %ymm5, %ymm1, %ymm0
vmovapd 0x240(%rsp), %ymm1
vblendvpd %ymm2, 0x260(%rsp), %ymm1, %ymm1
vmovapd 0x200(%rsp), %ymm2
vblendvpd %ymm8, 0x220(%rsp), %ymm2, %ymm2
vorpd %ymm1, %ymm2, %ymm1
vorpd %ymm0, %ymm1, %ymm8
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
vextractf128 $0x1, %ymm8, %xmm0
cmpq %rbx, %r8
movq %r11, %r12
jae 0x5b2394
movq 0x40(%rsp), %rdi
leaq (%rax,%rdi), %r10
vpextrb $0x8, %xmm0, (%r8,%r10)
cmpq %r13, %rcx
setge %r10b
leaq -0x1(%r8), %r15
cmpq %rbx, %r15
setae %r15b
orb %r10b, %r15b
jne 0x5b23bb
movq 0x48(%rsp), %rdi
leaq (%rax,%rdi), %r10
vpextrb $0x0, %xmm0, (%r8,%r10)
cmpq %r13, %r9
jge 0x5b23ec
leaq -0x2(%r8), %r10
cmpq $0x2, %r8
setae %r15b
cmpq %rbx, %r10
setl %r10b
andb %r15b, %r10b
cmpb $0x1, %r10b
jne 0x5b23ec
movq 0x38(%rsp), %rdi
leaq (%rax,%rdi), %r10
vpextrb $0x8, %xmm8, (%r8,%r10)
cmpq %r13, %rdx
setge %r10b
cmpq $0x3, %r8
setb %r15b
orb %r10b, %r15b
jne 0x5b240c
addq 0x50(%rsp), %rax
vpextrb $0x0, %xmm8, (%r8,%rax)
vpcmpeqd %ymm15, %ymm15, %ymm15
vpcmpgtq %ymm15, %ymm3, %ymm0
vmovdqa 0x2a0(%rsp), %ymm1
vpcmpgtq %ymm3, %ymm1, %ymm1
vpand 0x160(%rsp), %ymm1, %ymm1
vpand %ymm0, %ymm1, %ymm0
vextracti128 $0x1, %ymm0, %xmm1
vpackssdw %xmm1, %xmm0, %xmm1
vpcmpeqq %ymm11, %ymm4, %ymm2
vpcmpgtq %ymm11, %ymm4, %ymm5
vpand %ymm0, %ymm5, %ymm8
vblendvpd %ymm8, %ymm14, %ymm11, %ymm11
vextracti128 $0x1, %ymm8, %xmm14
vpackssdw %xmm14, %xmm8, %xmm8
vpcmpgtq %ymm3, %ymm9, %ymm14
vpand %ymm2, %ymm14, %ymm2
vextracti128 $0x1, %ymm2, %xmm14
vpackssdw %xmm14, %xmm2, %xmm14
vblendvps %xmm14, %xmm1, %xmm8, %xmm1
vmovapd 0x140(%rsp), %ymm8
vblendvpd %ymm13, %ymm8, %ymm12, %ymm12
vpmovsxdq %xmm1, %ymm1
vblendvpd %ymm1, 0x60(%rsp), %ymm7, %ymm7
vpor %ymm5, %ymm2, %ymm1
vmovapd %ymm8, %ymm5
vpand %ymm1, %ymm0, %ymm0
vblendvpd %ymm0, %ymm3, %ymm9, %ymm9
vmovq %xmm4, (%r12,%r8,8)
movq 0x28(%rsp), %rdi
vmovq %xmm6, (%rdi,%r8,8)
vpsubq %ymm15, %ymm3, %ymm3
incq %r8
cmpq %r8, 0x98(%rsp)
jne 0x5b21d7
vmovdqa 0x60(%rsp), %ymm0
vpaddq 0xc0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x60(%rsp)
movq 0x90(%rsp), %r10
addq $0x4, %r10
movq 0x88(%rsp), %rax
addq %rax, 0x50(%rsp)
addq %rax, 0x40(%rsp)
addq %rax, 0x48(%rsp)
addq %rax, 0x38(%rsp)
cmpq %r13, %r10
movq 0x10(%rbp), %r15
movq 0x30(%rsp), %r9
jl 0x5b20f2
vmovdqa %ymm11, 0x1a0(%rsp)
vmovdqa %ymm9, 0x180(%rsp)
vmovdqa %ymm7, 0x100(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x58(%rsp), %rbx
movq 0x1a0(%rsp,%rdx,8), %rsi
cmpq %r9, %rsi
jle 0x5b255e
movl 0x100(%rsp,%rdx,8), %eax
movl 0x180(%rsp,%rdx,8), %ecx
movq %rsi, %r9
jmp 0x5b2592
jne 0x5b2592
movq 0x180(%rsp,%rdx,8), %rsi
movslq %ecx, %r8
cmpq %r8, %rsi
jge 0x5b257b
movl 0x100(%rsp,%rdx,8), %eax
movl %esi, %ecx
jmp 0x5b2592
jne 0x5b2592
movq 0x100(%rsp,%rdx,8), %r10
movslq %eax, %r8
cmpq %r8, %r10
jge 0x5b2592
movl %esi, %ecx
movl %r10d, %eax
incq %rdx
cmpl $0x4, %edx
jne 0x5b253e
vpcmpgtq 0xe0(%rsp), %ymm5, %ymm0
vmovdqa 0xa0(%rsp), %ymm1
vpcmpgtq 0x120(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestpd %ymm0, %ymm0
je 0x5b25cd
orb $0x40, 0xc(%rbx)
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %eax, %eax
movl %r9d, (%rbx)
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r15)
jne 0x5b2632
movq 0x8(%rsp), %rdi
callq 0x20a60d
jmp 0x5b2632
callq 0x1f9435
jmp 0x5b2630
callq 0x1f940f
jmp 0x5b2630
callq 0x1f93e9
jmp 0x5b2630
callq 0x1f93c3
jmp 0x5b2630
callq 0x1f939d
jmp 0x5b2630
callq 0x1f9377
jmp 0x5b2630
callq 0x1f9351
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq