// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_striped_avx2_256_32.c
// Function: parasail_sw_trace_striped_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)
{
    /* declare local variables */
    int32_t i = 0;
    int32_t j = 0;
    int32_t k = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = NULL;
    __m256i* restrict pvEaStore = NULL;
    __m256i* restrict pvEaLoad = NULL;
    __m256i* restrict pvHT = NULL;
    __m256i* restrict pvHMax = NULL;
    __m256i vGapO;
    __m256i vGapE;
    __m256i vZero;
    int32_t score = 0;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int32_t maxp = 0;
    parasail_result_t *result = NULL;
    __m256i vTZero;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTDiag;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i vTDelF;
    __m256i vTMask;
    __m256i vFTMask;

    /* 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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m256i*)profile->profile32.score;
    vGapO = _mm256_set1_epi32(open);
    vGapE = _mm256_set1_epi32(gap);
    vZero = _mm256_setzero_si256();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT32_MAX - (int32_t)(matrix->max+1);
    vTZero = _mm256_set1_epi32(PARASAIL_ZERO);
    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);
    vTMask = _mm256_set1_epi32(PARASAIL_ZERO_MASK);
    vFTMask= _mm256_set1_epi32(PARASAIL_F_MASK);

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 32, sizeof(__m256i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SW | PARASAIL_FLAG_STRIPED
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_8;

    /* initialize heap variables */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad =  parasail_memalign___m256i(32, segLen);
    pvE = parasail_memalign___m256i(32, segLen);
    pvEaStore = parasail_memalign___m256i(32, segLen);
    pvEaLoad = parasail_memalign___m256i(32, segLen);
    pvHT = parasail_memalign___m256i(32, segLen);
    pvHMax = parasail_memalign___m256i(32, segLen);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvE) return NULL;
    if (!pvEaStore) return NULL;
    if (!pvEaLoad) return NULL;
    if (!pvHT) return NULL;
    if (!pvHMax) return NULL;

    /* initialize H and E */
    parasail_memset___m256i(pvHStore, vZero, segLen);
    parasail_memset___m256i(pvE, _mm256_set1_epi32(-open), segLen);
    parasail_memset___m256i(pvEaStore, _mm256_set1_epi32(-open), segLen);

    for (i=0; i<segLen; ++i) {
        arr_store(result->trace->trace_table, vTDiagE, i, segLen, 0);
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vEF_opn;
        __m256i vE;
        __m256i vE_ext;
        __m256i vF;
        __m256i vF_ext;
        __m256i vFa;
        __m256i vFa_ext;
        __m256i vH;
        __m256i vH_dag;
        const __m256i* vP = NULL;

        /* Initialize F value to 0.  Any errors to vH values will be
         * corrected in the Lazy_F loop. */
        vF = _mm256_sub_epi32(vZero,vGapO);

        /* load final segment of pvHStore and shift left by 4 bytes */
        vH = _mm256_load_si256(&pvHStore[segLen - 1]);
        vH = _mm256_slli_si256_rpl(vH, 4);

        /* Correct part of the vProfile */
        vP = vProfile + matrix->mapper[(unsigned char)s2[j]] * segLen;

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            SWAP3(pvHMax,  pvHLoad,  pvHStore)
            SWAP(pvEaLoad,  pvEaStore)
        }
        else {
            /* Swap the 2 H buffers. */
            SWAP(pvHLoad,  pvHStore)
            SWAP(pvEaLoad,  pvEaStore)
        }

        /* inner loop to process the query sequence */
        for (i=0; i<segLen; ++i) {
            vE = _mm256_load_si256(pvE + i);

            /* Get max from vH, vE and vF. */
            vH_dag = _mm256_add_epi32(vH, _mm256_load_si256(vP + i));
            vH_dag = _mm256_max_epi32(vH_dag, vZero);
            vH = _mm256_max_epi32(vH_dag, vE);
            vH = _mm256_max_epi32(vH, vF);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);

            {
                __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __m256i cond_zero = _mm256_cmpeq_epi32(vH, vZero);
                __m256i case1 = _mm256_cmpeq_epi32(vH, vH_dag);
                __m256i case2 = _mm256_cmpeq_epi32(vH, vF);
                __m256i vT = _mm256_blendv_epi8(
                        _mm256_blendv_epi8(vTIns, vTDel, case2),
                        _mm256_blendv_epi8(vTDiag, vTZero, cond_zero),
                        case1);
                _mm256_store_si256(pvHT + i, vT);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }
            vMaxH = _mm256_max_epi32(vH, vMaxH);
            vEF_opn = _mm256_sub_epi32(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm256_sub_epi32(vE, vGapE);
            vE = _mm256_max_epi32(vEF_opn, vE_ext);
            _mm256_store_si256(pvE + i, vE);
            {
                __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                __m256i vEa_ext = _mm256_sub_epi32(vEa, vGapE);
                vEa = _mm256_max_epi32(vEF_opn, vEa_ext);
                _mm256_store_si256(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vEa_ext);
                    __m256i vT = _mm256_blendv_epi8(vTInsE, vTDiagE, cond);
                    arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                }
            }

            /* Update vF value. */
            vF_ext = _mm256_sub_epi32(vF, vGapE);
            vF = _mm256_max_epi32(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m256i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vF_ext);
                __m256i vT = _mm256_blendv_epi8(vTDelF, vTDiagF, cond);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i+1, segLen, j);
            }

            /* Load the next vH. */
            vH = _mm256_load_si256(pvHLoad + i);
        }

        /* Lazy_F loop: has been revised to disallow adjecent insertion and
         * then deletion, so don't update E(i, i), learn from SWPS3 */
        vFa_ext = vF_ext;
        vFa = vF;
        for (k=0; k<segWidth; ++k) {
            __m256i vHp = _mm256_load_si256(&pvHLoad[segLen - 1]);
            vHp = _mm256_slli_si256_rpl(vHp, 4);
            vEF_opn = _mm256_slli_si256_rpl(vEF_opn, 4);
            vEF_opn = _mm256_insert_epi32_rpl(vEF_opn, -open, 0);
            vF_ext = _mm256_slli_si256_rpl(vF_ext, 4);
            vF_ext = _mm256_insert_epi32_rpl(vF_ext, NEG_INF, 0);
            vF = _mm256_slli_si256_rpl(vF, 4);
            vF = _mm256_insert_epi32_rpl(vF, -open, 0);
            vFa_ext = _mm256_slli_si256_rpl(vFa_ext, 4);
            vFa_ext = _mm256_insert_epi32_rpl(vFa_ext, NEG_INF, 0);
            vFa = _mm256_slli_si256_rpl(vFa, 4);
            vFa = _mm256_insert_epi32_rpl(vFa, -open, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi32(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
                {
                    __m256i vTAll;
                    __m256i vT;
                    __m256i case1;
                    __m256i case2;
                    __m256i cond;
                    vHp = _mm256_add_epi32(vHp, _mm256_load_si256(vP + i));
                    vHp = _mm256_max_epi32(vHp, vZero);
                    case1 = _mm256_cmpeq_epi32(vH, vHp);
                    case2 = _mm256_cmpeq_epi32(vH, vF);
                    cond = _mm256_andnot_si256(case1,case2);
                    vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    vT = _mm256_load_si256(pvHT + i);
                    vT = _mm256_blendv_epi8(vT, vTDel, cond);
                    _mm256_store_si256(pvHT + i, vT);
                    vTAll = _mm256_and_si256(vTAll, vTMask);
                    vTAll = _mm256_or_si256(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vMaxH = _mm256_max_epi32(vH, vMaxH);
                /* Update vF value. */
                {
                    __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vFa_ext);
                    __m256i vT = _mm256_blendv_epi8(vTDelF, vTDiagF, cond);
                    vTAll = _mm256_and_si256(vTAll, vFTMask);
                    vTAll = _mm256_or_si256(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vEF_opn = _mm256_sub_epi32(vH, vGapO);
                vF_ext = _mm256_sub_epi32(vF, vGapE);
                {
                    __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                    __m256i vEa_ext = _mm256_sub_epi32(vEa, vGapE);
                    vEa = _mm256_max_epi32(vEF_opn, vEa_ext);
                    _mm256_store_si256(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vEa_ext);
                        __m256i vT = _mm256_blendv_epi8(vTInsE, vTDiagE, cond);
                        arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                    }
                }
                if (! _mm256_movemask_epi8(
                            _mm256_or_si256(
                                _mm256_cmpgt_epi32(vF_ext, vEF_opn),
                                _mm256_cmpeq_epi32(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm256_max_epi32(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm256_sub_epi32(vFa, vGapE);
                vFa = _mm256_max_epi32(vEF_opn, vFa_ext);
                vHp = _mm256_load_si256(pvHLoad + i);
            }
        }
end:
        {
        }

        {
            __m256i vCompare = _mm256_cmpgt_epi32(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi32_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm256_set1_epi32(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

    if (score == INT32_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = 0;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            SWAP(pvHMax,  pvHStore)
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            SWAP(pvHMax,  pvHLoad)
        }
        /* Trace the alignment ending position on read. */
        {
            int32_t *t = (int32_t*)pvHMax;
            int32_t column_len = segLen * segWidth;
            end_query = s1Len - 1;
            for (i = 0; i<column_len; ++i, ++t) {
                if (*t == score) {
                    int32_t temp = i / segWidth + i % segWidth * segLen;
                    if (temp < end_query) {
                        end_query = temp;
                    }
                }
            }
        }
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(pvHMax);
    parasail_free(pvHT);
    parasail_free(pvEaLoad);
    parasail_free(pvEaStore);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rsi, 0x48(%rsp)
testq %rdi, %rdi
je 0x5c279a
movq 0x48(%rdi), %rax
movq %rax, 0xb0(%rsp)
testq %rax, %rax
je 0x5c27a1
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x5c27a8
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x5c27af
cmpq $0x0, 0x48(%rsp)
je 0x5c27b6
movl %edx, %r15d
testl %edx, %edx
jle 0x5c27bd
movl %ecx, %r12d
testl %ecx, %ecx
js 0x5c27c4
testl %r8d, %r8d
js 0x5c27cb
movl %r8d, 0x70(%rsp)
leaq 0x7(%r13), %rbp
movq %rbp, %r14
shrq $0x3, %r14
movl $0x7ffffffe, %ecx       # imm = 0x7FFFFFFE
movq 0x40(%rsp), %rax
subl 0x1c(%rax), %ecx
movl %ecx, 0x3c(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r14d, %edi
movl %r15d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x5c27d0
movq %rax, %rbx
movq %r13, 0x90(%rsp)
movq %r15, 0x30(%rsp)
movq %rbp, 0x98(%rsp)
orl $0x8480804, 0xc(%rax)   # imm = 0x8480804
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r15
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x28(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x50(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x10(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r13
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %rcx
xorl %eax, %eax
testq %r15, %r15
je 0x5c27d2
testq %rbp, %rbp
je 0x5c27d2
cmpq $0x0, 0x28(%rsp)
je 0x5c27d2
movq 0x50(%rsp), %rdx
testq %rdx, %rdx
je 0x5c27d2
cmpq $0x0, 0x10(%rsp)
je 0x5c27d2
testq %r13, %r13
je 0x5c27d2
testq %rcx, %rcx
je 0x5c27d2
movq %rcx, 0x20(%rsp)
vmovd %r12d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0xe0(%rsp)
vmovss 0x70(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0xc0(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f190d
negl %r12d
vmovd %r12d, %xmm0
vmovdqu %ymm0, 0x140(%rsp)
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x70(%rsp)
movq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x4f190d
movq 0x50(%rsp), %rdi
vmovups 0x70(%rsp), %ymm0
movq %r14, %rsi
callq 0x4f190d
movq %r14, %rax
shlq $0x5, %rax
xorl %ecx, %ecx
vpbroadcastq 0x6de6f(%rip), %ymm0 # 0x62ffc8
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
vmovdqa %ymm0, (%rdx,%rcx)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x5c2159
vpxor %xmm0, %xmm0, %xmm0
vpsubd 0xe0(%rsp), %ymm0, %ymm1
vmovdqu %ymm1, 0x120(%rsp)
leal -0x1(%r14), %eax
movl 0x30(%rsp), %ecx
movl %r14d, %esi
movq %rsi, 0xa0(%rsp)
shlq $0x5, %rsi
xorl %r8d, %r8d
shlq $0x5, %rax
movq %rax, 0xa8(%rsp)
vpbroadcastd 0x6db7d(%rip), %ymm2 # 0x62fd30
vpbroadcastd 0x6ba04(%rip), %ymm3 # 0x62dbc0
vbroadcastsd 0x6de0b(%rip), %ymm5 # 0x62ffd0
vbroadcastss 0x6be12(%rip), %ymm6 # 0x62dfe0
vbroadcastss 0x6db55(%rip), %ymm7 # 0x62fd2c
vpbroadcastq 0x6ddf8(%rip), %ymm8 # 0x62ffd8
movq %rsi, 0x70(%rsp)
xorl %r10d, %r10d
movl $0x0, 0xc(%rsp)
movl $0xc0000000, 0x8(%rsp)  # imm = 0xC0000000
vpxor %xmm10, %xmm10, %xmm10
vpxor %xmm9, %xmm9, %xmm9
vmovdqu 0xc0(%rsp), %ymm4
movq 0x50(%rsp), %rax
vmovdqu %ymm3, 0x100(%rsp)
movq 0x20(%rsp), %r11
movq %r11, 0x50(%rsp)
movq 0x10(%rsp), %r12
movq %rax, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq %r15, %rbp
movq %r10, %rax
movq 0xa8(%rsp), %rdi
leaq (%r15,%rdi), %rdx
movq %rdx, 0xb8(%rsp)
movq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x48(%rsp), %r9
movzbl (%r9,%r10), %r10d
movslq (%rdx,%r10,4), %r10
movq 0xa0(%rsp), %rdx
imulq %r10, %rdx
shlq $0x5, %rdx
addq 0xb0(%rsp), %rdx
leal -0x2(%rax), %r10d
cmpl %r10d, 0xc(%rsp)
movq 0x18(%rsp), %r15
cmoveq %r15, %r11
movq %r11, 0x20(%rsp)
cmoveq 0x50(%rsp), %r15
vmovdqa (%rbp,%rdi), %ymm1
vperm2i128 $0x28, %ymm1, %ymm1, %ymm11 # ymm11 = zero,zero,ymm1[0,1]
vpalignr $0xc, %ymm11, %ymm1, %ymm1 # ymm1 = ymm11[12,13,14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11],ymm11[28,29,30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
movq %rax, 0x18(%rsp)
leaq 0x1(%rax), %r10
movl $0x1, %eax
xorl %edi, %edi
vmovdqu 0x120(%rsp), %ymm12
movq %r14, %r9
movq 0x28(%rsp), %r14
vmovdqa (%r14,%rdi), %ymm11
vpaddd (%rdx,%rdi), %ymm1, %ymm1
vpmaxsd %ymm0, %ymm1, %ymm1
vpmaxsd %ymm11, %ymm1, %ymm13
vpmaxsd %ymm12, %ymm13, %ymm14
vmovdqa %ymm14, (%r15,%rdi)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
vpcmpeqd %ymm1, %ymm14, %ymm1
vpcmpgtd %ymm12, %ymm13, %ymm13
vpaddd %ymm2, %ymm13, %ymm13
vpcmpgtd %ymm0, %ymm14, %ymm15
vpand %ymm3, %ymm15, %ymm15
vblendvps %ymm1, %ymm15, %ymm13, %ymm1
vorps (%rdi,%r11), %ymm1, %ymm13
vmovaps %ymm1, (%r13,%rdi)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
vmovaps %ymm13, (%rdi,%r11)
vpsubd 0xe0(%rsp), %ymm14, %ymm13
vpsubd %ymm4, %ymm11, %ymm1
vpmaxsd %ymm1, %ymm13, %ymm1
vmovdqa %ymm1, (%r14,%rdi)
movq 0x10(%rsp), %r11
vmovdqa (%r11,%rdi), %ymm1
vpsubd %ymm4, %ymm1, %ymm1
vpmaxsd %ymm1, %ymm13, %ymm11
vmovdqa %ymm11, (%r12,%rdi)
cmpq %rcx, %r10
jae 0x5c2392
vpcmpgtd %ymm1, %ymm13, %ymm1
vbroadcastss 0x6b96f(%rip), %ymm11 # 0x62dce0
vbroadcastss 0x6bada(%rip), %ymm15 # 0x62de54
vblendvps %ymm1, %ymm11, %ymm15, %ymm1
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq 0x70(%rsp), %r11
vmovaps %ymm1, (%rdi,%r11)
vpsubd %ymm4, %ymm12, %ymm15
movq %r9, %r14
cmpq %r9, %rax
jae 0x5c23c1
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
vpcmpgtd %ymm15, %ymm13, %ymm1
vblendvps %ymm1, %ymm6, %ymm7, %ymm1
vorps 0x20(%rdi,%r11), %ymm1, %ymm1
vmovaps %ymm1, 0x20(%rdi,%r11)
vpmaxsd %ymm10, %ymm14, %ymm10
vpmaxsd %ymm15, %ymm13, %ymm12
vmovdqa (%rbp,%rdi), %ymm1
addq $0x20, %rdi
incq %rax
cmpq %rdi, %rsi
jne 0x5c22c3
vmovdqu %ymm9, 0x50(%rsp)
xorl %eax, %eax
vmovdqa %ymm12, %ymm14
movq 0xb8(%rsp), %r9
vpmovsxbd 0x6b8d9(%rip), %ymm1 # 0x62dcd8
vmovdqa %ymm8, %ymm3
vmovaps %ymm5, %ymm8
vmovdqa %ymm1, %ymm5
vpermd %ymm14, %ymm1, %ymm1
vmovdqu 0x140(%rsp), %ymm9
vpblendd $0x1, %ymm9, %ymm1, %ymm14 # ymm14 = ymm9[0],ymm1[1,2,3,4,5,6,7]
vpermd %ymm15, %ymm5, %ymm1
movl $0xc0000000, %edi       # imm = 0xC0000000
vmovd %edi, %xmm11
vpblendd $0x1, %ymm11, %ymm1, %ymm15 # ymm15 = ymm11[0],ymm1[1,2,3,4,5,6,7]
vpermd %ymm12, %ymm5, %ymm1
vpblendd $0x1, %ymm9, %ymm1, %ymm12 # ymm12 = ymm9[0],ymm1[1,2,3,4,5,6,7]
vpermd %ymm13, %ymm5, %ymm1
vmovaps %ymm8, %ymm5
vmovdqa %ymm3, %ymm8
vpcmpeqd %ymm3, %ymm3, %ymm3
vpblendd $0x1, %ymm9, %ymm1, %ymm13 # ymm13 = ymm9[0],ymm1[1,2,3,4,5,6,7]
vmovdqa (%r9), %ymm1
vperm2i128 $0x28, %ymm1, %ymm1, %ymm11 # ymm11 = zero,zero,ymm1[0,1]
vpalignr $0xc, %ymm11, %ymm1, %ymm11 # ymm11 = ymm11[12,13,14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11],ymm11[28,29,30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
xorl %edi, %edi
vmovdqa %ymm4, %ymm9
vmovdqa (%r15,%rdi), %ymm4
vpmaxsd %ymm12, %ymm4, %ymm1
vmovdqa %ymm1, (%r15,%rdi)
vpaddd (%rdx,%rdi), %ymm11, %ymm11
vpmaxsd %ymm0, %ymm11, %ymm11
vpcmpeqd %ymm1, %ymm11, %ymm11
vpcmpgtd %ymm12, %ymm4, %ymm4
vpor %ymm4, %ymm11, %ymm4
movq 0x10(%rbx), %r11
vblendvps %ymm4, (%r13,%rdi), %ymm2, %ymm4
movq (%r11), %r11
addq %r8, %r11
vandps (%rdi,%r11), %ymm5, %ymm11
vmovaps %ymm4, (%r13,%rdi)
vorps %ymm4, %ymm11, %ymm4
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
vmovaps %ymm4, (%rdi,%r11)
vpcmpgtd %ymm15, %ymm13, %ymm4
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
vblendvps %ymm4, %ymm6, %ymm7, %ymm4
vpand (%rdi,%r11), %ymm8, %ymm11
vpor %ymm4, %ymm11, %ymm4
vmovdqa %ymm4, (%rdi,%r11)
vpsubd 0xe0(%rsp), %ymm1, %ymm13
movq 0x10(%rsp), %r11
vmovdqa (%r11,%rdi), %ymm4
vpsubd %ymm9, %ymm4, %ymm11
vpmaxsd %ymm11, %ymm13, %ymm4
vmovdqa %ymm4, (%r12,%rdi)
cmpq %rcx, %r10
jae 0x5c2544
vpcmpgtd %ymm11, %ymm13, %ymm4
vbroadcastss 0x6b7bd(%rip), %ymm11 # 0x62dce0
vbroadcastss 0x6b928(%rip), %ymm15 # 0x62de54
vblendvps %ymm4, %ymm11, %ymm15, %ymm4
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq 0x70(%rsp), %r11
vmovaps %ymm4, (%rdi,%r11)
vpmaxsd %ymm10, %ymm1, %ymm10
vmovdqu 0xc0(%rsp), %ymm4
vpsubd %ymm4, %ymm12, %ymm12
vpcmpgtd %ymm12, %ymm13, %ymm1
vtestps %ymm3, %ymm1
jb 0x5c2589
vpsubd %ymm4, %ymm14, %ymm15
vpmaxsd %ymm15, %ymm13, %ymm14
vmovdqa (%rbp,%rdi), %ymm11
addq $0x20, %rdi
cmpq %rdi, %rsi
jne 0x5c2468
incl %eax
cmpl $0x8, %eax
jne 0x5c23f6
vmovdqu 0x50(%rsp), %ymm9
vpcmpgtd %ymm9, %ymm10, %ymm1
vtestps %ymm1, %ymm1
je 0x5c25fb
vpermq $0x44, %ymm10, %ymm1    # ymm1 = ymm10[0,1,0,1]
vpmaxsd %ymm1, %ymm10, %ymm1
vpslldq $0x8, %ymm1, %ymm4      # ymm4 = zero,zero,zero,zero,zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23]
vpmaxsd %ymm4, %ymm1, %ymm1
vpslldq $0x4, %ymm1, %ymm4      # ymm4 = zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vpmaxsd %ymm4, %ymm1, %ymm1
vextracti128 $0x1, %ymm1, %xmm4
vpextrd $0x3, %xmm4, %eax
movl %eax, 0x8(%rsp)
cmpl 0x3c(%rsp), %eax
vmovdqu 0x100(%rsp), %ymm3
jg 0x5c261a
vpbroadcastd 0x6b78e(%rip), %ymm4 # 0x62dd70
vpermd %ymm1, %ymm4, %ymm9
movq 0x18(%rsp), %rax
movl %eax, 0xc(%rsp)
vmovdqu 0xc0(%rsp), %ymm4
jmp 0x5c2604
vmovdqu 0x100(%rsp), %ymm3
addq %rsi, 0x70(%rsp)
addq %rsi, %r8
movq %r12, %rax
cmpq %rcx, %r10
jne 0x5c2219
jmp 0x5c2628
orb $0x40, 0xc(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x7fffffff, 0x8(%rsp)  # imm = 0x7FFFFFFF
jne 0x5c2636
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
vzeroupper
callq 0x20be2e
xorl %ecx, %ecx
testl %eax, %eax
je 0x5c26a0
xorl %r9d, %r9d
movq 0x20(%rsp), %rdi
xorl %r8d, %r8d
movl %r9d, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq 0x10(%rsp), %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq 0x28(%rsp), %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %rbx, %rax
jmp 0x5c27d2
movq 0x30(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0xc(%rsp), %r8d
cmpl %ecx, %r8d
movq 0x20(%rsp), %rcx
movq %rcx, %rdi
cmoveq %rbp, %rdi
movq %rbp, %rdx
cmoveq %rcx, %rdx
cmpl %eax, %r8d
cmoveq %r15, %rdi
cmoveq %rbp, %rdx
movq %rdx, %rbp
cmoveq %rcx, %r15
movq 0x90(%rsp), %rax
movl %eax, %ecx
decl %ecx
movq 0x98(%rsp), %rsi
testl $0x7ffffff8, %esi       # imm = 0x7FFFFFF8
je 0x5c27e4
andl $0x7ffffff8, %esi       # imm = 0x7FFFFFF8
movl 0x8(%rsp), %r9d
je 0x5c27ee
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovd %r9d, %xmm1
vpbroadcastd %xmm1, %ymm1
vmovd %r14d, %xmm2
vpbroadcastd %xmm2, %ymm2
vpmovsxbd 0x6be49(%rip), %ymm3 # 0x62e578
xorl %eax, %eax
vpbroadcastd 0x6b636(%rip), %ymm4 # 0x62dd70
vpbroadcastd 0x6b59d(%rip), %ymm5 # 0x62dce0
vpcmpeqd (%rdi,%rax,4), %ymm1, %ymm6
vpsrld $0x3, %ymm3, %ymm7
vpand %ymm4, %ymm3, %ymm8
vpmulld %ymm2, %ymm8, %ymm8
vpaddd %ymm7, %ymm8, %ymm7
vpminsd %ymm0, %ymm7, %ymm7
vblendvps %ymm6, %ymm7, %ymm0, %ymm0
addq $0x8, %rax
vpaddd %ymm5, %ymm3, %ymm3
cmpq %rax, %rsi
jne 0x5c2743
vextracti128 $0x1, %ymm0, %xmm1
vpminsd %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpminsd %xmm1, %xmm0, %xmm0
vpshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
vpminsd %xmm1, %xmm0, %xmm0
vmovd %xmm0, %ecx
jmp 0x5c2652
callq 0x1faaeb
jmp 0x5c27d0
callq 0x1faac5
jmp 0x5c27d0
callq 0x1faa9f
jmp 0x5c27d0
callq 0x1faa79
jmp 0x5c27d0
callq 0x1faa53
jmp 0x5c27d0
callq 0x1faa2d
jmp 0x5c27d0
callq 0x1faa07
jmp 0x5c27d0
callq 0x1fa9e1
xorl %eax, %eax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsp), %r9d
jmp 0x5c2652
xorl %eax, %eax
movl %ecx, %edx
movl %eax, %ecx
shrl $0x3, %ecx
cmpl %edx, %ecx
cmovgel %edx, %ecx
cmpl %r9d, (%rdi,%rax,4)
cmovnel %edx, %ecx
incq %rax
cmpl %eax, %esi
jne 0x5c27f0
jmp 0x5c2652
nop