// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_striped_sse41_128_8.c
// Function: parasail_sw_trace_striped_profile_sse41_128_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;
    __m128i* restrict vProfile = NULL;
    __m128i* restrict pvHStore = NULL;
    __m128i* restrict pvHLoad = NULL;
    __m128i* restrict pvE = NULL;
    __m128i* restrict pvEaStore = NULL;
    __m128i* restrict pvEaLoad = NULL;
    __m128i* restrict pvHT = NULL;
    __m128i* restrict pvHMax = NULL;
    __m128i vGapO;
    __m128i vGapE;
    __m128i vZero;
    int8_t score = 0;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    int8_t maxp = 0;
    parasail_result_t *result = NULL;
    __m128i vTZero;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTDiag;
    __m128i vTDiagE;
    __m128i vTInsE;
    __m128i vTDiagF;
    __m128i vTDelF;
    __m128i vTMask;
    __m128i 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 = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m128i*)profile->profile8.score;
    vGapO = _mm_set1_epi8(open);
    vGapE = _mm_set1_epi8(gap);
    vZero = _mm_setzero_si128();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT8_MAX - (int8_t)(matrix->max+1);
    vTZero = _mm_set1_epi8(PARASAIL_ZERO);
    vTIns  = _mm_set1_epi8(PARASAIL_INS);
    vTDel  = _mm_set1_epi8(PARASAIL_DEL);
    vTDiag = _mm_set1_epi8(PARASAIL_DIAG);
    vTDiagE= _mm_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi8(PARASAIL_INS_E);
    vTDiagF= _mm_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi8(PARASAIL_DEL_F);
    vTMask = _mm_set1_epi8(PARASAIL_ZERO_MASK);
    vFTMask= _mm_set1_epi8(PARASAIL_F_MASK);

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 16, sizeof(__m128i));
    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_16;

    /* initialize heap variables */
    pvHStore = parasail_memalign___m128i(16, segLen);
    pvHLoad =  parasail_memalign___m128i(16, segLen);
    pvE = parasail_memalign___m128i(16, segLen);
    pvEaStore = parasail_memalign___m128i(16, segLen);
    pvEaLoad = parasail_memalign___m128i(16, segLen);
    pvHT = parasail_memalign___m128i(16, segLen);
    pvHMax = parasail_memalign___m128i(16, 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___m128i(pvHStore, vZero, segLen);
    parasail_memset___m128i(pvE, _mm_set1_epi8(-open), segLen);
    parasail_memset___m128i(pvEaStore, _mm_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) {
        __m128i vEF_opn;
        __m128i vE;
        __m128i vE_ext;
        __m128i vF;
        __m128i vF_ext;
        __m128i vFa;
        __m128i vFa_ext;
        __m128i vH;
        __m128i vH_dag;
        const __m128i* vP = NULL;

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

        /* load final segment of pvHStore and shift left by 1 bytes */
        vH = _mm_load_si128(&pvHStore[segLen - 1]);
        vH = _mm_slli_si128(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 = _mm_load_si128(pvE + i);

            /* Get max from vH, vE and vF. */
            vH_dag = _mm_adds_epi8(vH, _mm_load_si128(vP + i));
            vH_dag = _mm_max_epi8(vH_dag, vZero);
            vH = _mm_max_epi8(vH_dag, vE);
            vH = _mm_max_epi8(vH, vF);
            /* Save vH values. */
            _mm_store_si128(pvHStore + i, vH);

            {
                __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __m128i cond_zero = _mm_cmpeq_epi8(vH, vZero);
                __m128i case1 = _mm_cmpeq_epi8(vH, vH_dag);
                __m128i case2 = _mm_cmpeq_epi8(vH, vF);
                __m128i vT = _mm_blendv_epi8(
                        _mm_blendv_epi8(vTIns, vTDel, case2),
                        _mm_blendv_epi8(vTDiag, vTZero, cond_zero),
                        case1);
                _mm_store_si128(pvHT + i, vT);
                vT = _mm_or_si128(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }
            vMaxH = _mm_max_epi8(vH, vMaxH);
            vEF_opn = _mm_subs_epi8(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm_subs_epi8(vE, vGapE);
            vE = _mm_max_epi8(vEF_opn, vE_ext);
            _mm_store_si128(pvE + i, vE);
            {
                __m128i vEa = _mm_load_si128(pvEaLoad + i);
                __m128i vEa_ext = _mm_subs_epi8(vEa, vGapE);
                vEa = _mm_max_epi8(vEF_opn, vEa_ext);
                _mm_store_si128(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m128i cond = _mm_cmpgt_epi8(vEF_opn, vEa_ext);
                    __m128i vT = _mm_blendv_epi8(vTInsE, vTDiagE, cond);
                    arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                }
            }

            /* Update vF value. */
            vF_ext = _mm_subs_epi8(vF, vGapE);
            vF = _mm_max_epi8(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m128i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m128i cond = _mm_cmpgt_epi8(vEF_opn, vF_ext);
                __m128i vT = _mm_blendv_epi8(vTDelF, vTDiagF, cond);
                vT = _mm_or_si128(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i+1, segLen, j);
            }

            /* Load the next vH. */
            vH = _mm_load_si128(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) {
            __m128i vHp = _mm_load_si128(&pvHLoad[segLen - 1]);
            vHp = _mm_slli_si128(vHp, 1);
            vEF_opn = _mm_slli_si128(vEF_opn, 1);
            vEF_opn = _mm_insert_epi8(vEF_opn, -open, 0);
            vF_ext = _mm_slli_si128(vF_ext, 1);
            vF_ext = _mm_insert_epi8(vF_ext, NEG_INF, 0);
            vF = _mm_slli_si128(vF, 1);
            vF = _mm_insert_epi8(vF, -open, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 1);
            vFa_ext = _mm_insert_epi8(vFa_ext, NEG_INF, 0);
            vFa = _mm_slli_si128(vFa, 1);
            vFa = _mm_insert_epi8(vFa, -open, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi8(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_adds_epi8(vHp, _mm_load_si128(vP + i));
                    vHp = _mm_max_epi8(vHp, vZero);
                    case1 = _mm_cmpeq_epi8(vH, vHp);
                    case2 = _mm_cmpeq_epi8(vH, vF);
                    cond = _mm_andnot_si128(case1,case2);
                    vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    vT = _mm_load_si128(pvHT + i);
                    vT = _mm_blendv_epi8(vT, vTDel, cond);
                    _mm_store_si128(pvHT + i, vT);
                    vTAll = _mm_and_si128(vTAll, vTMask);
                    vTAll = _mm_or_si128(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vMaxH = _mm_max_epi8(vH, vMaxH);
                /* Update vF value. */
                {
                    __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m128i cond = _mm_cmpgt_epi8(vEF_opn, vFa_ext);
                    __m128i vT = _mm_blendv_epi8(vTDelF, vTDiagF, cond);
                    vTAll = _mm_and_si128(vTAll, vFTMask);
                    vTAll = _mm_or_si128(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vEF_opn = _mm_subs_epi8(vH, vGapO);
                vF_ext = _mm_subs_epi8(vF, vGapE);
                {
                    __m128i vEa = _mm_load_si128(pvEaLoad + i);
                    __m128i vEa_ext = _mm_subs_epi8(vEa, vGapE);
                    vEa = _mm_max_epi8(vEF_opn, vEa_ext);
                    _mm_store_si128(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m128i cond = _mm_cmpgt_epi8(vEF_opn, vEa_ext);
                        __m128i vT = _mm_blendv_epi8(vTInsE, vTDiagE, cond);
                        arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                    }
                }
                if (! _mm_movemask_epi8(
                            _mm_or_si128(
                                _mm_cmpgt_epi8(vF_ext, vEF_opn),
                                _mm_cmpeq_epi8(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm_max_epi8(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm_subs_epi8(vFa, vGapE);
                vFa = _mm_max_epi8(vEF_opn, vFa_ext);
                vHp = _mm_load_si128(pvHLoad + i);
            }
        }
end:
        {
        }

        {
            __m128i vCompare = _mm_cmpgt_epi8(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi8_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm_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 $0xd8, %rsp
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x4ac794
movq 0x18(%rdi), %rax
movq %rax, 0xb0(%rsp)
testq %rax, %rax
je 0x4ac79b
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x4ac7a2
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
jle 0x4ac7a9
cmpq $0x0, 0x78(%rsp)
je 0x4ac7b0
movl %edx, %r13d
testl %edx, %edx
jle 0x4ac7b7
movl %ecx, %r12d
testl %ecx, %ecx
js 0x4ac7be
testl %r8d, %r8d
js 0x4ac7c5
movl %r8d, 0x60(%rsp)
leaq 0xf(%r14), %r15
movq %r15, %rbp
shrq $0x4, %rbp
movq 0x70(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x8(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %ebp, %edi
movl %r13d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x4ac7ca
movq %rax, %rbx
movl %r12d, 0x40(%rsp)
movq %r13, 0x30(%rsp)
movq %r15, 0x90(%rsp)
movq %r14, 0x98(%rsp)
orl $0x10180804, 0xc(%rax)  # imm = 0x10180804
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2f600c
movq %rax, %r15
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2f600c
movq %rbp, %r12
movq %rax, %rbp
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, 0x50(%rsp)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, %r13
movl $0x10, %edi
movq %r12, 0x20(%rsp)
movq %r12, %rsi
callq 0x2f600c
movq %rax, %rcx
xorl %eax, %eax
testq %r15, %r15
je 0x4ac835
testq %rbp, %rbp
je 0x4ac835
cmpq $0x0, 0x28(%rsp)
je 0x4ac835
movq 0x50(%rsp), %rdx
testq %rdx, %rdx
je 0x4ac835
testq %r14, %r14
je 0x4ac835
testq %r13, %r13
je 0x4ac835
testq %rcx, %rcx
je 0x4ac835
movq %rcx, 0x18(%rsp)
movd 0x40(%rsp), %xmm1
pxor %xmm0, %xmm0
pshufb %xmm0, %xmm1
movdqa %xmm1, 0x80(%rsp)
movd 0x60(%rsp), %xmm1
pshufb %xmm0, %xmm1
movdqa %xmm1, 0x60(%rsp)
movq %r15, %rdi
movq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x2f6015
movl 0x40(%rsp), %eax
negb %al
movzbl %al, %eax
movl %eax, 0x3c(%rsp)
movd %eax, %xmm0
pshufb 0x17dc3e(%rip), %xmm0   # 0x629d60
movdqa %xmm0, 0x40(%rsp)
movq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x2f6015
movq 0x50(%rsp), %rdi
movdqa 0x40(%rsp), %xmm0
movq %r12, %rsi
callq 0x2f6015
shlq $0x4, %r12
xorl %ecx, %ecx
movdqa 0x11e059(%rip), %xmm11  # 0x5ca1b0
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
movdqa %xmm11, (%rdx,%rcx)
addq $0x10, %rcx
cmpq %rcx, %r12
jne 0x4ac157
pxor %xmm3, %xmm3
pxor %xmm0, %xmm0
psubsb 0x80(%rsp), %xmm0
movdqa %xmm0, 0xc0(%rsp)
movq 0x20(%rsp), %rcx
leal -0x1(%rcx), %esi
movb $0x7e, %al
subb 0x8(%rsp), %al
movsbl %al, %eax
movl %eax, 0x38(%rsp)
movl 0x30(%rsp), %edx
movl %ecx, %edi
movq %rdi, 0xa0(%rsp)
shlq $0x4, %rdi
movb $-0x80, %al
movl %eax, (%rsp)
xorl %r8d, %r8d
shlq $0x4, %rsi
movq %rsi, 0xa8(%rsp)
movdqa 0x11dfb6(%rip), %xmm5   # 0x5ca180
movdqa 0x11dfce(%rip), %xmm6   # 0x5ca1a0
movdqa 0x11dfe6(%rip), %xmm7   # 0x5ca1c0
movdqa 0x11dffd(%rip), %xmm8   # 0x5ca1e0
movdqa 0x11dfe4(%rip), %xmm9   # 0x5ca1d0
movq %rdi, 0x8(%rsp)
xorl %r11d, %r11d
movl $0x0, 0x4(%rsp)
pxor %xmm13, %xmm13
pxor %xmm1, %xmm1
movq 0x50(%rsp), %rax
movdqa %xmm1, 0x50(%rsp)
movq 0x18(%rsp), %r10
movq %r10, 0x10(%rsp)
movq %r14, %r12
movq %rax, %r14
movq %rbp, 0xb8(%rsp)
movq %r15, %rbp
movq %r11, %rax
movq 0xa8(%rsp), %r9
leaq (%r15,%r9), %rcx
movq %rcx, 0x40(%rsp)
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x78(%rsp), %rcx
movzbl (%rcx,%r11), %r11d
movslq (%rsi,%r11,4), %r11
movq 0xa0(%rsp), %rsi
imulq %r11, %rsi
shlq $0x4, %rsi
addq 0xb0(%rsp), %rsi
leal -0x2(%rax), %r11d
cmpl %r11d, 0x4(%rsp)
movq 0xb8(%rsp), %r15
cmoveq %r15, %r10
movq %r10, 0x18(%rsp)
cmoveq 0x10(%rsp), %r15
movdqa (%rbp,%r9), %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq %rax, 0x10(%rsp)
leaq 0x1(%rax), %r11
movl $0x1, %eax
xorl %r9d, %r9d
movdqa 0xc0(%rsp), %xmm15
movq 0x28(%rsp), %r10
movdqa (%r10,%r9), %xmm1
paddsb (%rsi,%r9), %xmm0
pmaxsb %xmm3, %xmm0
movdqa %xmm0, %xmm2
pmaxsb %xmm1, %xmm2
movdqa %xmm2, %xmm4
pmaxsb %xmm15, %xmm4
movdqa %xmm4, (%r15,%r9)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
pcmpeqb %xmm4, %xmm0
pcmpgtb %xmm15, %xmm2
paddb %xmm5, %xmm2
movdqa %xmm4, %xmm12
pcmpgtb %xmm3, %xmm12
pand %xmm6, %xmm12
pblendvb %xmm0, %xmm12, %xmm2
movdqa (%r9,%rcx), %xmm0
por %xmm2, %xmm0
movdqa %xmm2, (%r13,%r9)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
movdqa %xmm0, (%r9,%rcx)
movdqa %xmm4, %xmm14
psubsb 0x80(%rsp), %xmm14
movdqa 0x60(%rsp), %xmm2
psubsb %xmm2, %xmm1
pmaxsb %xmm14, %xmm1
movdqa %xmm1, (%r10,%r9)
movdqa (%r14,%r9), %xmm1
psubsb %xmm2, %xmm1
movdqa %xmm14, %xmm0
pmaxsb %xmm1, %xmm0
movdqa %xmm0, (%r12,%r9)
cmpq %rdx, %r11
jae 0x4ac39a
movdqa %xmm14, %xmm0
pcmpgtb %xmm1, %xmm0
movdqa %xmm7, %xmm1
pblendvb %xmm0, %xmm11, %xmm1
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq 0x8(%rsp), %rcx
movdqa %xmm1, (%r9,%rcx)
movdqa %xmm15, %xmm12
psubsb %xmm2, %xmm12
cmpq 0x20(%rsp), %rax
jae 0x4ac3d8
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa %xmm14, %xmm0
pcmpgtb %xmm12, %xmm0
movdqa %xmm8, %xmm1
pblendvb %xmm0, %xmm9, %xmm1
addq %r8, %rcx
por 0x10(%r9,%rcx), %xmm1
movdqa %xmm1, 0x10(%r9,%rcx)
pmaxsb %xmm4, %xmm13
movdqa %xmm14, %xmm15
pmaxsb %xmm12, %xmm15
movdqa (%rbp,%r9), %xmm0
addq $0x10, %r9
incq %rax
cmpq %r9, %rdi
jne 0x4ac2b5
xorl %eax, %eax
movdqa %xmm15, %xmm4
movdqa 0x60(%rsp), %xmm10
movq 0x40(%rsp), %r10
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movl 0x3c(%rsp), %ecx
pinsrb $0x0, %ecx, %xmm4
pslldq $0x1, %xmm12            # xmm12 = zero,xmm12[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movl $0x80, %r9d
pinsrb $0x0, %r9d, %xmm12
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, %ecx, %xmm15
pslldq $0x1, %xmm14            # xmm14 = zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, %ecx, %xmm14
movdqa (%r10), %xmm2
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
xorl %r9d, %r9d
movdqa (%r15,%r9), %xmm0
movdqa %xmm0, %xmm1
pmaxsb %xmm15, %xmm1
movdqa %xmm1, (%r15,%r9)
paddsb (%rsi,%r9), %xmm2
pcmpgtb %xmm12, %xmm14
pmaxsb %xmm3, %xmm2
pcmpeqb %xmm1, %xmm2
pcmpgtb %xmm15, %xmm0
por %xmm2, %xmm0
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
movdqa (%r9,%rcx), %xmm2
pand 0x17f769(%rip), %xmm2   # 0x62bc10
movdqa %xmm5, %xmm12
pblendvb %xmm0, (%r13,%r9), %xmm12
movdqa %xmm12, (%r13,%r9)
por %xmm2, %xmm12
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
movdqa %xmm12, (%r9,%rcx)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
movdqa %xmm8, %xmm2
movdqa %xmm14, %xmm0
pblendvb %xmm0, %xmm9, %xmm2
movdqa (%r9,%rcx), %xmm0
pand 0x17f728(%rip), %xmm0   # 0x62bc20
por %xmm2, %xmm0
movdqa %xmm0, (%r9,%rcx)
movdqa %xmm1, %xmm14
psubsb 0x80(%rsp), %xmm14
movdqa (%r14,%r9), %xmm2
psubsb %xmm10, %xmm2
movdqa %xmm14, %xmm0
pmaxsb %xmm2, %xmm0
movdqa %xmm0, (%r12,%r9)
cmpq %rdx, %r11
jae 0x4ac556
movdqa %xmm14, %xmm0
pcmpgtb %xmm2, %xmm0
movdqa %xmm7, %xmm2
pblendvb %xmm0, %xmm11, %xmm2
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq 0x8(%rsp), %rcx
movdqa %xmm2, (%r9,%rcx)
pmaxsb %xmm1, %xmm13
movdqa 0x60(%rsp), %xmm10
psubsb %xmm10, %xmm15
movdqa %xmm14, %xmm0
pcmpgtb %xmm15, %xmm0
pmovmskb %xmm0, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x4ac5b2
movdqa %xmm4, %xmm12
psubsb %xmm10, %xmm12
movdqa %xmm14, %xmm4
pmaxsb %xmm12, %xmm4
movdqa (%rbp,%r9), %xmm2
addq $0x10, %r9
cmpq %r9, %rdi
jne 0x4ac45c
incl %eax
cmpl $0x10, %eax
jne 0x4ac413
movdqa %xmm13, %xmm0
movdqa 0x50(%rsp), %xmm1
pcmpgtb %xmm1, %xmm0
pmovmskb %xmm0, %eax
testl %eax, %eax
je 0x4ac642
movdqa %xmm13, %xmm0
pxor 0x17e03a(%rip), %xmm0   # 0x62a610
movdqa %xmm0, %xmm1
psrlw $0x8, %xmm1
pminub %xmm0, %xmm1
phminposuw %xmm1, %xmm0
movd %xmm0, %eax
xorb $0x7f, %al
movl %eax, (%rsp)
movsbl %al, %eax
cmpl %eax, 0x38(%rsp)
jl 0x4ac658
movdqa %xmm13, %xmm0
psrldq $0x8, %xmm0             # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pmaxsb %xmm13, %xmm0
movdqa %xmm0, %xmm1
psrldq $0x4, %xmm1             # xmm1 = xmm1[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
pmaxsb %xmm0, %xmm1
movdqa %xmm1, %xmm0
psrldq $0x2, %xmm0             # xmm0 = xmm0[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
pmaxsb %xmm1, %xmm0
movdqa %xmm0, %xmm1
psrldq $0x1, %xmm1             # xmm1 = xmm1[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
pmaxsb %xmm0, %xmm1
pshufb %xmm3, %xmm1
movq 0x10(%rsp), %rax
movl %eax, 0x4(%rsp)
addq %rdi, 0x8(%rsp)
addq %rdi, %r8
movq %r12, %rax
cmpq %rdx, %r11
jne 0x4ac20a
jmp 0x4ac666
orb $0x40, 0xc(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpb $0x7f, (%rsp)
jne 0x4ac670
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
callq 0x20be2e
xorl %ecx, %ecx
testl %eax, %eax
je 0x4ac68d
movq 0x18(%rsp), %rdi
xorl %r9d, %r9d
xorl %edx, %edx
jmp 0x4ac7f2
movq 0x30(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0x4(%rsp), %r9d
cmpl %ecx, %r9d
movq 0x18(%rsp), %rcx
movq %rcx, %rdi
cmoveq %rbp, %rdi
movq %rbp, %rdx
cmoveq %rcx, %rdx
cmpl %eax, %r9d
cmoveq %r15, %rdi
cmoveq %rbp, %rdx
movq %rdx, %rbp
cmoveq %rcx, %r15
movq 0x98(%rsp), %rdx
decl %edx
movq 0x90(%rsp), %rsi
testl $0x7ffffff0, %esi       # imm = 0x7FFFFFF0
je 0x4ac7ce
andl $0x7ffffff0, %esi       # imm = 0x7FFFFFF0
movl (%rsp), %r8d
je 0x4ac7d4
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm1      # xmm1 = xmm0[0,0,0,0]
movzbl %r8b, %eax
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0,4,5,6,7]
movd 0x20(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
pmovsxbd 0x17f667(%rip), %xmm4   # 0x62bd88
xorl %eax, %eax
pmovsxbd 0x17f78a(%rip), %xmm5   # 0x62beb6
pmovsxbd 0x17f65b(%rip), %xmm6   # 0x62bd90
movd (%rdi,%rax), %xmm0
pcmpeqb %xmm2, %xmm0
pmovsxbd %xmm0, %xmm0
movdqa %xmm4, %xmm7
psrld $0x4, %xmm7
movdqa %xmm4, %xmm8
pand %xmm5, %xmm8
pmulld %xmm3, %xmm8
paddd %xmm7, %xmm8
pminsd %xmm1, %xmm8
blendvps %xmm0, %xmm8, %xmm1
addq $0x4, %rax
paddd %xmm6, %xmm4
cmpq %rax, %rsi
jne 0x4ac735
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
pminsd %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
pminsd %xmm0, %xmm1
movd %xmm1, %edx
jmp 0x4ac7ee
callq 0x1ddb7b
jmp 0x4ac7ca
callq 0x1ddb55
jmp 0x4ac7ca
callq 0x1ddb2f
jmp 0x4ac7ca
callq 0x1ddb09
jmp 0x4ac7ca
callq 0x1ddae3
jmp 0x4ac7ca
callq 0x1ddabd
jmp 0x4ac7ca
callq 0x1dda97
jmp 0x4ac7ca
callq 0x1dda71
xorl %eax, %eax
jmp 0x4ac835
movl (%rsp), %r8d
jmp 0x4ac7ee
xorl %eax, %eax
movl %eax, %ecx
shrl $0x4, %ecx
cmpl %edx, %ecx
cmovgel %edx, %ecx
cmpb %r8b, (%rdi,%rax)
cmovel %ecx, %edx
incq %rax
cmpl %eax, %esi
jne 0x4ac7d6
movsbl %r8b, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %r9d, 0x8(%rbx)
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r14, %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
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop