// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_trace_scan_avx2_256_32.c
// Function: parasail_sg_flags_trace_scan_profile_avx2_256_32
parasail_result_t* PNAME(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        int s1_beg, int s1_end, int s2_beg, int s2_end)
{
    /* declare local variables */
    int32_t i = 0;
    int32_t j = 0;
    int32_t k = 0;
    int32_t s1Len = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    int32_t offset = 0;
    int32_t position = 0;
    __m256i* restrict pvP = NULL;
    __m256i* restrict pvE = NULL;
    int32_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    __m256i vZero;
    int32_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    __m256i vMaxH;
    __m256i vPosMask;
    __m256i vNegInfFront;
    __m256i vSegLenXgap;
    parasail_result_t *result = NULL;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTDiag;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i vTDelF;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile32.score);
    PARASAIL_CHECK_NULL(profile->matrix);
    PARASAIL_CHECK_GT0(profile->s1Len);
    PARASAIL_CHECK_NULL(s2);
    PARASAIL_CHECK_GT0(s2Len);
    PARASAIL_CHECK_GE0(open);
    PARASAIL_CHECK_GE0(gap);

    /* initialize stack variables */
    i = 0;
    j = 0;
    k = 0;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m256i*)profile->profile32.score;
    vGapO = _mm256_set1_epi32(open);
    vGapE = _mm256_set1_epi32(gap);
    NEG_LIMIT = (-open < matrix->min ? INT32_MIN + open : INT32_MIN - matrix->min) + 1;
    POS_LIMIT = INT32_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vPosMask = _mm256_cmpeq_epi32(_mm256_set1_epi32(position),
            _mm256_set_epi32(0,1,2,3,4,5,6,7));
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi32_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_add_epi32(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi32(-segLen*gap), 4));
    vTIns  = _mm256_set1_epi32(PARASAIL_INS);
    vTDel  = _mm256_set1_epi32(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi32(PARASAIL_DIAG);
    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(segLen, s2Len, 32, sizeof(__m256i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SG | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_8;
    result->flag |= s1_beg ? PARASAIL_FLAG_SG_S1_BEG : 0;
    result->flag |= s1_end ? PARASAIL_FLAG_SG_S1_END : 0;
    result->flag |= s2_beg ? PARASAIL_FLAG_SG_S2_BEG : 0;
    result->flag |= s2_end ? PARASAIL_FLAG_SG_S2_END : 0;

    /* initialize heap variables */
    pvE = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int32_t(32, s2Len+1);
    pvHt= parasail_memalign___m256i(32, segLen);
    pvH = parasail_memalign___m256i(32, segLen);
    pvGapper = parasail_memalign___m256i(32, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!boundary) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvGapper) return NULL;

    /* initialize H and E */
    {
        int32_t index = 0;
        for (i=0; i<segLen; ++i) {
            int32_t segNum = 0;
            __m256i_32_t h;
            __m256i_32_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = s1_beg ? 0 : (-open-gap*(segNum*segLen+i));
                h.v[segNum] = tmp < INT32_MIN ? INT32_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT32_MIN ? INT32_MIN : tmp;
            }
            _mm256_store_si256(&pvH[index], h.m);
            _mm256_store_si256(&pvE[index], e.m);
            ++index;
        }
    }

    /* initialize uppder boundary */
    {
        boundary[0] = 0;
        for (i=1; i<=s2Len; ++i) {
            int64_t tmp = s2_beg ? 0 : (-open-gap*(i-1));
            boundary[i] = tmp < INT32_MIN ? INT32_MIN : tmp;
        }
    }

    {
        __m256i vGapper = _mm256_sub_epi32(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_sub_epi32(vGapper, vGapE);
            /* long queries and/or large penalties will break the pseudo prefix scan */
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vGapper);
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        __m256i vE_ext;
        __m256i vE_opn;
        __m256i vHt;
        __m256i vF;
        __m256i vF_ext;
        __m256i vF_opn;
        __m256i vH;
        __m256i vHp;
        __m256i *pvW;
        __m256i vW;
        __m256i case1;
        __m256i case2;
        __m256i vGapper;
        __m256i vT;
        __m256i vET;
        __m256i vFT;

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm256_load_si256(pvH+(segLen-1));
        vHp = _mm256_slli_si256_rpl(vHp, 4);
        vHp = _mm256_insert_epi32_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_sub_epi32(vNegLimit, pvGapper[0]);
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm256_load_si256(pvH+i);
            vE = _mm256_load_si256(pvE+i);
            vW = _mm256_load_si256(pvW+i);
            vGapper = _mm256_load_si256(pvGapper+i);
            vE_opn = _mm256_sub_epi32(vH, vGapO);
            vE_ext = _mm256_sub_epi32(vE, vGapE);
            case1 = _mm256_cmpgt_epi32(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi32(vE_opn, vE_ext);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vE);
            vGapper = _mm256_add_epi32(vHt, vGapper);
            vF = _mm256_max_epi32(vF, vGapper);
            vHp = _mm256_add_epi32(vHp, vW);
            vHt = _mm256_max_epi32(vE, vHp);
            _mm256_store_si256(pvE+i, vE);
            _mm256_store_si256(pvHt+i, vHt);
            _mm256_store_si256(pvH+i, vHp);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm256_slli_si256_rpl(vHt, 4);
        vHt = _mm256_insert_epi32_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_add_epi32(vHt, vGapper);
        vF = _mm256_max_epi32(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 4);
            vFt = _mm256_add_epi32(vFt, vSegLenXgap);
            vF = _mm256_max_epi32(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 4);
        vF = _mm256_add_epi32(vF, vNegInfFront);
        vH = _mm256_max_epi32(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm256_load_si256(pvH+i);
            vHt = _mm256_load_si256(pvHt+i);
            vF_opn = _mm256_sub_epi32(vH, vGapO);
            vF_ext = _mm256_sub_epi32(vF, vGapE);
            vF = _mm256_max_epi32(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi32(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi32(vHt, vF);
            case1 = _mm256_cmpeq_epi32(vH, vHp);
            case2 = _mm256_cmpeq_epi32(vH, vF);
            vT = _mm256_blendv_epi8(
                    _mm256_blendv_epi8(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm256_or_si256(vT, vET);
            vT = _mm256_or_si256(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi32(vSaturationCheckMax, vH);
        }

        /* extract vector containing last value from column */
        {
            __m256i vCompare;
            vH = _mm256_load_si256(pvH + offset);
            vCompare = _mm256_and_si256(vPosMask, _mm256_cmpgt_epi32(vH, vMaxH));
            vMaxH = _mm256_max_epi32(vH, vMaxH);
            if (_mm256_movemask_epi8(vCompare)) {
                end_ref = j;
            }
        }
    } 

    /* max last value from all columns */
    if (s2_end)
    {
        for (k=0; k<position; ++k) {
            vMaxH = _mm256_slli_si256_rpl(vMaxH, 4);
        }
        score = (int32_t) _mm256_extract_epi32_rpl(vMaxH, 7);
        end_query = s1Len-1;
    }

    /* max of last column */
    if (s1_end)
    {
        /* Trace the alignment ending position on read. */
        int32_t *t = (int32_t*)pvH;
        int32_t column_len = segLen * segWidth;
        for (i = 0; i<column_len; ++i, ++t) {
            int32_t temp = i / segWidth + i % segWidth * segLen;
            if (temp >= s1Len) continue;
            if (*t > score) {
                score = *t;
                end_query = temp;
                end_ref = s2Len-1;
            }
            else if (*t == score && end_ref == s2Len-1 && temp < end_query) {
                end_query = temp;
            }
        }
    }

    if (!s1_end && !s2_end) {
        /* extract last value from the last column */
        {
            __m256i vH = _mm256_load_si256(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 4);
            }
            score = (int32_t) _mm256_extract_epi32_rpl (vH, 7);
            end_ref = s2Len - 1;
            end_query = s1Len - 1;
        }
    }

    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(pvGapper);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(boundary);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rsi, 0x60(%rsp)
testq %rdi, %rdi
je 0x57864c
movq 0x48(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x578653
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x57865a
movl %edx, %r13d
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x578661
cmpq $0x0, 0x60(%rsp)
je 0x578668
testl %r13d, %r13d
jle 0x57866f
testl %ecx, %ecx
js 0x578676
testl %r8d, %r8d
js 0x57867d
movl %r9d, %r15d
movl %r8d, 0xc0(%rsp)
leal -0x1(%rdx), %eax
movq %rdx, 0x50(%rsp)
leaq 0x7(%rdx), %r12
movq %r12, %rdi
shrq $0x3, %rdi
movl %eax, 0x10(%rsp)
cltd
idivl %edi
movl %eax, 0x14(%rsp)
movl %edx, 0x40(%rsp)
movl %ecx, %esi
negl %esi
movq 0x58(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %r14d      # imm = 0x80000000
movl %ecx, 0x20(%rsp)
orl %r14d, %ecx
subl %eax, %r14d
movl %esi, 0x38(%rsp)
cmpl %esi, %eax
cmovgl %ecx, %r14d
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x80(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movq %rdi, 0x18(%rsp)
movl %r13d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x578682
movq %rax, %rbx
movq %r12, 0x70(%rsp)
movl %r14d, 0x8(%rsp)
movl 0x20(%rbp), %edi
xorl %eax, %eax
testl %r15d, %r15d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rbp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x18(%rbp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %edi, 0x4c(%rsp)
testl %edi, %edi
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%rbx), %eax
orl $0x8480402, %eax        # imm = 0x8480402
movl %eax, 0xc(%rbx)
movl $0x20, %edi
movq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, %r12
leal 0x1(%r13), %esi
movl $0x20, %edi
movq %rsi, 0xe0(%rsp)
callq 0x2094d5
movq %rax, 0x28(%rsp)
movl $0x20, %edi
movq %r14, %rsi
movq %r13, 0xa0(%rsp)
movq %r14, %r13
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq 0x18(%rsp), %rsi
callq 0x4c5e3c
testq %r12, %r12
sete %cl
cmpq $0x0, 0x28(%rsp)
sete %dl
orb %cl, %dl
testq %r14, %r14
sete %cl
testq %r13, %r13
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %dl
xorl %ecx, %ecx
orb %sil, %dl
jne 0x578682
movq 0xa0(%rsp), %rdx
decl %edx
movl %edx, 0xc(%rsp)
movl $0x7, %esi
subl 0x14(%rsp), %esi
movl 0x20(%rsp), %r8d
vmovd %r8d, %xmm0
vpbroadcastd %xmm0, %ymm4
movl 0xc0(%rsp), %edi
vmovd %edi, %xmm0
vpbroadcastd %xmm0, %ymm5
movl 0x8(%rsp), %edx
incl %edx
movl %edx, 0x8(%rsp)
vmovd %edx, %xmm0
vpbroadcastd %xmm0, %ymm2
vmovd 0x80(%rsp), %xmm0
vpbroadcastd %xmm0, %ymm3
movl %esi, 0x34(%rsp)
vmovd %esi, %xmm0
vpbroadcastd %xmm0, %ymm1
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %ymm2, 0x80(%rsp)
vmovss %xmm2, %xmm0, %xmm6     # xmm6 = xmm2[0],xmm0[1,2,3]
movq 0x18(%rsp), %r9
movl %r9d, %edx
imull %edi, %edx
movl %edx, %esi
negl %esi
vmovd %esi, %xmm0
vpbroadcastd %xmm0, %ymm0
vpxor %xmm2, %xmm2, %xmm2
vpblendd $0x1, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[0],ymm0[1,2,3,4,5,6,7]
vmovaps %ymm6, 0x160(%rsp)
vpaddd %ymm0, %ymm6, %ymm9
movl %r8d, %esi
movl %r9d, %edi
movq %rdi, 0x20(%rsp)
movq $-0x80000000, %rdi      # imm = 0x80000000
movl 0x38(%rsp), %r9d
movl %r9d, %r10d
xorl %r11d, %r11d
testl %r15d, %r15d
movl $0x0, %r8d
cmovel %r10d, %r8d
movslq %r8d, %r8
movl %r8d, 0x1a0(%rsp,%r11,4)
subq %rsi, %r8
cmpq $-0x7fffffff, %r8       # imm = 0x80000001
cmovlq %rdi, %r8
movl %r8d, 0x180(%rsp,%r11,4)
incq %r11
subl %edx, %r10d
cmpq $0x8, %r11
jne 0x578187
movq %rcx, %r8
shlq $0x5, %r8
vmovaps 0x1a0(%rsp), %ymm0
vmovaps %ymm0, (%r13,%r8)
vmovdqa 0x180(%rsp), %ymm0
vmovdqa %ymm0, (%r12,%r8)
incq %rcx
movl 0xc0(%rsp), %r8d
subl %r8d, %r9d
cmpq 0x20(%rsp), %rcx
jne 0x578181
movq 0x28(%rsp), %rsi
movl $0x0, (%rsi)
movl $0x1, %ecx
movl 0x38(%rsp), %edi
movl 0x18(%rbp), %r9d
movq 0xe0(%rsp), %r10
testl %r9d, %r9d
movl $0x0, %edx
cmovel %edi, %edx
movl %edx, (%rsi,%rcx,4)
incq %rcx
subl %r8d, %edi
cmpq %rcx, %r10
jne 0x57821c
vpxor %xmm0, %xmm0, %xmm0
vpsubd %ymm4, %ymm0, %ymm0
movq 0x18(%rsp), %r11
leal -0x1(%r11), %ecx
movq %rcx, %rsi
shlq $0x5, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r11d, %esi
vmovdqa %ymm3, 0x100(%rsp)
vmovdqa %ymm3, %ymm2
vmovdqa %ymm0, (%rdx)
vpsubd %ymm5, %ymm0, %ymm0
vpminsd %ymm0, %ymm2, %ymm2
addq $-0x20, %rdx
decl %esi
jg 0x578263
movl %ecx, %ecx
shlq $0x5, %rcx
addq %r13, %rcx
movq %rcx, 0x38(%rsp)
movl 0x40(%rsp), %r10d
movq %r10, 0x68(%rsp)
shlq $0x5, %r10
addq %r13, %r10
cmpl $0x1, %r11d
adcl $0x0, %r11d
movq 0xa0(%rsp), %rcx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
movq %rdx, 0x40(%rsp)
movq 0x20(%rsp), %rsi
shlq $0x5, %rsi
shlq $0x5, %r11
xorl %edx, %edx
vpmovsxbd 0x814b1(%rip), %ymm10 # 0x5f9780
vbroadcastss 0x81728(%rip), %ymm0 # 0x5f9a00
vmovaps %ymm0, 0xa0(%rsp)
vbroadcastss 0x8311a(%rip), %ymm11 # 0x5fb404
vbroadcastss 0x83115(%rip), %ymm12 # 0x5fb408
vbroadcastss 0x83110(%rip), %ymm13 # 0x5fb40c
vpbroadcastd 0x8310b(%rip), %ymm14 # 0x5fb410
vbroadcastss 0x83106(%rip), %ymm15 # 0x5fb414
vpcmpeqd 0x8148a(%rip), %ymm1, %ymm0 # 0x5f97a0
vmovdqa %ymm0, 0x120(%rsp)
xorl %ecx, %ecx
movl 0xc(%rsp), %edi
vmovdqa 0x80(%rsp), %ymm0
vmovdqa %ymm0, %ymm3
vmovdqa %ymm0, %ymm6
vmovdqa %ymm9, 0x140(%rsp)
vmovaps %ymm12, 0xe0(%rsp)
vmovdqa %ymm6, 0xc0(%rsp)
movq 0x38(%rsp), %r8
vpermd (%r8), %ymm10, %ymm0
movq 0x28(%rsp), %r8
vmovd (%r8,%rcx,4), %xmm6
vpblendd $0x1, %ymm6, %ymm0, %ymm1 # ymm1 = ymm6[0],ymm0[1,2,3,4,5,6,7]
movq 0x58(%rsp), %r8
movq 0x10(%r8), %r8
movq 0x60(%rsp), %r9
movzbl (%r9,%rcx), %r9d
movslq (%r8,%r9,4), %r9
imulq 0x20(%rsp), %r9
shlq $0x5, %r9
addq 0x78(%rsp), %r9
vmovdqa 0x80(%rsp), %ymm0
vpsubd (%rax), %ymm0, %ymm6
xorl %r15d, %r15d
vmovaps 0xa0(%rsp), %ymm12
vpaddd (%r9,%r15), %ymm1, %ymm9
vmovdqa (%r13,%r15), %ymm1
vmovdqa (%r12,%r15), %ymm8
vpsubd %ymm4, %ymm1, %ymm7
vpsubd %ymm5, %ymm8, %ymm8
vpcmpgtd %ymm8, %ymm7, %ymm10
vblendvps %ymm10, %ymm12, %ymm11, %ymm10
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %rdx, %r8
vpaddd (%rax,%r15), %ymm6, %ymm6
vmovaps %ymm10, (%r15,%r8)
vpmaxsd %ymm6, %ymm0, %ymm0
vpmaxsd %ymm8, %ymm7, %ymm7
vpminsd %ymm7, %ymm2, %ymm2
vpmaxsd %ymm9, %ymm7, %ymm6
vmovdqa %ymm7, (%r12,%r15)
vmovdqa %ymm6, (%r14,%r15)
vmovdqa %ymm9, (%r13,%r15)
addq $0x20, %r15
cmpq %r15, %r11
jne 0x5783ab
vpmovsxbd 0x81360(%rip), %ymm10 # 0x5f9780
vpermd %ymm6, %ymm10, %ymm1
leaq 0x1(%rcx), %r9
movq 0x28(%rsp), %r8
vmovd 0x4(%r8,%rcx,4), %xmm6
vpblendd $0x1, %ymm6, %ymm1, %ymm6 # ymm6 = ymm6[0],ymm1[1,2,3,4,5,6,7]
vpaddd (%rax), %ymm6, %ymm1
vpmaxsd %ymm1, %ymm0, %ymm0
movl $0x6, %r15d
vmovdqa 0x140(%rsp), %ymm9
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm1[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd %ymm1, %ymm9, %ymm1
vpmaxsd %ymm1, %ymm0, %ymm0
decl %r15d
jne 0x578453
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm1[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd 0x160(%rsp), %ymm0, %ymm0
vpmaxsd %ymm6, %ymm0, %ymm6
xorl %r15d, %r15d
vmovaps 0xe0(%rsp), %ymm12
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %rdx, %r8
vmovdqa (%r14,%r15), %ymm1
vpsubd %ymm4, %ymm6, %ymm6
vpsubd %ymm5, %ymm0, %ymm7
vpmaxsd %ymm7, %ymm6, %ymm0
vpcmpgtd %ymm7, %ymm6, %ymm6
vblendvps %ymm6, %ymm12, %ymm13, %ymm7
vpmaxsd %ymm0, %ymm1, %ymm6
vpcmpeqd (%r13,%r15), %ymm6, %ymm8
vpcmpgtd %ymm0, %ymm1, %ymm1
vpaddd %ymm1, %ymm14, %ymm1
vblendvps %ymm8, %ymm15, %ymm1, %ymm1
vorps (%r15,%r8), %ymm7, %ymm7
vorps %ymm1, %ymm7, %ymm1
vmovaps %ymm1, (%r15,%r8)
vmovdqa %ymm6, (%r13,%r15)
vpminsd %ymm0, %ymm2, %ymm1
vpminsd %ymm6, %ymm1, %ymm2
vpmaxsd %ymm6, %ymm3, %ymm3
addq $0x20, %r15
cmpq %r15, %r11
jne 0x578493
vmovdqa (%r10), %ymm0
vmovdqa 0xc0(%rsp), %ymm6
vpcmpgtd %ymm6, %ymm0, %ymm1
vpmaxsd %ymm6, %ymm0, %ymm6
vtestps 0x120(%rsp), %ymm1
cmovnel %ecx, %edi
addq %rsi, %rdx
movq %r9, %rcx
cmpq 0x40(%rsp), %r9
jne 0x578348
cmpl $0x0, 0x20(%rbp)
movl 0x10(%rsp), %r8d
movq 0x50(%rsp), %r10
movq 0x18(%rsp), %r15
je 0x578581
cmpl $0x6, 0x14(%rsp)
jg 0x578573
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
vperm2i128 $0x28, %ymm6, %ymm6, %ymm0 # ymm0 = zero,zero,ymm6[0,1]
vpalignr $0xc, %ymm0, %ymm6, %ymm6 # ymm6 = ymm0[12,13,14,15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11],ymm0[28,29,30,31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27]
decl %ecx
jne 0x578563
vextracti128 $0x1, %ymm6, %xmm0
vpextrd $0x3, %xmm0, 0x8(%rsp)
cmpl $0x0, 0x10(%rbp)
je 0x578600
testl $0x7ffffff8, 0x70(%rsp) # imm = 0x7FFFFFF8
je 0x578600
movl %r15d, %edx
andl $0xfffffff, %edx        # imm = 0xFFFFFFF
shll $0x3, %edx
xorl %esi, %esi
movl %r8d, %ecx
movl %esi, %r9d
shrl $0x3, %r9d
movl %esi, %r8d
andl $0x7, %r8d
imull %r15d, %r8d
addl %r9d, %r8d
cmpl %r10d, %r8d
jge 0x5785f7
movl (%r13,%rsi,4), %r9d
movl 0x8(%rsp), %r11d
cmpl %r11d, %r9d
jle 0x5785d9
movl %r9d, 0x8(%rsp)
movl 0xc(%rsp), %edi
movl %r8d, %ecx
jmp 0x5785f7
xorl %r11d, %r9d
movl %edi, %r10d
xorl 0xc(%rsp), %r10d
cmpl %ecx, %r8d
cmovgel %ecx, %r8d
orl %r9d, %r10d
movq 0x50(%rsp), %r10
cmovel %r8d, %ecx
incq %rsi
cmpl %esi, %edx
jne 0x5785a2
jmp 0x578603
movl %r8d, %ecx
movl 0x10(%rbp), %edx
orl %edx, 0x4c(%rsp)
jne 0x5786ae
movq 0x68(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%r13,%rcx), %ymm0
cmpl $0x6, 0x14(%rsp)
jg 0x578696
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x10(%rsp), %edx
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm1[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
decl %ecx
jne 0x57863a
jmp 0x57869a
callq 0x1f818d
jmp 0x578682
callq 0x1f8167
jmp 0x578682
callq 0x1f8141
jmp 0x578682
callq 0x1f811b
jmp 0x578682
callq 0x1f80f5
jmp 0x578682
callq 0x1f80cf
jmp 0x578682
callq 0x1f80a9
jmp 0x578682
callq 0x1f8083
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x10(%rsp), %edx
vextracti128 $0x1, %ymm0, %xmm0
vpextrd $0x3, %xmm0, 0x8(%rsp)
movl 0xc(%rsp), %edi
movl %edx, %ecx
vmovdqa 0x80(%rsp), %ymm0
vpcmpgtd %ymm2, %ymm0, %ymm0
vpcmpgtd 0x100(%rsp), %ymm3, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestps %ymm0, %ymm0
je 0x5786df
orb $0x40, 0xc(%rbx)
movl $0x0, 0x8(%rsp)
xorl %edi, %edi
xorl %ecx, %ecx
movl 0x8(%rsp), %edx
movl %edx, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edi, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x578684