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

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

    /* 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_32 | PARASAIL_FLAG_LANES_8;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* 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 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))];
        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 = _mm256_max_epi32(
                    _mm256_sub_epi32(vNH, vOpen),
                    _mm256_sub_epi32(vF, vGap));
            vE = _mm256_max_epi32(
                    _mm256_sub_epi32(vWH, vOpen),
                    _mm256_sub_epi32(vE, vGap));
            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);
            vWH = _mm256_max_epi32(vWH, vZero);
            /* 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);
            }
#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-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 $0x2c0, %rsp            # imm = 0x2C0
testq %rdx, %rdx
je 0x55c635
movl %ecx, %ebx
testl %ecx, %ecx
jle 0x55c63c
testl %r8d, %r8d
js 0x55c643
testl %r9d, %r9d
js 0x55c64a
movq 0x10(%rbp), %r13
testq %r13, %r13
je 0x55c651
movq %rdx, %r12
cmpl $0x0, 0x30(%r13)
je 0x55bb3e
movl 0x34(%r13), %r14d
jmp 0x55bb52
testq %rdi, %rdi
je 0x55c658
movl %esi, %r14d
testl %esi, %esi
jle 0x55c65f
movq %rdi, 0x30(%rsp)
movl %r9d, 0x8(%rsp)
movl %r8d, %eax
negl %eax
movl 0x20(%r13), %ecx
movl $0x80000000, %esi       # imm = 0x80000000
movl %r8d, 0x18(%rsp)
movl %r8d, %edx
orl %esi, %edx
subl %ecx, %esi
cmpl %eax, %ecx
cmovgl %edx, %esi
incl %esi
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%r13), %eax
movl %eax, 0x40(%rsp)
movl %esi, 0x24(%rsp)
vmovd %esi, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqa %ymm0, 0x1c0(%rsp)
vmovdqa %ymm0, 0x120(%rsp)
vmovdqa %ymm0, 0x1a0(%rsp)
vmovdqa %ymm0, 0x100(%rsp)
movl %r14d, %edi
movl %ebx, %esi
vzeroupper
callq 0x20ac53
testq %rax, %rax
je 0x55c664
movq %rax, %r15
movq %r12, 0x28(%rsp)
movq %r14, 0x60(%rsp)
orl $0x8441004, 0xc(%rax)   # imm = 0x8441004
movq %rbx, 0x10(%rsp)
leal 0xe(%rbx), %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 0x55c664
movq %r15, 0x58(%rsp)
cmpl $0x0, 0x30(%r13)
movq %rbx, 0x38(%rsp)
movq %rax, 0x50(%rsp)
je 0x55bc62
movq $0x0, 0x48(%rsp)
movq 0x60(%rsp), %rbx
movq 0x28(%rsp), %r12
jmp 0x55bcd5
movq 0x60(%rsp), %rbx
leal 0x7(%rbx), %r15d
movslq %r15d, %rsi
movl $0x20, %edi
callq 0x20a62d
testq %rax, %rax
movq 0x28(%rsp), %r12
je 0x55c664
testl %ebx, %ebx
movq 0x30(%rsp), %r8
jle 0x55bcaa
movq 0x10(%r13), %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 0x55bc97
movslq %ebx, %rsi
leal 0x1(%rbx), %ecx
cmpl %ecx, %r15d
cmovgl %r15d, %ecx
movq %rax, 0x48(%rsp)
leaq (%rax,%rsi,4), %rdi
movl %ebx, %eax
notl %eax
addl %ecx, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x10(%rsp), %rcx
leal 0x7(%rcx), %r15d
vmovss 0x40(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovaps %ymm0, 0x140(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vblendps $0x7f, 0x1a0(%rsp), %ymm0, %ymm0 # ymm0 = mem[0,1,2,3,4,5,6],ymm0[7]
vmovaps %ymm0, 0x220(%rsp)
vmovss 0x18(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovaps %ymm0, 0x280(%rsp)
vmovss 0x8(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovaps %ymm0, 0x260(%rsp)
vmovd %ebx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqa %ymm0, 0x200(%rsp)
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqa %ymm0, 0x240(%rsp)
movq 0x10(%r13), %rax
movl %ecx, %ebx
xorl %ecx, %ecx
movzbl (%r12,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0x1c(%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rbx
jne 0x55bd5e
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, 0xc(%r14)
vmovdqu %xmm0, (%r14)
movq 0x10(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl %eax, %r15d
cmovgl %r15d, %eax
leaq (%r14,%rbx,4), %rdi
addq $0x1c, %rdi
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
vzeroupper
callq 0x19e090
movl 0x24(%rsp), %r8d
movq 0x38(%rsp), %rdx
movq 0x50(%rsp), %rdi
movl $0x0, 0x1c(%rdx,%r12,4)
movl %r8d, 0x1c(%rdi,%r12,4)
incq %r12
cmpq %r12, %rbx
jne 0x55bdc1
xorl %eax, %eax
movl %r8d, (%rdx,%rax,4)
movl %r8d, (%rdi,%rax,4)
incq %rax
cmpq $0x7, %rax
jne 0x55bdd9
leaq 0x7(%rbx), %rax
movq 0x10(%rsp), %rcx
vmovdqa 0x1a0(%rsp), %ymm5
movq 0x60(%rsp), %rsi
movl %r8d, (%rdx,%rax,4)
movl %r8d, (%rdi,%rax,4)
incq %rax
incl %ecx
cmpl %ecx, %r15d
jg 0x55be01
testl %esi, %esi
jle 0x55c56a
movq 0x8(%r13), %rax
movq %rax, 0x88(%rsp)
leal -0x1(%rsi), %ecx
movq 0x10(%rsp), %rax
decl %eax
movq %rax, 0x10(%rsp)
cmpl $0x2, %r15d
movl $0x1, %eax
cmovgel %r15d, %eax
movq %rax, 0xc0(%rsp)
movl %esi, %esi
vmovdqa 0x1c0(%rsp), %ymm3
vmovdqa 0x100(%rsp), %ymm2
leaq 0x1(%rbx), %rax
movq %rax, 0xb8(%rsp)
leaq 0x2(%rbx), %rax
movq %rax, 0xb0(%rsp)
leaq 0x3(%rbx), %rax
movq %rax, 0xa8(%rsp)
leaq 0x4(%rbx), %rax
movq %rax, 0xa0(%rsp)
leaq 0x5(%rbx), %rax
movq %rax, 0x98(%rsp)
leaq 0x6(%rbx), %rax
movq %rax, 0x90(%rsp)
vmovaps 0xd1e51(%rip), %ymm0    # 0x62dd00
vmovaps %ymm0, 0x60(%rsp)
xorl %r8d, %r8d
vpcmpeqd %ymm9, %ymm9, %ymm9
vbroadcastss 0xd1e1a(%rip), %ymm0 # 0x62dce0
vmovaps %ymm0, 0x1e0(%rsp)
vmovdqa 0x140(%rsp), %ymm0
vmovdqa %ymm0, 0x160(%rsp)
vmovdqa %ymm5, 0x180(%rsp)
vmovdqa %ymm5, %ymm4
movq %r8, %rdi
orq $0x3, %rdi
cmpl $0x0, 0x30(%r13)
movq %rdi, 0x30(%rsp)
je 0x55bf63
movq %r8, %rdx
orq $0x1, %rdx
cmpq %rsi, %rdx
cmovael %ecx, %edx
movq %r8, %rax
orq $0x2, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
cmpq %rsi, %rdi
movl %edi, %r10d
cmovael %ecx, %r10d
movq %r8, %rdi
orq $0x4, %rdi
cmpq %rsi, %rdi
cmovael %ecx, %edi
movq %r8, %r11
orq $0x5, %r11
cmpq %rsi, %r11
cmovael %ecx, %r11d
movq %r8, %r15
orq $0x6, %r15
cmpq %rsi, %r15
cmovael %ecx, %r15d
movq %r8, %r9
orq $0x7, %r9
cmpq %rsi, %r9
cmovael %ecx, %r9d
movl %r8d, 0x8(%rsp)
jmp 0x55bf92
movq 0x48(%rsp), %r9
movl (%r9,%r8,4), %eax
movl %eax, 0x8(%rsp)
movl 0x4(%r9,%r8,4), %edx
movl 0x8(%r9,%r8,4), %eax
movl (%r9,%rdi,4), %r10d
movl 0x10(%r9,%r8,4), %edi
movl 0x14(%r9,%r8,4), %r11d
movl 0x18(%r9,%r8,4), %r15d
movl 0x1c(%r9,%r8,4), %r9d
movl 0x18(%r13), %r12d
imull %r12d, %r11d
movslq %r11d, %r11
movq 0x88(%rsp), %r13
leaq (,%r11,4), %r11
addq %r13, %r11
movq %r11, 0x28(%rsp)
imull %r12d, %r10d
movslq %r10d, %r10
leaq (,%r10,4), %r10
addq %r13, %r10
movq %r10, 0xf8(%rsp)
imull %r12d, %edx
movslq %edx, %rdx
leaq (,%rdx,4), %rdx
addq %r13, %rdx
movq %rdx, 0xf0(%rsp)
movl 0x8(%rsp), %edx
imull %r12d, %edx
movslq %edx, %rdx
leaq (,%rdx,4), %rdx
addq %r13, %rdx
movq %rdx, 0xe8(%rsp)
imull %r12d, %eax
cltq
leaq (,%rax,4), %rax
addq %r13, %rax
movq %rax, 0xe0(%rsp)
imull %r12d, %edi
movslq %edi, %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq %rax, 0xd8(%rsp)
imull %r12d, %r15d
movslq %r15d, %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq %rax, 0xd0(%rsp)
imull %r12d, %r9d
movslq %r9d, %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq %rax, 0xc8(%rsp)
movq %r8, %rax
orq $0x1, %rax
movq %rax, 0x8(%rsp)
movq %r8, %rax
orq $0x2, %rax
movq %rax, 0x18(%rsp)
movq %r8, %r15
orq $0x4, %r15
movq %r8, %r10
orq $0x5, %r10
movq %r8, %r12
orq $0x6, %r12
movq %r8, %r11
orq $0x7, %r11
vmovdqa 0x200(%rsp), %ymm0
vpcmpgtd 0x60(%rsp), %ymm0, %ymm11
vpmovsxbd 0xcfe6c(%rip), %ymm12 # 0x62bf26
vmovdqa %ymm5, %ymm8
vmovdqa %ymm5, %ymm6
vmovdqa 0x220(%rsp), %ymm14
vmovdqa %ymm14, %ymm13
xorl %r9d, %r9d
movq 0x38(%rsp), %rdx
movq 0x50(%rsp), %rdi
movq %r8, 0x40(%rsp)
movslq 0x10(%r14,%r9,4), %rax
movq 0xf8(%rsp), %r13
vmovd (%r13,%rax,4), %xmm0
movslq 0x14(%r14,%r9,4), %rax
movq 0xe0(%rsp), %r13
vpinsrd $0x1, (%r13,%rax,4), %xmm0, %xmm0
movslq 0x18(%r14,%r9,4), %rax
movq 0xf0(%rsp), %r13
vpinsrd $0x2, (%r13,%rax,4), %xmm0, %xmm0
movslq 0x1c(%r14,%r9,4), %rax
movq 0xe8(%rsp), %r13
vpinsrd $0x3, (%r13,%rax,4), %xmm0, %xmm0
movslq (%r14,%r9,4), %rax
movq 0xc8(%rsp), %r13
vmovd (%r13,%rax,4), %xmm10
movslq 0x4(%r14,%r9,4), %rax
movq 0xd0(%rsp), %r13
vpinsrd $0x1, (%r13,%rax,4), %xmm10, %xmm10
movslq 0x8(%r14,%r9,4), %rax
movq 0x28(%rsp), %r13
vpinsrd $0x2, (%r13,%rax,4), %xmm10, %xmm10
movslq 0xc(%r14,%r9,4), %rax
movq 0xd8(%rsp), %r13
vpinsrd $0x3, (%r13,%rax,4), %xmm10, %xmm10
cmpq %rcx, %r8
setne %r13b
vinserti128 $0x1, %xmm0, %ymm10, %ymm0
vpmovsxbd 0xd1fa6(%rip), %ymm1 # 0x62e140
vpermd %ymm13, %ymm1, %ymm10
vpaddd %ymm0, %ymm14, %ymm0
vpbroadcastd 0x1c(%rdx,%r9,4), %ymm14
vpblendd $0x80, %ymm14, %ymm10, %ymm14 # ymm14 = ymm10[0,1,2,3,4,5,6],ymm14[7]
vpermd %ymm8, %ymm1, %ymm8
vpbroadcastd 0x1c(%rdi,%r9,4), %ymm10
vpblendd $0x80, %ymm10, %ymm8, %ymm8 # ymm8 = ymm8[0,1,2,3,4,5,6],ymm10[7]
vmovdqa 0x280(%rsp), %ymm1
vpsubd %ymm1, %ymm14, %ymm10
vmovdqa 0x260(%rsp), %ymm7
vpsubd %ymm7, %ymm8, %ymm8
vpmaxsd %ymm8, %ymm10, %ymm8
vpsubd %ymm1, %ymm13, %ymm10
vpsubd %ymm7, %ymm6, %ymm6
vpmaxsd %ymm6, %ymm10, %ymm15
vpmaxsd %ymm8, %ymm15, %ymm6
vpmaxsd 0xd1a24(%rip), %ymm6, %ymm6 # 0x62dc20
vpmaxsd %ymm6, %ymm0, %ymm10
vpcmpeqd %ymm9, %ymm12, %ymm6
vpandn %ymm10, %ymm6, %ymm13
cmpq $0x8, %r9
jb 0x55c23f
vmovdqa 0x160(%rsp), %ymm0
vpminsd %ymm13, %ymm0, %ymm0
vmovdqa %ymm0, 0x160(%rsp)
vmovdqa 0x180(%rsp), %ymm0
vpmaxsd %ymm13, %ymm0, %ymm0
vmovdqa %ymm0, 0x180(%rsp)
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x10(%rax), %r8
movq (%r8), %rax
movq 0x8(%r8), %r8
cmpq %rbx, %r9
setae %dl
orb %dl, %r13b
vextracti128 $0x1, %ymm13, %xmm0
jne 0x55c26c
vpextrd $0x3, %xmm0, (%rax,%r9,4)
cmpq %r9, 0x10(%rsp)
jne 0x55c27f
movq 0x40(%rsp), %rdx
vpextrd $0x3, %xmm0, (%r8,%rdx,4)
cmpq %rcx, 0x8(%rsp)
setne %dl
leaq -0x1(%r9), %r13
cmpq %rbx, %r13
setae %r13b
orb %dl, %r13b
jne 0x55c29f
vpextrd $0x2, %xmm0, -0x4(%rax,%r9,4)
cmpq %rsi, 0x8(%rsp)
setae %dl
cmpq %r9, %rbx
setne %r13b
orb %dl, %r13b
jne 0x55c2bf
movq 0x8(%rsp), %rdx
vpextrd $0x2, %xmm0, (%r8,%rdx,4)
cmpq %rcx, 0x18(%rsp)
jne 0x55c2e8
leaq -0x2(%r9), %rdx
cmpq $0x2, %r9
setae %r13b
cmpq %rbx, %rdx
setl %dl
andb %r13b, %dl
cmpb $0x1, %dl
jne 0x55c2e8
vpextrd $0x1, %xmm0, -0x8(%rax,%r9,4)
cmpq %rsi, 0x18(%rsp)
setae %dl
cmpq %r9, 0xb8(%rsp)
setne %r13b
orb %dl, %r13b
jne 0x55c30d
movq 0x18(%rsp), %rdx
vpextrd $0x1, %xmm0, (%r8,%rdx,4)
cmpq %rcx, %rdi
jne 0x55c333
leaq -0x3(%r9), %rdx
cmpq $0x3, %r9
setae %r13b
cmpq %rbx, %rdx
setl %dl
andb %r13b, %dl
cmpb $0x1, %dl
jne 0x55c333
vmovd %xmm0, -0xc(%rax,%r9,4)
cmpq %rsi, %rdi
setae %dl
cmpq %r9, 0xb0(%rsp)
setne %r13b
orb %dl, %r13b
jne 0x55c350
vmovd %xmm0, (%r8,%rdi,4)
cmpq %rcx, %r15
jne 0x55c377
leaq -0x4(%r9), %rdx
cmpq $0x4, %r9
setae %r13b
cmpq %rbx, %rdx
setl %dl
andb %r13b, %dl
cmpb $0x1, %dl
jne 0x55c377
vpextrd $0x3, %xmm13, -0x10(%rax,%r9,4)
cmpq %rsi, %r15
setae %dl
cmpq %r9, 0xa8(%rsp)
setne %r13b
orb %dl, %r13b
jne 0x55c395
vpextrd $0x3, %xmm13, (%r8,%r15,4)
cmpq %rcx, %r10
jne 0x55c3bc
leaq -0x5(%r9), %rdx
cmpq $0x5, %r9
setae %r13b
cmpq %rbx, %rdx
setl %dl
andb %r13b, %dl
cmpb $0x1, %dl
jne 0x55c3bc
vpextrd $0x2, %xmm13, -0x14(%rax,%r9,4)
cmpq %rsi, %r10
setae %dl
cmpq %r9, 0xa0(%rsp)
setne %r13b
orb %dl, %r13b
jne 0x55c3da
vpextrd $0x2, %xmm13, (%r8,%r10,4)
cmpq %rcx, %r12
jne 0x55c401
leaq -0x6(%r9), %rdx
cmpq $0x6, %r9
setae %r13b
cmpq %rbx, %rdx
setl %dl
andb %r13b, %dl
cmpb $0x1, %dl
jne 0x55c401
vpextrd $0x1, %xmm13, -0x18(%rax,%r9,4)
cmpq %rsi, %r12
setae %dl
cmpq %r9, 0x98(%rsp)
setne %r13b
orb %dl, %r13b
jne 0x55c41f
vpextrd $0x1, %xmm13, (%r8,%r12,4)
cmpq %rcx, %r11
setne %dl
cmpq $0x7, %r9
setb %r13b
orb %dl, %r13b
jne 0x55c439
vmovd %xmm13, -0x1c(%rax,%r9,4)
vblendvps %ymm6, %ymm5, %ymm8, %ymm8
cmpq %rsi, %r11
setae %dl
cmpq %r9, 0x90(%rsp)
setne %r13b
vmovd %xmm13, %eax
orb %dl, %r13b
jne 0x55c45e
movl %eax, (%r8,%r11,4)
vmovdqa 0x240(%rsp), %ymm0
vpcmpgtd %ymm12, %ymm0, %ymm0
vpand %ymm0, %ymm11, %ymm0
vpsrad $0x1f, %ymm12, %ymm1
vpandn %ymm0, %ymm1, %ymm0
vextracti128 $0x1, %ymm0, %xmm1
vpackssdw %xmm1, %xmm0, %xmm1
vpcmpeqd %ymm3, %ymm13, %ymm7
vpcmpgtd %ymm3, %ymm13, %ymm9
vpand %ymm0, %ymm9, %ymm5
vblendvps %ymm5, %ymm10, %ymm3, %ymm3
vextracti128 $0x1, %ymm5, %xmm10
vpackssdw %xmm10, %xmm5, %xmm5
vpcmpgtd %ymm12, %ymm2, %ymm10
vpand %ymm7, %ymm10, %ymm7
vextracti128 $0x1, %ymm7, %xmm10
vpackssdw %xmm10, %xmm7, %xmm10
vpblendvb %xmm10, %xmm1, %xmm5, %xmm1
vmovaps 0x1a0(%rsp), %ymm5
vblendvps %ymm6, %ymm5, %ymm15, %ymm6
vpmovsxwd %xmm1, %ymm1
vblendvps %ymm1, 0x60(%rsp), %ymm4, %ymm4
vpor %ymm7, %ymm9, %ymm1
vpand %ymm1, %ymm0, %ymm0
vblendvps %ymm0, %ymm12, %ymm2, %ymm2
movq 0x38(%rsp), %rdx
movl %eax, (%rdx,%r9,4)
movq 0x50(%rsp), %rdi
vmovss %xmm8, (%rdi,%r9,4)
vpcmpeqd %ymm9, %ymm9, %ymm9
vpsubd %ymm9, %ymm12, %ymm12
incq %r9
cmpq %r9, 0xc0(%rsp)
movq 0x40(%rsp), %r8
jne 0x55c0e2
vmovdqa 0x60(%rsp), %ymm0
vpaddd 0x1e0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x60(%rsp)
addq $0x8, %r8
cmpq %rsi, %r8
movq 0x10(%rbp), %r13
jb 0x55beee
vmovdqa %ymm3, 0x1c0(%rsp)
vmovdqa %ymm2, 0x100(%rsp)
movl 0x24(%rsp), %r8d
vmovdqa 0x180(%rsp), %ymm1
vmovdqa 0x160(%rsp), %ymm0
jmp 0x55c57b
vmovdqa %ymm5, %ymm4
vmovdqa %ymm5, %ymm1
vmovdqa 0x140(%rsp), %ymm0
vmovdqa %ymm4, 0x120(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x58(%rsp), %rbx
movl 0x1c0(%rsp,%rdx,4), %esi
cmpl %r8d, %esi
jle 0x55c5ae
movl 0x120(%rsp,%rdx,4), %eax
movl 0x100(%rsp,%rdx,4), %ecx
movl %esi, %r8d
jmp 0x55c5d4
jne 0x55c5d4
movl 0x100(%rsp,%rdx,4), %esi
cmpl %ecx, %esi
jge 0x55c5c6
movl 0x120(%rsp,%rdx,4), %eax
movl %esi, %ecx
jmp 0x55c5d4
jne 0x55c5d4
movl 0x120(%rsp,%rdx,4), %esi
cmpl %eax, %esi
cmovll %esi, %eax
incq %rdx
cmpl $0x8, %edx
jne 0x55c58f
vpcmpgtd %ymm0, %ymm5, %ymm0
vpcmpgtd 0x140(%rsp), %ymm1, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestps %ymm0, %ymm0
je 0x55c5ff
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 0x38(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r13)
jne 0x55c666
movq 0x48(%rsp), %rdi
callq 0x20a60d
jmp 0x55c666
callq 0x1f0f27
jmp 0x55c664
callq 0x1f0f01
jmp 0x55c664
callq 0x1f0edb
jmp 0x55c664
callq 0x1f0eb5
jmp 0x55c664
callq 0x1f0e8f
jmp 0x55c664
callq 0x1f0e69
jmp 0x55c664
callq 0x1f0e43
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq