// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_striped_avx2_256_8.c
// Function: parasail_sw_trace_striped_profile_avx2_256_8
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;
    int8_t score = 0;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int8_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->profile8.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 = 32; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m256i*)profile->profile8.score;
    vGapO = _mm256_set1_epi8(open);
    vGapE = _mm256_set1_epi8(gap);
    vZero = _mm256_setzero_si256();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT8_MAX - (int8_t)(matrix->max+1);
    vTZero = _mm256_set1_epi8(PARASAIL_ZERO);
    vTIns  = _mm256_set1_epi8(PARASAIL_INS);
    vTDel  = _mm256_set1_epi8(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi8(PARASAIL_DIAG);
    vTDiagE= _mm256_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi8(PARASAIL_INS_E);
    vTDiagF= _mm256_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi8(PARASAIL_DEL_F);
    vTMask = _mm256_set1_epi8(PARASAIL_ZERO_MASK);
    vFTMask= _mm256_set1_epi8(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_8 | PARASAIL_FLAG_LANES_32;

    /* 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_epi8(-open), segLen);
    parasail_memset___m256i(pvEaStore, _mm256_set1_epi8(-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_subs_epi8(vZero,vGapO);

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

        /* 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_adds_epi8(vH, _mm256_load_si256(vP + i));
            vH_dag = _mm256_max_epi8(vH_dag, vZero);
            vH = _mm256_max_epi8(vH_dag, vE);
            vH = _mm256_max_epi8(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_epi8(vH, vZero);
                __m256i case1 = _mm256_cmpeq_epi8(vH, vH_dag);
                __m256i case2 = _mm256_cmpeq_epi8(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_epi8(vH, vMaxH);
            vEF_opn = _mm256_subs_epi8(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm256_subs_epi8(vE, vGapE);
            vE = _mm256_max_epi8(vEF_opn, vE_ext);
            _mm256_store_si256(pvE + i, vE);
            {
                __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                __m256i vEa_ext = _mm256_subs_epi8(vEa, vGapE);
                vEa = _mm256_max_epi8(vEF_opn, vEa_ext);
                _mm256_store_si256(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m256i cond = _mm256_cmpgt_epi8(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_subs_epi8(vF, vGapE);
            vF = _mm256_max_epi8(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m256i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m256i cond = _mm256_cmpgt_epi8(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, 1);
            vEF_opn = _mm256_slli_si256_rpl(vEF_opn, 1);
            vEF_opn = _mm256_insert_epi8_rpl(vEF_opn, -open, 0);
            vF_ext = _mm256_slli_si256_rpl(vF_ext, 1);
            vF_ext = _mm256_insert_epi8_rpl(vF_ext, NEG_INF, 0);
            vF = _mm256_slli_si256_rpl(vF, 1);
            vF = _mm256_insert_epi8_rpl(vF, -open, 0);
            vFa_ext = _mm256_slli_si256_rpl(vFa_ext, 1);
            vFa_ext = _mm256_insert_epi8_rpl(vFa_ext, NEG_INF, 0);
            vFa = _mm256_slli_si256_rpl(vFa, 1);
            vFa = _mm256_insert_epi8_rpl(vFa, -open, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi8(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
                {
                    __m256i vTAll;
                    __m256i vT;
                    __m256i case1;
                    __m256i case2;
                    __m256i cond;
                    vHp = _mm256_adds_epi8(vHp, _mm256_load_si256(vP + i));
                    vHp = _mm256_max_epi8(vHp, vZero);
                    case1 = _mm256_cmpeq_epi8(vH, vHp);
                    case2 = _mm256_cmpeq_epi8(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_epi8(vH, vMaxH);
                /* Update vF value. */
                {
                    __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m256i cond = _mm256_cmpgt_epi8(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_subs_epi8(vH, vGapO);
                vF_ext = _mm256_subs_epi8(vF, vGapE);
                {
                    __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                    __m256i vEa_ext = _mm256_subs_epi8(vEa, vGapE);
                    vEa = _mm256_max_epi8(vEF_opn, vEa_ext);
                    _mm256_store_si256(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m256i cond = _mm256_cmpgt_epi8(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_epi8(vF_ext, vEF_opn),
                                _mm256_cmpeq_epi8(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm256_max_epi8(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm256_subs_epi8(vFa, vGapE);
                vFa = _mm256_max_epi8(vEF_opn, vFa_ext);
                vHp = _mm256_load_si256(pvHLoad + i);
            }
        }
end:
        {
        }

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

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

    if (score == INT8_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. */
        {
            int8_t *t = (int8_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 $0x138, %rsp            # imm = 0x138
movq %rsi, 0x58(%rsp)
testq %rdi, %rdi
je 0x5c8e3e
movq 0x18(%rdi), %rax
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x5c8e45
movq 0x10(%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x5c8e4c
movl 0x8(%rdi), %ebp
testl %ebp, %ebp
jle 0x5c8e53
cmpq $0x0, 0x58(%rsp)
je 0x5c8e5a
movl %edx, %r13d
testl %edx, %edx
jle 0x5c8e61
testl %ecx, %ecx
js 0x5c8e68
testl %r8d, %r8d
js 0x5c8e6f
movl %r8d, 0x60(%rsp)
movl %ecx, 0x10(%rsp)
leaq 0x1f(%rbp), %r15
movq %r15, %r14
shrq $0x5, %r14
movq 0x50(%rsp), %rax
movl 0x1c(%rax), %r12d
movl $0x20, %edx
movl $0x20, %ecx
movl %r14d, %edi
movl %r13d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x5c8e74
movq %rax, %rbx
movq %r13, 0x40(%rsp)
movq %r15, 0x80(%rsp)
movq %rbp, 0x88(%rsp)
orl $0x20180804, 0xc(%rax)  # imm = 0x20180804
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, 0x38(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x20(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x18(%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 0x5c8ee5
testq %rbp, %rbp
je 0x5c8ee5
cmpq $0x0, 0x38(%rsp)
je 0x5c8ee5
movq 0x20(%rsp), %rdx
testq %rdx, %rdx
je 0x5c8ee5
cmpq $0x0, 0x18(%rsp)
je 0x5c8ee5
testq %r13, %r13
je 0x5c8ee5
testq %rcx, %rcx
je 0x5c8ee5
movl %r12d, 0xb0(%rsp)
movq %rcx, 0x30(%rsp)
movl 0x10(%rsp), %r12d
vmovd %r12d, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0xf0(%rsp)
vmovd 0x60(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0xd0(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f190d
negb %r12b
movl %r12d, 0x10(%rsp)
vmovd %r12d, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x60(%rsp)
movq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x4f190d
movq 0x20(%rsp), %rdi
vmovups 0x60(%rsp), %ymm0
movq %r14, %rsi
callq 0x4f190d
movq %r14, %rax
shlq $0x5, %rax
xorl %ecx, %ecx
vpbroadcastq 0x678cb(%rip), %ymm0 # 0x6300e0
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
vmovdqa %ymm0, (%rdx,%rcx)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x5c8815
vpxor %xmm0, %xmm0, %xmm0
vpsubsb 0xf0(%rsp), %ymm0, %ymm1
vmovdqu %ymm1, 0x110(%rsp)
leal -0x1(%r14), %ecx
movb $0x7e, %al
subb 0xb0(%rsp), %al
movsbl %al, %eax
movl %eax, 0x4c(%rsp)
movl 0x40(%rsp), %edx
movl %r14d, %edi
movq %rdi, 0x90(%rsp)
shlq $0x5, %rdi
movb $-0x80, %al
movl %eax, 0xc(%rsp)
xorl %r8d, %r8d
shlq $0x5, %rcx
movq %rcx, 0x98(%rsp)
vpbroadcastb 0x678dd(%rip), %ymm2 # 0x630162
vpbroadcastb 0x678d5(%rip), %ymm3 # 0x630163
vpbroadcastq 0x67851(%rip), %ymm4 # 0x6300e8
vpbroadcastb 0x678c6(%rip), %ymm5 # 0x630166
vpbroadcastb 0x678be(%rip), %ymm6 # 0x630167
vpbroadcastq 0x6783e(%rip), %ymm7 # 0x6300f0
movq %rdi, 0x60(%rsp)
xorl %r11d, %r11d
movl $0x0, 0x14(%rsp)
vpxor %xmm8, %xmm8, %xmm8
vpxor %xmm9, %xmm9, %xmm9
vmovdqu 0xd0(%rsp), %ymm1
movq 0x20(%rsp), %rax
vmovdqu %ymm9, 0xb0(%rsp)
movq 0x30(%rsp), %r10
movq %r10, 0x28(%rsp)
movq 0x18(%rsp), %r12
movq %rax, 0x18(%rsp)
movq %rbp, 0xa8(%rsp)
movq %r15, %rbp
movq %r11, %rax
movq 0x98(%rsp), %r9
leaq (%r15,%r9), %rcx
movq %rcx, 0x20(%rsp)
movq 0x50(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x58(%rsp), %rcx
movzbl (%rcx,%r11), %r11d
movslq (%rsi,%r11,4), %r11
movq 0x90(%rsp), %rsi
imulq %r11, %rsi
shlq $0x5, %rsi
addq 0xa0(%rsp), %rsi
leal -0x2(%rax), %r11d
cmpl %r11d, 0x14(%rsp)
movq 0xa8(%rsp), %r15
cmoveq %r15, %r10
movq %r10, 0x30(%rsp)
cmoveq 0x28(%rsp), %r15
vmovdqa (%rbp,%r9), %ymm10
vperm2i128 $0x28, %ymm10, %ymm10, %ymm11 # ymm11 = zero,zero,ymm10[0,1]
vpalignr $0xf, %ymm11, %ymm10, %ymm13 # ymm13 = ymm11[15],ymm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm11[31],ymm10[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
movq %rax, 0x28(%rsp)
leaq 0x1(%rax), %r11
movl $0x1, %eax
xorl %r9d, %r9d
vmovdqu 0x110(%rsp), %ymm10
movq %r14, %r10
movq 0x38(%rsp), %r14
vmovdqa (%r14,%r9), %ymm12
vpaddsb (%rsi,%r9), %ymm13, %ymm11
vpmaxsb %ymm0, %ymm11, %ymm11
vpmaxsb %ymm12, %ymm11, %ymm14
vpmaxsb %ymm10, %ymm14, %ymm13
vmovdqa %ymm13, (%r15,%r9)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vpcmpeqb %ymm11, %ymm13, %ymm11
vpcmpgtb %ymm10, %ymm14, %ymm14
vpaddb %ymm2, %ymm14, %ymm14
vpcmpgtb %ymm0, %ymm13, %ymm15
vpand %ymm3, %ymm15, %ymm15
vpblendvb %ymm11, %ymm15, %ymm14, %ymm11
vpor (%r9,%rcx), %ymm11, %ymm14
vmovdqa %ymm11, (%r13,%r9)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vmovdqa %ymm14, (%r9,%rcx)
vpsubsb 0xf0(%rsp), %ymm13, %ymm11
vpsubsb %ymm1, %ymm12, %ymm12
vpmaxsb %ymm12, %ymm11, %ymm12
vmovdqa %ymm12, (%r14,%r9)
movq 0x18(%rsp), %rcx
vmovdqa (%rcx,%r9), %ymm12
vpsubsb %ymm1, %ymm12, %ymm12
vpmaxsb %ymm12, %ymm11, %ymm14
vmovdqa %ymm14, (%r12,%r9)
cmpq %rdx, %r11
jae 0x5c8a64
vpbroadcastb 0x67726(%rip), %ymm14 # 0x630164
vpbroadcastb 0x6771e(%rip), %ymm15 # 0x630165
vpcmpgtb %ymm12, %ymm11, %ymm12
vpblendvb %ymm12, %ymm14, %ymm15, %ymm12
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq 0x60(%rsp), %rcx
vmovdqa %ymm12, (%r9,%rcx)
vpsubsb %ymm1, %ymm10, %ymm12
movq %r10, %r14
cmpq %r10, %rax
jae 0x5c8a93
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vpcmpgtb %ymm12, %ymm11, %ymm10
vpblendvb %ymm10, %ymm5, %ymm6, %ymm10
vpor 0x20(%r9,%rcx), %ymm10, %ymm10
vmovdqa %ymm10, 0x20(%r9,%rcx)
vpmaxsb %ymm8, %ymm13, %ymm8
vpmaxsb %ymm12, %ymm11, %ymm10
vmovdqa (%rbp,%r9), %ymm13
addq $0x20, %r9
incq %rax
cmpq %r9, %rdi
jne 0x5c8992
xorl %eax, %eax
vmovdqa %ymm10, %ymm13
movl 0x10(%rsp), %r10d
vinserti128 $0x1, %xmm13, %ymm0, %ymm14
vpalignr $0xf, %ymm14, %ymm13, %ymm13 # ymm13 = ymm14[15],ymm13[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm14[31],ymm13[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %r10d, %xmm13, %xmm14
vinserti128 $0x1, %xmm12, %ymm0, %ymm15
vpalignr $0xf, %ymm15, %ymm12, %ymm12 # ymm12 = ymm15[15],ymm12[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm15[31],ymm12[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
movl $0x80, %ecx
vpinsrb $0x0, %ecx, %xmm12, %xmm15
vpblendd $0xf, %ymm14, %ymm13, %ymm13 # ymm13 = ymm14[0,1,2,3],ymm13[4,5,6,7]
vpblendd $0xf, %ymm15, %ymm12, %ymm12 # ymm12 = ymm15[0,1,2,3],ymm12[4,5,6,7]
vinserti128 $0x1, %xmm10, %ymm0, %ymm14
vpalignr $0xf, %ymm14, %ymm10, %ymm10 # ymm10 = ymm14[15],ymm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm14[31],ymm10[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %r10d, %xmm10, %xmm14
vpblendd $0xf, %ymm14, %ymm10, %ymm10 # ymm10 = ymm14[0,1,2,3],ymm10[4,5,6,7]
vinserti128 $0x1, %xmm11, %ymm0, %ymm14
vpalignr $0xf, %ymm14, %ymm11, %ymm11 # ymm11 = ymm14[15],ymm11[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm14[31],ymm11[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %r10d, %xmm11, %xmm14
vpblendd $0xf, %ymm14, %ymm11, %ymm11 # ymm11 = ymm14[0,1,2,3],ymm11[4,5,6,7]
movq 0x20(%rsp), %rcx
vmovdqa (%rcx), %ymm14
vperm2i128 $0x28, %ymm14, %ymm14, %ymm15 # ymm15 = zero,zero,ymm14[0,1]
vpalignr $0xf, %ymm15, %ymm14, %ymm15 # ymm15 = ymm15[15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm15[31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
xorl %r9d, %r9d
vmovdqa %ymm1, %ymm9
vmovdqa (%r15,%r9), %ymm1
vpmaxsb %ymm10, %ymm1, %ymm14
vmovdqa %ymm14, (%r15,%r9)
vpaddsb (%rsi,%r9), %ymm15, %ymm15
vpmaxsb %ymm0, %ymm15, %ymm15
vpcmpeqb %ymm15, %ymm14, %ymm15
vpcmpgtb %ymm10, %ymm1, %ymm1
vpor %ymm1, %ymm15, %ymm1
movq 0x10(%rbx), %rcx
vpblendvb %ymm1, (%r13,%r9), %ymm2, %ymm1
movq (%rcx), %rcx
addq %r8, %rcx
vpand (%r9,%rcx), %ymm4, %ymm15
vmovdqa %ymm1, (%r13,%r9)
vpor %ymm1, %ymm15, %ymm1
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vmovdqa %ymm1, (%r9,%rcx)
vpcmpgtb %ymm12, %ymm11, %ymm1
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vpblendvb %ymm1, %ymm5, %ymm6, %ymm1
vpand (%r9,%rcx), %ymm7, %ymm11
vpor %ymm1, %ymm11, %ymm1
vmovdqa %ymm1, (%r9,%rcx)
vpsubsb 0xf0(%rsp), %ymm14, %ymm11
movq 0x18(%rsp), %rcx
vmovdqa (%rcx,%r9), %ymm1
vpsubsb %ymm9, %ymm1, %ymm12
vpmaxsb %ymm12, %ymm11, %ymm1
vmovdqa %ymm1, (%r12,%r9)
cmpq %rdx, %r11
jae 0x5c8c1b
vpbroadcastb 0x6756f(%rip), %ymm1 # 0x630164
vpbroadcastb 0x67567(%rip), %ymm15 # 0x630165
vpcmpgtb %ymm12, %ymm11, %ymm12
vpblendvb %ymm12, %ymm1, %ymm15, %ymm1
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq 0x60(%rsp), %rcx
vmovdqa %ymm1, (%r9,%rcx)
vpmaxsb %ymm8, %ymm14, %ymm8
vmovdqu 0xd0(%rsp), %ymm9
vpsubsb %ymm9, %ymm10, %ymm10
vpcmpgtb %ymm10, %ymm11, %ymm1
vpmovmskb %ymm1, %ecx
cmpl $-0x1, %ecx
je 0x5c8c69
vmovdqa %ymm9, %ymm1
vpsubsb %ymm9, %ymm13, %ymm12
vpmaxsb %ymm12, %ymm11, %ymm13
vmovdqa (%rbp,%r9), %ymm15
addq $0x20, %r9
cmpq %r9, %rdi
jne 0x5c8b3d
incl %eax
cmpl $0x20, %eax
jne 0x5c8ac0
vmovdqu 0xb0(%rsp), %ymm9
vpcmpgtb %ymm9, %ymm8, %ymm1
vpmovmskb %ymm1, %eax
testl %eax, %eax
je 0x5c8ce8
vpermq $0x44, %ymm8, %ymm1     # ymm1 = ymm8[0,1,0,1]
vpmaxsb %ymm1, %ymm8, %ymm1
vpslldq $0x8, %ymm1, %ymm9      # ymm9 = 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]
vpmaxsb %ymm9, %ymm1, %ymm1
vpslldq $0x4, %ymm1, %ymm9      # ymm9 = 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]
vpmaxsb %ymm9, %ymm1, %ymm1
vpslldq $0x2, %ymm1, %ymm9      # ymm9 = zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpmaxsb %ymm9, %ymm1, %ymm1
vpslldq $0x1, %ymm1, %ymm9      # ymm9 = zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpmaxsb %ymm9, %ymm1, %ymm9
vextracti128 $0x1, %ymm9, %xmm1
vpextrb $0xf, %xmm1, %eax
movl %eax, 0xc(%rsp)
movsbl %al, %eax
cmpl %eax, 0x4c(%rsp)
jl 0x5c8d07
vpbroadcastb 0x67494(%rip), %ymm1 # 0x630168
vpshufb %ymm1, %ymm9, %ymm1
vpermq $0xaa, %ymm1, %ymm9     # ymm9 = ymm1[2,2,2,2]
movq 0x28(%rsp), %rax
movl %eax, 0x14(%rsp)
addq %rdi, 0x60(%rsp)
addq %rdi, %r8
movq %r12, %rax
cmpq %rdx, %r11
vmovdqu 0xd0(%rsp), %ymm1
jne 0x5c88da
jmp 0x5c8d15
orb $0x40, 0xc(%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpb $0x7f, 0xc(%rsp)
jne 0x5c8d20
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
vzeroupper
callq 0x20be2e
xorl %ecx, %ecx
testl %eax, %eax
je 0x5c8d40
movq 0x30(%rsp), %rdi
xorl %r8d, %r8d
xorl %edx, %edx
jmp 0x5c8e9d
movq 0x40(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0x14(%rsp), %r8d
cmpl %ecx, %r8d
movq 0x30(%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 0x88(%rsp), %rdx
decl %edx
movq 0x80(%rsp), %rsi
testl $0x7fffffe0, %esi       # imm = 0x7FFFFFE0
je 0x5c8e78
andl $0x7fffffe0, %esi       # imm = 0x7FFFFFE0
movl 0xc(%rsp), %r9d
je 0x5c8e7f
vmovd %edx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovd %r9d, %xmm1
vpbroadcastb %xmm1, %xmm1
vmovd %r14d, %xmm2
vpbroadcastd %xmm2, %ymm2
vpmovsxbd 0x657ab(%rip), %ymm3 # 0x62e578
xorl %eax, %eax
vpbroadcastd 0x652a8(%rip), %ymm4 # 0x62e080
vpbroadcastd 0x64eff(%rip), %ymm5 # 0x62dce0
vmovq (%rdi,%rax), %xmm6
vpcmpeqb %xmm1, %xmm6, %xmm6
vpmovsxbd %xmm6, %ymm6
vpsrld $0x5, %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 0x5c8de1
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, %edx
jmp 0x5c8e99
callq 0x1fb847
jmp 0x5c8e74
callq 0x1fb821
jmp 0x5c8e74
callq 0x1fb7fb
jmp 0x5c8e74
callq 0x1fb7d5
jmp 0x5c8e74
callq 0x1fb7af
jmp 0x5c8e74
callq 0x1fb789
jmp 0x5c8e74
callq 0x1fb763
jmp 0x5c8e74
callq 0x1fb73d
xorl %eax, %eax
jmp 0x5c8ee5
movl 0xc(%rsp), %r9d
jmp 0x5c8e99
xorl %eax, %eax
movl %eax, %ecx
shrl $0x5, %ecx
cmpl %edx, %ecx
cmovgel %edx, %ecx
cmpb %r9b, (%rdi,%rax)
cmovel %ecx, %edx
incq %rax
cmpl %eax, %esi
jne 0x5c8e81
movsbl %r9b, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq 0x18(%rsp), %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq 0x38(%rsp), %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop