// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_striped_avx2_256_8.c
// Function: parasail_nw_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 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 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;
    int8_t* restrict boundary = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    int8_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    parasail_result_t *result = NULL;
    __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;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 32; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m256i*)profile->profile8.score;
    vGapO = _mm256_set1_epi8(open);
    vGapE = _mm256_set1_epi8(gap);
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    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_NW | 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);
    boundary = parasail_memalign_int8_t(32, s2Len+1);

    /* 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 (!boundary) return NULL;

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

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

    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 -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        vF = vNegLimit;

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

        /* insert upper boundary condition */
        vH = _mm256_insert_epi8_rpl(vH, boundary[j], 0);

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

        /* 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 = _mm256_max_epi8(vH_dag, vE);
            vH = _mm256_max_epi8(vH, vF);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
            vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vF);

            {
                __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __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),
                        vTDiag, case1);
                _mm256_store_si256(pvHT + i, vT);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }

            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) {
            int64_t tmp = boundary[j+1]-open;
            int8_t tmp2 = tmp < INT8_MIN ? INT8_MIN : tmp;
            __m256i vHp = _mm256_load_si256(&pvHLoad[segLen - 1]);
            vHp = _mm256_slli_si256_rpl(vHp, 1);
            vHp = _mm256_insert_epi8_rpl(vHp, boundary[j], 0);
            vEF_opn = _mm256_slli_si256_rpl(vEF_opn, 1);
            vEF_opn = _mm256_insert_epi8_rpl(vEF_opn, tmp2, 0);
            vF_ext = _mm256_slli_si256_rpl(vF_ext, 1);
            vF_ext = _mm256_insert_epi8_rpl(vF_ext, NEG_LIMIT, 0);
            vF = _mm256_slli_si256_rpl(vF, 1);
            vF = _mm256_insert_epi8_rpl(vF, tmp2, 0);
            vFa_ext = _mm256_slli_si256_rpl(vFa_ext, 1);
            vFa_ext = _mm256_insert_epi8_rpl(vFa_ext, NEG_LIMIT, 0);
            vFa = _mm256_slli_si256_rpl(vFa, 1);
            vFa = _mm256_insert_epi8_rpl(vFa, tmp2, 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);
                vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
                {
                    __m256i vTAll;
                    __m256i vT;
                    __m256i case1;
                    __m256i case2;
                    __m256i cond;
                    vHp = _mm256_adds_epi8(vHp, _mm256_load_si256(vP + i));
                    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);
                }
                /* 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:
        {
        }
    }

    /* extract last value from the last column */
    {
        __m256i vH = _mm256_load_si256(pvHStore + offset);
        for (k=0; k<position; ++k) {
            vH = _mm256_slli_si256_rpl (vH, 1);
        }
        score = (int8_t) _mm256_extract_epi8_rpl (vH, 31);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi8_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi8(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(boundary);
    parasail_free(pvHT);
    parasail_free(pvEaLoad);
    parasail_free(pvEaStore);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x180, %rsp            # imm = 0x180
movl %ecx, 0x4(%rsp)
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x5936b6
movq 0x18(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x5936bd
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x5936c4
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
jle 0x5936cb
cmpq $0x0, 0x78(%rsp)
je 0x5936d2
movl %edx, %r12d
testl %edx, %edx
jle 0x5936d9
cmpl $0x0, 0x4(%rsp)
js 0x5936e0
testl %r8d, %r8d
js 0x5936e7
movl %r8d, 0x18(%rsp)
leal -0x1(%r14), %eax
addq $0x1f, %r14
shrq $0x5, %r14
movl %eax, 0x6c(%rsp)
cltd
idivl %r14d
movl %eax, 0x34(%rsp)
movl %edx, %r15d
movq 0x70(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %ecx
negb %cl
movzbl %cl, %esi
movl 0x4(%rsp), %ecx
movl %ecx, %r13d
negl %r13d
cmpl %r13d, %eax
cmovgl %ecx, %esi
movl %esi, 0x14(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movl %eax, 0x8(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r14d, %edi
movl %r12d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x5936ec
movq %rax, %rbx
movl %r15d, 0x68(%rsp)
orl $0x20180801, 0xc(%rax)  # imm = 0x20180801
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, 0x50(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, 0x20(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, 0x48(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, 0xa0(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, 0x28(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, %r15
movq %r12, 0x38(%rsp)
leal 0x1(%r12), %esi
movl $0x20, %edi
movq %rsi, 0xe0(%rsp)
callq 0x2094c8
movq 0x50(%rsp), %r11
testq %r11, %r11
sete %dl
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %dl, %cl
cmpq $0x0, 0x48(%rsp)
sete %sil
cmpq $0x0, 0xa0(%rsp)
sete %dl
orb %sil, %dl
orb %cl, %dl
cmpq $0x0, 0x28(%rsp)
sete %sil
testq %r15, %r15
sete %cl
orb %sil, %cl
testq %rax, %rax
sete %sil
orb %cl, %sil
orb %dl, %sil
testb $0x1, %sil
jne 0x5936ec
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rax
decl %eax
movl %eax, 0x30(%rsp)
movl $0x1f, %eax
subl 0x34(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x4(%rsp), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %ymm2
movl 0x18(%rsp), %esi
vmovd %esi, %xmm0
vpbroadcastb %xmm0, %ymm3
movl 0x14(%rsp), %ecx
addb $-0x7f, %cl
movl %ecx, 0x14(%rsp)
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqa %ymm0, 0xc0(%rsp)
vmovd 0x8(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm5
movl %eax, %eax
movl %esi, %ecx
movslq %r13d, %rsi
movq %r14, 0x8(%rsp)
movl %r14d, %edi
negq %rax
movq %rdi, 0x40(%rsp)
imulq %rcx, %rdi
xorl %r8d, %r8d
movq $-0x80, %r9
movq 0x48(%rsp), %r14
movq %r11, %rdx
movq %rsi, %r10
xorl %r11d, %r11d
cmpq $-0x7f, %r10
movq $-0x80, %r12
cmovgeq %r10, %r12
movb %r12b, 0x140(%rsp,%r11)
leaq (%rax,%r10), %r12
cmpq $-0x7f, %r12
cmovlq %r9, %r12
movb %r12b, 0x120(%rsp,%r11)
incq %r11
subq %rdi, %r10
cmpq $0x20, %r11
jne 0x59302e
movq %r8, %r10
shlq $0x5, %r10
vmovaps 0x140(%rsp), %ymm0
movq %rdx, %r11
vmovaps %ymm0, (%rdx,%r10)
vmovdqa 0x120(%rsp), %ymm0
vmovdqa %ymm0, (%r14,%r10)
movq 0xa0(%rsp), %rdx
vmovdqa %ymm0, (%rdx,%r10)
incq %r8
subq %rcx, %rsi
cmpq 0x40(%rsp), %r8
jne 0x593025
movq 0x58(%rsp), %rdi
movb $0x0, (%rdi)
movl $0x1, %eax
movl 0x18(%rsp), %edx
movq 0xe0(%rsp), %rsi
cmpl $-0x7f, %r13d
movl $0xffffff80, %ecx       # imm = 0xFFFFFF80
cmovgel %r13d, %ecx
movb %cl, (%rdi,%rax)
incq %rax
subl %edx, %r13d
cmpq %rax, %rsi
jne 0x5930c5
movq 0x8(%rsp), %rdx
cmpl $0x1, %edx
adcl $0x0, %edx
shlq $0x5, %rdx
xorl %eax, %eax
vbroadcastsd 0x686d6(%rip), %ymm0 # 0x5fb7d0
movq 0x38(%rsp), %rsi
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
vmovaps %ymm0, (%rcx,%rax)
addq $0x20, %rax
cmpq %rax, %rdx
jne 0x5930ff
movq 0x8(%rsp), %rax
decl %eax
cmpl $0x2, %esi
movl $0x1, %ecx
cmovgel %esi, %ecx
movq %rcx, 0x88(%rsp)
movl %esi, %r10d
movq 0x40(%rsp), %rsi
vpbroadcastb 0x686a9(%rip), %ymm6 # 0x5fb7e8
shlq $0x5, %rsi
vpbroadcastb 0x6869d(%rip), %ymm0 # 0x5fb7e9
vmovdqa %ymm0, 0xe0(%rsp)
xorl %ecx, %ecx
vpbroadcastb 0x6868c(%rip), %ymm8 # 0x5fb7ec
shlq $0x5, %rax
movq %rax, 0x90(%rsp)
vpbroadcastb 0x68678(%rip), %ymm9 # 0x5fb7ed
vpbroadcastq 0x6865a(%rip), %ymm10 # 0x5fb7d8
vpbroadcastq 0x68659(%rip), %ymm11 # 0x5fb7e0
movq %rsi, 0x80(%rsp)
movq %rsi, 0x18(%rsp)
xorl %r8d, %r8d
vmovdqa %ymm5, 0x100(%rsp)
vmovdqa 0xc0(%rsp), %ymm4
movq 0xa0(%rsp), %rax
movq 0x28(%rsp), %r12
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %r13
movq 0x90(%rsp), %rsi
leaq (%r11,%rsi), %r9
movq %r9, 0x50(%rsp)
movq %r11, 0x20(%rsp)
vmovdqa (%r11,%rsi), %ymm0
vinserti128 $0x1, %xmm0, %ymm0, %ymm1
vpalignr $0xf, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm1[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, (%rdi,%r8), %xmm0, %xmm1
vpblendd $0xf, %ymm1, %ymm0, %ymm12 # ymm12 = ymm1[0,1,2,3],ymm0[4,5,6,7]
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x78(%rsp), %rsi
movzbl (%rsi,%r8), %esi
movslq (%rax,%rsi,4), %rax
movq 0x40(%rsp), %rdi
movq %rdi, %rsi
imulq %rax, %rsi
shlq $0x5, %rsi
addq 0x98(%rsp), %rsi
movq %r8, 0x38(%rsp)
incq %r8
movl $0x1, %eax
xorl %r9d, %r9d
vmovdqa 0xc0(%rsp), %ymm0
vmovdqa (%r14,%r9), %ymm1
vpaddsb (%rsi,%r9), %ymm12, %ymm13
vpmaxsb %ymm1, %ymm13, %ymm14
vpmaxsb %ymm0, %ymm14, %ymm12
vmovdqa %ymm12, (%r13,%r9)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %rcx, %r11
vpcmpeqb %ymm13, %ymm12, %ymm13
vpcmpgtb %ymm0, %ymm14, %ymm14
vpaddb %ymm6, %ymm14, %ymm14
vpblendvb %ymm13, 0xe0(%rsp), %ymm14, %ymm13
vpor (%r9,%r11), %ymm13, %ymm14
vmovdqa %ymm13, (%r15,%r9)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %rcx, %r11
vmovdqa %ymm14, (%r9,%r11)
vpsubsb %ymm2, %ymm12, %ymm13
vpsubsb %ymm3, %ymm1, %ymm14
vpmaxsb %ymm14, %ymm13, %ymm14
vmovdqa %ymm14, (%r14,%r9)
movq 0x28(%rsp), %r11
vmovdqa (%r11,%r9), %ymm14
vpsubsb %ymm3, %ymm14, %ymm14
vpmaxsb %ymm14, %ymm13, %ymm15
vmovdqa %ymm15, (%r12,%r9)
cmpq %r10, %r8
jae 0x5932f9
vpbroadcastb 0x68517(%rip), %ymm15 # 0x5fb7ea
vpbroadcastb 0x6850f(%rip), %ymm7 # 0x5fb7eb
vpcmpgtb %ymm14, %ymm13, %ymm14
vpblendvb %ymm14, %ymm15, %ymm7, %ymm7
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq 0x18(%rsp), %r11
vmovdqa %ymm7, (%r9,%r11)
vpsubsb %ymm3, %ymm0, %ymm14
cmpq %rdi, %rax
jae 0x593325
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %rcx, %r11
vpcmpgtb %ymm14, %ymm13, %ymm7
vpblendvb %ymm7, %ymm8, %ymm9, %ymm7
vpor 0x20(%r9,%r11), %ymm7, %ymm7
vmovdqa %ymm7, 0x20(%r9,%r11)
vpmaxsb %ymm12, %ymm4, %ymm4
vpminsb %ymm1, %ymm5, %ymm1
vpminsb %ymm0, %ymm1, %ymm0
vpminsb %ymm12, %ymm0, %ymm5
vpmaxsb %ymm14, %ymm13, %ymm0
movq 0x20(%rsp), %r11
vmovdqa (%r11,%r9), %ymm12
addq $0x20, %r9
incq %rax
cmpq %r9, %rdx
jne 0x59323d
movq $0x0, 0x8(%rsp)
vmovdqa %ymm0, %ymm12
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %r11
movsbl 0x1(%rdi,%r11), %eax
subl 0x4(%rsp), %eax
cmpl $-0x7f, %eax
movl $0xffffff80, %r9d       # imm = 0xFFFFFF80
cmovll %r9d, %eax
movq 0x50(%rsp), %r9
vmovdqa (%r9), %ymm1
vinserti128 $0x1, %xmm1, %ymm0, %ymm7
vpalignr $0xf, %ymm7, %ymm1, %ymm1 # ymm1 = ymm7[15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm7[31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, (%rdi,%r11), %xmm1, %xmm7
vinserti128 $0x1, %xmm13, %ymm0, %ymm15
vpalignr $0xf, %ymm15, %ymm13, %ymm13 # ymm13 = ymm15[15],ymm13[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm15[31],ymm13[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %eax, %xmm13, %xmm15
vpblendd $0xf, %ymm7, %ymm1, %ymm1 # ymm1 = ymm7[0,1,2,3],ymm1[4,5,6,7]
vpblendd $0xf, %ymm15, %ymm13, %ymm13 # ymm13 = ymm15[0,1,2,3],ymm13[4,5,6,7]
vinserti128 $0x1, %xmm12, %ymm0, %ymm7
vpalignr $0xf, %ymm7, %ymm12, %ymm7 # ymm7 = ymm7[15],ymm12[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm7[31],ymm12[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %eax, %xmm7, %xmm12
vpblendd $0xf, %ymm12, %ymm7, %ymm15 # ymm15 = ymm12[0,1,2,3],ymm7[4,5,6,7]
vinserti128 $0x1, %xmm14, %ymm0, %ymm7
vpalignr $0xf, %ymm7, %ymm14, %ymm7 # ymm7 = ymm7[15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm7[31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, 0x14(%rsp), %xmm7, %xmm12
vpblendd $0xf, %ymm12, %ymm7, %ymm14 # ymm14 = ymm12[0,1,2,3],ymm7[4,5,6,7]
vinserti128 $0x1, %xmm0, %ymm0, %ymm7
vpalignr $0xf, %ymm7, %ymm0, %ymm0 # ymm0 = ymm7[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm7[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %eax, %xmm0, %xmm7
vpblendd $0xf, %ymm7, %ymm0, %ymm0 # ymm0 = ymm7[0,1,2,3],ymm0[4,5,6,7]
movb $0x1, %al
movl $0x1, %r9d
xorl %r11d, %r11d
movq 0x40(%rsp), %rdi
vmovdqa (%r13,%r11), %ymm7
vpmaxsb %ymm15, %ymm7, %ymm12
vmovdqa %ymm12, (%r13,%r11)
vpaddsb (%rsi,%r11), %ymm1, %ymm1
vpcmpeqb %ymm1, %ymm12, %ymm1
vpcmpgtb %ymm15, %ymm7, %ymm7
vpor %ymm7, %ymm1, %ymm1
movq 0x10(%rbx), %r14
vpblendvb %ymm1, (%r15,%r11), %ymm6, %ymm1
movq (%r14), %r14
addq %rcx, %r14
vpand (%r11,%r14), %ymm10, %ymm7
vmovdqa %ymm1, (%r15,%r11)
vpor %ymm1, %ymm7, %ymm1
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
vmovdqa %ymm1, (%r11,%r14)
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
vpcmpgtb %ymm14, %ymm13, %ymm1
vpblendvb %ymm1, %ymm8, %ymm9, %ymm1
vpand (%r11,%r14), %ymm11, %ymm7
vpor %ymm1, %ymm7, %ymm1
vmovdqa %ymm1, (%r11,%r14)
vpsubsb %ymm2, %ymm12, %ymm13
movq 0x28(%rsp), %r14
vmovdqa (%r14,%r11), %ymm1
vpsubsb %ymm3, %ymm1, %ymm1
vpmaxsb %ymm1, %ymm13, %ymm7
vmovdqa %ymm7, (%r12,%r11)
cmpq %r10, %r8
jae 0x593555
vpbroadcastb 0x68322(%rip), %ymm7 # 0x5fb7ea
vmovdqa %ymm14, 0xa0(%rsp)
vmovdqa %ymm4, %ymm14
vmovdqa %ymm5, %ymm4
vmovdqa %ymm0, %ymm5
vmovdqa %ymm3, %ymm0
vmovdqa %ymm6, %ymm3
vmovdqa %ymm9, %ymm6
vmovdqa %ymm8, %ymm9
vmovdqa %ymm11, %ymm8
vmovdqa %ymm10, %ymm11
vmovdqa %ymm2, %ymm10
vpbroadcastb 0x682e6(%rip), %ymm2 # 0x5fb7eb
vpcmpgtb %ymm1, %ymm13, %ymm1
vpblendvb %ymm1, %ymm7, %ymm2, %ymm1
vmovdqa %ymm10, %ymm2
vmovdqa %ymm11, %ymm10
vmovdqa %ymm8, %ymm11
vmovdqa %ymm9, %ymm8
vmovdqa %ymm6, %ymm9
vmovdqa %ymm3, %ymm6
vmovdqa %ymm0, %ymm3
vmovdqa %ymm5, %ymm0
vmovdqa %ymm4, %ymm5
vmovdqa %ymm14, %ymm4
vmovdqa 0xa0(%rsp), %ymm14
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq 0x18(%rsp), %r14
vmovdqa %ymm1, (%r11,%r14)
vpminsb %ymm12, %ymm5, %ymm5
vpmaxsb %ymm12, %ymm4, %ymm4
vpsubsb %ymm3, %ymm15, %ymm12
vpcmpgtb %ymm12, %ymm13, %ymm1
vpmovmskb %ymm1, %r14d
cmpl $-0x1, %r14d
je 0x5935a3
vpsubsb %ymm3, %ymm0, %ymm14
vpmaxsb %ymm14, %ymm13, %ymm0
movq 0x20(%rsp), %rax
vmovdqa (%rax,%r11), %ymm1
cmpq %rdi, %r9
setb %al
addq $0x20, %r11
incq %r9
vmovdqa %ymm12, %ymm15
cmpq %r11, %rdx
jne 0x59341c
jmp 0x5935a8
vmovdqa %ymm15, %ymm12
testb $0x1, %al
jne 0x5935c2
movq 0x8(%rsp), %rdi
leal 0x1(%rdi), %eax
cmpl $0x1f, %edi
movq %rax, 0x8(%rsp)
jb 0x593366
movq 0x80(%rsp), %rax
addq %rax, 0x18(%rsp)
addq %rax, %rcx
movq %r13, %r11
movq %r12, %rax
cmpq 0x88(%rsp), %r8
movq 0x48(%rsp), %r14
movq 0x58(%rsp), %rdi
jne 0x5931b1
movl 0x68(%rsp), %eax
shlq $0x5, %rax
vmovdqa (%r13,%rax), %ymm0
cmpl $0x1e, 0x34(%rsp)
jg 0x59362b
movl 0x64(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x30(%rsp), %edx
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm1[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %eax
jne 0x593619
jmp 0x59362f
movl 0x30(%rsp), %edx
vmovdqa 0xc0(%rsp), %ymm1
vpcmpgtb %ymm5, %ymm1, %ymm1
vpcmpgtb 0x100(%rsp), %ymm4, %ymm2
vpor %ymm2, %ymm1, %ymm1
vpmovmskb %ymm1, %eax
testl %eax, %eax
je 0x59365d
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x59366d
vextracti128 $0x1, %ymm0, %xmm0
vpextrb $0xf, %xmm0, %eax
movl 0x6c(%rsp), %ecx
movsbl %al, %eax
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
vzeroupper
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x20(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
jmp 0x5936ee
callq 0x1fb3df
jmp 0x5936ec
callq 0x1fb3b9
jmp 0x5936ec
callq 0x1fb393
jmp 0x5936ec
callq 0x1fb36d
jmp 0x5936ec
callq 0x1fb347
jmp 0x5936ec
callq 0x1fb321
jmp 0x5936ec
callq 0x1fb2fb
jmp 0x5936ec
callq 0x1fb2d5
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq