// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_diag_avx2_256_64.c
// Function: parasail_sw_rowcol_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 = 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 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;

    /* 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);

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(s1Len, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(s1Len, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SW | PARASAIL_FLAG_DIAG
        | PARASAIL_FLAG_BITS_64 | PARASAIL_FLAG_LANES_4;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* 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 vF = 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 = _mm256_max_epi64_rpl(
                    _mm256_sub_epi64(vNH, vOpen),
                    _mm256_sub_epi64(vF, vGap));
            vE = _mm256_max_epi64_rpl(
                    _mm256_sub_epi64(vWH, vOpen),
                    _mm256_sub_epi64(vE, vGap));
            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);
            vWH = _mm256_max_epi64_rpl(vNWH, vE);
            vWH = _mm256_max_epi64_rpl(vWH, vF);
            vWH = _mm256_max_epi64_rpl(vWH, vZero);
            /* 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);
            }
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vWH, i, s1Len, j, s2Len);
#endif
#ifdef PARASAIL_ROWCOL
            arr_store_rowcol(result->rowcols->score_row, result->rowcols->score_col, vWH, i, s1Len, j, s2Len);
#endif
            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 $0x280, %rsp            # imm = 0x280
testq %rdx, %rdx
je 0x559f12
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x559f19
testl %r8d, %r8d
js 0x559f20
movl %r9d, %r12d
testl %r9d, %r9d
js 0x559f27
movq %rdx, %r15
movq 0x10(%rbp), %rdx
testq %rdx, %rdx
je 0x559f2e
cmpl $0x0, 0x30(%rdx)
je 0x55967c
movl 0x34(%rdx), %ebx
jmp 0x55968f
testq %rdi, %rdi
je 0x559f35
movl %esi, %ebx
testl %esi, %esi
jle 0x559f3c
movq %rdi, 0x30(%rsp)
movslq 0x20(%rdx), %rax
movl %r8d, %ecx
negl %r8d
movq %rcx, 0x60(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
subq %rax, %rsi
cmpl %r8d, %eax
cmovgq %rcx, %rsi
incq %rsi
movslq 0x1c(%rdx), %rax
movq %rax, 0x38(%rsp)
movq %rsi, 0x40(%rsp)
vmovq %rsi, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x160(%rsp)
vmovdqa %ymm0, 0xe0(%rsp)
vmovdqa %ymm0, 0x120(%rsp)
vmovdqa %ymm0, 0x140(%rsp)
movl %ebx, %edi
movl %r14d, %esi
vzeroupper
callq 0x20ac53
testq %rax, %rax
je 0x559f41
movq %rax, %r13
movl %r12d, 0x20(%rsp)
movq %r15, 0x28(%rsp)
orl $0x4841004, 0xc(%rax)   # imm = 0x4841004
movq %r14, 0x10(%rsp)
leal 0x6(%r14), %r12d
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a636
movq %rax, %r14
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a636
movq %rax, %r15
movl $0x20, %edi
movq %r12, %rsi
callq 0x20a636
testq %r14, %r14
sete %dl
testq %r15, %r15
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x559f41
movq %r13, 0x58(%rsp)
movslq %ebx, %r13
movq 0x10(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
movq %r15, 0x18(%rsp)
movq %rax, 0x50(%rsp)
je 0x559798
xorl %r15d, %r15d
jmp 0x559806
leal 0x3(%rbx), %r12d
movslq %r12d, %rsi
movl $0x20, %edi
callq 0x20a636
testq %rax, %rax
je 0x559f41
movq %rax, %rsi
testl %ebx, %ebx
movq 0x30(%rsp), %rdi
jle 0x5597dc
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
movslq (%rax,%rdx,4), %rdx
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x5597c8
leal 0x1(%rbx), %eax
cmpl %eax, %r12d
cmovgl %r12d, %eax
movq %rsi, %r15
leaq (%rsi,%r13,8), %rdi
movl %ebx, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x10(%rbp), %rcx
movq %r15, 0x48(%rsp)
movq 0x10(%rsp), %rsi
leal 0x3(%rsi), %r8d
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
subq 0x38(%rsp), %rax
addq $-0x2, %rax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x100(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vpblendd $0x3f, 0x120(%rsp), %ymm0, %ymm0 # ymm0 = mem[0,1,2,3,4,5],ymm0[6,7]
vmovdqa %ymm0, 0x1c0(%rsp)
vmovsd 0x60(%rsp), %xmm0
vbroadcastsd %xmm0, %ymm0
vmovaps %ymm0, 0x220(%rsp)
movl 0x20(%rsp), %eax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x200(%rsp)
vmovq %r13, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x1a0(%rsp)
movl %esi, %r15d
vmovq %r15, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x1e0(%rsp)
movq 0x10(%rcx), %rax
xorl %ecx, %ecx
movq 0x28(%rsp), %rdi
movzbl (%rdi,%rcx), %edx
movslq (%rax,%rdx,4), %rdx
movq %rdx, 0x18(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x5598b1
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,%r15,8), %rdi
addq $0x18, %rdi
movl %esi, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movq 0x40(%rsp), %rdx
movq 0x18(%rsp), %r10
movq 0x50(%rsp), %rdi
movq $0x0, 0x18(%r10,%r12,8)
movq %rdx, 0x18(%rdi,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x559918
xorl %eax, %eax
movq %rdx, (%r10,%rax,8)
movq %rdx, (%rdi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x559930
leaq 0x3(%r15), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rbp), %r11
vmovdqa 0x120(%rsp), %ymm10
movl 0x60(%rsp), %esi
movq %rdx, (%r10,%rax,8)
movq %rdx, (%rdi,%rax,8)
incq %rax
incl %ecx
cmpl %ecx, %esi
jg 0x55995b
vmovdqa %ymm10, %ymm2
vmovdqa %ymm10, %ymm3
vmovdqa %ymm10, %ymm4
vmovdqa %ymm10, 0xc0(%rsp)
vmovdqa 0x100(%rsp), %ymm0
vmovdqa %ymm0, 0xa0(%rsp)
testl %ebx, %ebx
jle 0x559e19
movq 0x8(%r11), %rax
movq %rax, 0x80(%rsp)
decl %ebx
movq 0x10(%rsp), %rax
decl %eax
movq %rax, 0x10(%rsp)
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
movq %rax, 0x98(%rsp)
leaq 0x1(%r15), %rax
movq %rax, 0x90(%rsp)
leaq 0x2(%r15), %rax
movq %rax, 0x88(%rsp)
vmovaps 0xd41b8(%rip), %ymm0    # 0x62dba0
vmovaps %ymm0, 0x60(%rsp)
xorl %ecx, %ecx
vpcmpeqd %ymm8, %ymm8, %ymm8
vbroadcastsd 0xd418a(%rip), %ymm0 # 0x62db88
vmovaps %ymm0, 0x180(%rsp)
vmovdqa 0x100(%rsp), %ymm0
vmovdqa %ymm0, 0xa0(%rsp)
vmovdqa %ymm10, 0xc0(%rsp)
vmovdqa %ymm10, %ymm4
vmovdqa %ymm10, %ymm3
vmovdqa %ymm10, %ymm2
movq %rcx, %r8
orq $0x2, %r8
cmpl $0x0, 0x30(%r11)
je 0x559a6c
movq %rcx, %rax
orq $0x1, %rax
cmpq %r13, %rax
cmovgel %ebx, %eax
movslq %eax, %r12
cmpq %r13, %r8
movl %r8d, %eax
cmovgel %ebx, %eax
cltq
movq %rcx, %rsi
orq $0x3, %rsi
cmpq %r13, %rsi
cmovgel %ebx, %esi
movslq %esi, %rsi
movq %rcx, %rdx
jmp 0x559a83
movq 0x48(%rsp), %rsi
movq (%rsi,%rcx,8), %rdx
movq 0x8(%rsi,%rcx,8), %r12
movq (%rsi,%r8,8), %rax
movq 0x18(%rsi,%rcx,8), %rsi
movslq 0x18(%r11), %r9
imulq %r9, %r12
movq 0x80(%rsp), %r11
leaq (%r11,%r12,4), %r12
movq %r12, 0x38(%rsp)
imulq %r9, %rdx
leaq (%r11,%rdx,4), %rdx
movq %rdx, 0x30(%rsp)
imulq %r9, %rax
leaq (%r11,%rax,4), %rax
movq %rax, 0x28(%rsp)
imulq %r9, %rsi
leaq (%r11,%rsi,4), %rax
movq %rax, 0x20(%rsp)
movq %rcx, %rdx
orq $0x1, %rdx
movq %rcx, %rax
orq $0x3, %rcx
vmovdqa 0x1a0(%rsp), %ymm0
vpcmpgtq 0x60(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x240(%rsp)
xorl %esi, %esi
vpmovsxbq 0xd23f9(%rip), %ymm11 # 0x62beee
vmovdqa %ymm10, %ymm9
vmovdqa %ymm10, %ymm6
vmovdqa 0x1c0(%rsp), %ymm12
vmovdqa %ymm12, %ymm13
vmovdqa %ymm12, %ymm15
vpermq $0xf9, %ymm13, %ymm7    # ymm7 = ymm13[1,2,3,3]
vpbroadcastq 0x18(%r10,%rsi,8), %ymm12
vpblendd $0xc0, %ymm12, %ymm7, %ymm12 # ymm12 = ymm7[0,1,2,3,4,5],ymm12[6,7]
vpermq $0xf9, %ymm9, %ymm7     # ymm7 = ymm9[1,2,3,3]
vpbroadcastq 0x18(%rdi,%rsi,8), %ymm9
vpblendd $0xc0, %ymm9, %ymm7, %ymm7 # ymm7 = ymm7[0,1,2,3,4,5],ymm9[6,7]
vmovdqa 0x220(%rsp), %ymm0
vpsubq %ymm0, %ymm12, %ymm9
vmovdqa 0x200(%rsp), %ymm1
vpsubq %ymm1, %ymm7, %ymm7
vpsubq %ymm0, %ymm13, %ymm13
vpsubq %ymm1, %ymm6, %ymm6
movq 0x18(%r14,%rsi,8), %r9
movq 0x30(%rsp), %rdi
movslq (%rdi,%r9,4), %r9
movq 0x10(%r14,%rsi,8), %r12
movq 0x38(%rsp), %rdi
movslq (%rdi,%r12,4), %r12
movq (%r14,%rsi,8), %r10
movq 0x8(%r14,%rsi,8), %r11
movq 0x28(%rsp), %rdi
movslq (%rdi,%r11,4), %r11
movq 0x20(%rsp), %rdi
movslq (%rdi,%r10,4), %r10
vmovq %r9, %xmm14
vmovq %r12, %xmm5
vpunpcklqdq %xmm14, %xmm5, %xmm5 # xmm5 = xmm5[0],xmm14[0]
vmovq %r11, %xmm14
vmovq %r10, %xmm0
vpunpcklqdq %xmm14, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm14[0]
vpcmpgtq %ymm7, %ymm9, %ymm14
vblendvpd %ymm14, %ymm9, %ymm7, %ymm9
vinserti128 $0x1, %xmm5, %ymm0, %ymm0
vpcmpgtq %ymm6, %ymm13, %ymm5
vblendvpd %ymm5, %ymm13, %ymm6, %ymm14
vpaddq %ymm0, %ymm15, %ymm0
vpcmpgtq %ymm14, %ymm0, %ymm5
vblendvpd %ymm5, %ymm0, %ymm14, %ymm0
vpcmpgtq %ymm9, %ymm0, %ymm5
vblendvpd %ymm5, %ymm0, %ymm9, %ymm0
vpcmpgtq 0xd4033(%rip), %ymm0, %ymm5 # 0x62dc20
vpand %ymm0, %ymm5, %ymm6
vpcmpeqq %ymm8, %ymm11, %ymm15
vpandn %ymm6, %ymm15, %ymm13
cmpq $0x4, %rsi
jb 0x559c3a
vmovdqa 0xa0(%rsp), %ymm1
vpcmpgtq %ymm1, %ymm13, %ymm0
vblendvpd %ymm0, %ymm1, %ymm13, %ymm1
vmovapd %ymm1, 0xa0(%rsp)
vmovdqa 0xc0(%rsp), %ymm1
vpcmpgtq %ymm13, %ymm1, %ymm0
vblendvpd %ymm0, %ymm1, %ymm13, %ymm1
vmovapd %ymm1, 0xc0(%rsp)
movq %rax, %rdi
cmpq %rbx, %rax
setne %r10b
movq 0x58(%rsp), %r9
movq 0x10(%r9), %r11
movq (%r11), %r9
movq 0x8(%r11), %r12
cmpq %r15, %rsi
setae %r11b
orb %r10b, %r11b
vextractf128 $0x1, %ymm13, %xmm7
jne 0x559c6d
vextractps $0x2, %xmm7, (%r9,%rsi,4)
cmpq %rsi, 0x10(%rsp)
jne 0x559c7b
vextractps $0x2, %xmm7, (%r12,%rdi,4)
cmpq %rbx, %rdx
setne %r10b
leaq -0x1(%rsi), %r11
cmpq %r15, %r11
setae %r11b
orb %r10b, %r11b
jne 0x559c99
vmovss %xmm7, -0x4(%r9,%rsi,4)
cmpq %r13, %rdx
setge %r10b
cmpq %rsi, %r15
setne %r11b
orb %r10b, %r11b
jne 0x559cb2
vmovss %xmm7, (%r12,%rdx,4)
cmpq %rbx, %r8
jne 0x559cdb
leaq -0x2(%rsi), %r10
cmpq $0x2, %rsi
setae %r11b
cmpq %r15, %r10
setl %r10b
andb %r11b, %r10b
cmpb $0x1, %r10b
jne 0x559cdb
vpextrd $0x2, %xmm13, -0x8(%r9,%rsi,4)
cmpq %r13, %r8
setge %r10b
cmpq %rsi, 0x90(%rsp)
setne %r11b
orb %r10b, %r11b
jne 0x559cfa
vpextrd $0x2, %xmm13, (%r12,%r8,4)
cmpq %rbx, %rcx
setne %r10b
cmpq $0x3, %rsi
setb %r11b
orb %r10b, %r11b
jne 0x559d15
vmovd %xmm13, -0xc(%r9,%rsi,4)
vblendvpd %ymm15, %ymm10, %ymm9, %ymm9
cmpq %r13, %rcx
setge %r9b
cmpq %rsi, 0x88(%rsp)
setne %r10b
orb %r9b, %r10b
movq 0x50(%rsp), %rdi
jne 0x559d3e
vmovd %xmm13, (%r12,%rcx,4)
vpcmpgtq %ymm8, %ymm11, %ymm0
vmovdqa 0x1e0(%rsp), %ymm1
vpcmpgtq %ymm11, %ymm1, %ymm5
vpand 0x240(%rsp), %ymm5, %ymm5
vpand %ymm0, %ymm5, %ymm0
vextracti128 $0x1, %ymm0, %xmm5
vpackssdw %xmm5, %xmm0, %xmm5
vpcmpeqq %ymm4, %ymm13, %ymm7
vpcmpgtq %ymm4, %ymm13, %ymm1
vpand %ymm0, %ymm1, %ymm10
vblendvpd %ymm10, %ymm6, %ymm4, %ymm4
vextracti128 $0x1, %ymm10, %xmm6
vpackssdw %xmm6, %xmm10, %xmm6
vpcmpgtq %ymm11, %ymm3, %ymm10
vpand %ymm7, %ymm10, %ymm7
vextracti128 $0x1, %ymm7, %xmm10
vpackssdw %xmm10, %xmm7, %xmm10
vblendvps %xmm10, %xmm5, %xmm6, %xmm5
vmovapd 0x120(%rsp), %ymm10
vblendvpd %ymm15, %ymm10, %ymm14, %ymm6
vpmovsxdq %xmm5, %ymm5
vblendvpd %ymm5, 0x60(%rsp), %ymm2, %ymm2
vpor %ymm1, %ymm7, %ymm1
vpand %ymm1, %ymm0, %ymm0
vblendvpd %ymm0, %ymm11, %ymm3, %ymm3
movq 0x18(%rsp), %r10
vmovq %xmm13, (%r10,%rsi,8)
vmovlpd %xmm9, (%rdi,%rsi,8)
vpsubq %ymm8, %ymm11, %ymm11
incq %rsi
cmpq %rsi, 0x98(%rsp)
jne 0x559b0c
vmovdqa 0x60(%rsp), %ymm0
vpaddq 0x180(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x60(%rsp)
movq %rax, %rcx
addq $0x4, %rcx
cmpq %r13, %rcx
movq 0x10(%rbp), %r11
jl 0x559a2e
vmovdqa %ymm4, 0x160(%rsp)
vmovdqa %ymm3, 0x140(%rsp)
vmovdqa %ymm2, 0xe0(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x58(%rsp), %rbx
movq 0x40(%rsp), %r8
movq 0x160(%rsp,%rdx,8), %rsi
cmpq %r8, %rsi
jle 0x559e64
movl 0xe0(%rsp,%rdx,8), %eax
movl 0x140(%rsp,%rdx,8), %ecx
movq %rsi, %r8
jmp 0x559e9e
jne 0x559e9e
movq 0x140(%rsp,%rdx,8), %rsi
movslq %ecx, %r9
cmpq %r9, %rsi
jge 0x559e81
movl 0xe0(%rsp,%rdx,8), %eax
movl %esi, %ecx
jmp 0x559e9e
jne 0x559e9e
movq %r8, %r9
movq 0xe0(%rsp,%rdx,8), %r10
movslq %eax, %r8
cmpq %r8, %r10
jge 0x559e9b
movl %esi, %ecx
movl %r10d, %eax
movq %r9, %r8
incq %rdx
cmpl $0x4, %edx
jne 0x559e44
movq %r11, %r15
vpcmpgtq 0xa0(%rsp), %ymm10, %ymm0
vmovdqa 0xc0(%rsp), %ymm1
vpcmpgtq 0x100(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestpd %ymm0, %ymm0
je 0x559edc
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 0x18(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r15)
jne 0x559f43
movq 0x48(%rsp), %rdi
callq 0x20a60d
jmp 0x559f43
callq 0x1f0c09
jmp 0x559f41
callq 0x1f0be3
jmp 0x559f41
callq 0x1f0bbd
jmp 0x559f41
callq 0x1f0b97
jmp 0x559f41
callq 0x1f0b71
jmp 0x559f41
callq 0x1f0b4b
jmp 0x559f41
callq 0x1f0b25
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)