// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_striped_sse2_128_8.c
// Function: parasail_sw_trace_striped_profile_sse2_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_rpl(vH_dag, vZero);
            vH = _mm_max_epi8_rpl(vH_dag, vE);
            vH = _mm_max_epi8_rpl(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_rpl(
                        _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                        _mm_blendv_epi8_rpl(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_rpl(vH, vMaxH);
            vEF_opn = _mm_subs_epi8(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm_subs_epi8(vE, vGapE);
            vE = _mm_max_epi8_rpl(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_rpl(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_rpl(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_rpl(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_rpl(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_rpl(vEF_opn, -open, 0);
            vF_ext = _mm_slli_si128(vF_ext, 1);
            vF_ext = _mm_insert_epi8_rpl(vF_ext, NEG_INF, 0);
            vF = _mm_slli_si128(vF, 1);
            vF = _mm_insert_epi8_rpl(vF, -open, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 1);
            vFa_ext = _mm_insert_epi8_rpl(vFa_ext, NEG_INF, 0);
            vFa = _mm_slli_si128(vFa, 1);
            vFa = _mm_insert_epi8_rpl(vFa, -open, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi8_rpl(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_rpl(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_rpl(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_rpl(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_rpl(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_rpl(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_rpl(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_rpl(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm_subs_epi8(vFa, vGapE);
                vFa = _mm_max_epi8_rpl(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 $0x108, %rsp            # imm = 0x108
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x3c120c
movq 0x18(%rdi), %rax
movq %rax, 0xb0(%rsp)
testq %rax, %rax
je 0x3c1213
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x3c121a
movl 0x8(%rdi), %r15d
testl %r15d, %r15d
jle 0x3c1221
cmpq $0x0, 0x78(%rsp)
je 0x3c1228
movl %edx, %r12d
testl %edx, %edx
jle 0x3c122f
testl %ecx, %ecx
js 0x3c1236
testl %r8d, %r8d
js 0x3c123d
movl %r8d, 0x60(%rsp)
movl %ecx, 0x30(%rsp)
leaq 0xf(%r15), %r14
movq %r14, %r13
shrq $0x4, %r13
movq 0x70(%rsp), %rax
movl 0x1c(%rax), %ebp
movl $0x10, %edx
movl $0x10, %ecx
movl %r13d, %edi
movl %r12d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3c1242
movq %rax, %rbx
movl %ebp, 0x50(%rsp)
movq %r12, 0x48(%rsp)
movq %r15, 0x90(%rsp)
movq %r14, 0x98(%rsp)
orl $0x10180804, 0xc(%rax)  # imm = 0x10180804
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r14
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %r13, %rsi
movq %rax, %r13
movl $0x10, %edi
movq %rsi, 0x20(%rsp)
callq 0x2f600c
movq %rax, %rdx
movq %r15, %xmm0
movq %rbp, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq 0x28(%rsp), %xmm1
movq %r12, 0x80(%rsp)
movq %r12, %xmm2
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
pxor %xmm2, %xmm2
pcmpeqd %xmm2, %xmm0
pcmpeqd %xmm2, %xmm1
movdqa %xmm0, %xmm2
shufps $0xdd, %xmm1, %xmm2     # xmm2 = xmm2[1,3],xmm1[1,3]
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
andps %xmm2, %xmm0
movmskps %xmm0, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x3c12ae
testq %r14, %r14
je 0x3c12ae
testq %r13, %r13
je 0x3c12ae
testq %rdx, %rdx
je 0x3c12ae
movq %rdx, 0x18(%rsp)
movd 0x30(%rsp), %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, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xc0(%rsp)
movd 0x60(%rsp), %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, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x60(%rsp)
pxor %xmm0, %xmm0
movq %r15, %rdi
movq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x2f6015
movl 0x30(%rsp), %eax
negb %al
movzbl %al, %eax
movd %eax, %xmm0
movdqa %xmm0, 0xe0(%rsp)
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x2f6015
movq 0x80(%rsp), %rdi
movaps 0x30(%rsp), %xmm0
movq %r12, %rsi
callq 0x2f6015
shlq $0x4, %r12
xorl %ecx, %ecx
movdqa 0x20978d(%rip), %xmm0   # 0x5ca1b0
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
movdqa %xmm0, (%rdx,%rcx)
addq $0x10, %rcx
cmpq %rcx, %r12
jne 0x3c0a23
pxor %xmm0, %xmm0
pxor %xmm1, %xmm1
movdqa 0xc0(%rsp), %xmm10
psubsb %xmm10, %xmm1
movdqa %xmm1, 0xd0(%rsp)
movq 0x20(%rsp), %rcx
leal -0x1(%rcx), %esi
movb $0x7e, %al
subb 0x50(%rsp), %al
movsbl %al, %eax
movl %eax, 0x5c(%rsp)
movl 0x48(%rsp), %edx
movl %ecx, %edi
movq %rdi, 0xa0(%rsp)
shlq $0x4, %rdi
movb $-0x80, %al
movl %eax, 0x8(%rsp)
xorl %r8d, %r8d
shlq $0x4, %rsi
movq %rsi, 0xa8(%rsp)
movdqa 0x2096e4(%rip), %xmm2   # 0x5ca180
movdqa 0x2096fc(%rip), %xmm3   # 0x5ca1a0
movdqa 0x209714(%rip), %xmm5   # 0x5ca1c0
movdqa 0x26ae0c(%rip), %xmm6   # 0x62b8c0
movdqa 0x209724(%rip), %xmm7   # 0x5ca1e0
movq %rdi, 0x30(%rsp)
xorl %r10d, %r10d
movl $0x0, 0xc(%rsp)
pxor %xmm12, %xmm12
pxor %xmm4, %xmm4
movq 0x80(%rsp), %rax
movdqa %xmm4, 0x80(%rsp)
movq 0x18(%rsp), %r11
movq %r11, 0x10(%rsp)
movq %r14, %r12
movq %rax, %r14
movq %rbp, 0xb8(%rsp)
movq %r15, %rbp
movq %r10, %rax
movq 0xa8(%rsp), %rcx
leaq (%r15,%rcx), %rsi
movq %rsi, 0x50(%rsp)
movq 0x70(%rsp), %rsi
movq 0x10(%rsi), %rsi
movq 0x78(%rsp), %r9
movzbl (%r9,%r10), %r10d
movslq (%rsi,%r10,4), %r10
movq 0xa0(%rsp), %rsi
imulq %r10, %rsi
shlq $0x4, %rsi
addq 0xb0(%rsp), %rsi
leal -0x2(%rax), %r10d
cmpl %r10d, 0xc(%rsp)
movq 0xb8(%rsp), %r15
cmoveq %r15, %r11
movq %r11, 0x18(%rsp)
cmoveq 0x10(%rsp), %r15
movdqa (%rbp,%rcx), %xmm15
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq %rax, 0x10(%rsp)
leaq 0x1(%rax), %r10
movl $0x1, %eax
xorl %ecx, %ecx
movdqa 0xd0(%rsp), %xmm9
paddsb (%rsi,%rcx), %xmm15
movq 0x28(%rsp), %r9
movdqa (%r9,%rcx), %xmm14
movdqa %xmm15, %xmm1
pcmpgtb %xmm0, %xmm1
pand %xmm15, %xmm1
movdqa %xmm1, %xmm8
pcmpgtb %xmm14, %xmm8
movdqa %xmm1, %xmm15
pand %xmm8, %xmm15
pandn %xmm14, %xmm8
por %xmm15, %xmm8
movdqa %xmm8, %xmm15
pcmpgtb %xmm9, %xmm15
pand %xmm15, %xmm8
movdqa %xmm15, %xmm13
pandn %xmm9, %xmm13
por %xmm8, %xmm13
movdqa %xmm13, (%r15,%rcx)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
pcmpeqb %xmm13, %xmm1
movdqa %xmm13, %xmm8
pcmpeqb %xmm0, %xmm8
pandn %xmm1, %xmm8
pand %xmm3, %xmm8
paddb %xmm2, %xmm15
pandn %xmm15, %xmm1
por %xmm8, %xmm1
movdqa (%rcx,%r11), %xmm8
por %xmm1, %xmm8
movdqa %xmm1, (%r13,%rcx)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
movdqa %xmm8, (%rcx,%r11)
movdqa %xmm13, %xmm11
psubsb %xmm10, %xmm11
movdqa 0x60(%rsp), %xmm4
psubsb %xmm4, %xmm14
movdqa %xmm11, %xmm1
pcmpgtb %xmm14, %xmm1
movdqa %xmm11, %xmm15
pand %xmm1, %xmm15
pandn %xmm14, %xmm1
por %xmm15, %xmm1
movdqa %xmm1, (%r9,%rcx)
movdqa (%r14,%rcx), %xmm14
psubsb %xmm4, %xmm14
movdqa %xmm11, %xmm8
pcmpgtb %xmm14, %xmm8
movdqa %xmm11, %xmm15
pand %xmm8, %xmm15
movdqa %xmm8, %xmm1
pandn %xmm14, %xmm1
por %xmm15, %xmm1
movdqa %xmm1, (%r12,%rcx)
cmpq %rdx, %r10
jae 0x3c0cd2
pand 0x26abf5(%rip), %xmm8   # 0x62b8b0
pxor %xmm5, %xmm8
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq 0x30(%rsp), %r11
movdqa %xmm8, (%rcx,%r11)
movdqa %xmm9, %xmm14
psubsb 0x60(%rsp), %xmm14
movdqa %xmm11, %xmm9
pcmpgtb %xmm14, %xmm9
cmpq 0x20(%rsp), %rax
jae 0x3c0d14
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
movdqa %xmm9, %xmm1
pand %xmm6, %xmm1
pxor %xmm7, %xmm1
por 0x10(%rcx,%r11), %xmm1
movdqa %xmm1, 0x10(%rcx,%r11)
movdqa %xmm13, %xmm1
pcmpgtb %xmm12, %xmm1
pand %xmm1, %xmm13
pandn %xmm12, %xmm1
movdqa %xmm1, %xmm12
por %xmm13, %xmm12
movdqa %xmm11, %xmm1
pand %xmm9, %xmm1
pandn %xmm14, %xmm9
por %xmm1, %xmm9
movdqa (%rbp,%rcx), %xmm15
addq $0x10, %rcx
incq %rax
cmpq %rcx, %rdi
jne 0x3c0b8b
xorl %eax, %eax
movdqa %xmm9, %xmm15
movdqa 0x60(%rsp), %xmm4
movq 0x50(%rsp), %r9
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa 0x268ea3(%rip), %xmm1   # 0x629c20
pandn 0xe0(%rsp), %xmm1
por %xmm1, %xmm15
pslldq $0x1, %xmm14            # xmm14 = zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por 0x269366(%rip), %xmm14  # 0x62a100
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por %xmm1, %xmm9
pslldq $0x1, %xmm11            # xmm11 = zero,xmm11[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por %xmm1, %xmm11
movdqa (%r9), %xmm1
pslldq $0x1, %xmm1             # xmm1 = zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
xorl %ecx, %ecx
pcmpgtb %xmm14, %xmm11
movdqa (%r15,%rcx), %xmm8
movdqa %xmm8, %xmm13
pcmpgtb %xmm9, %xmm13
pand %xmm13, %xmm8
movdqa %xmm13, %xmm14
pandn %xmm9, %xmm14
por %xmm8, %xmm14
movdqa %xmm14, (%r15,%rcx)
paddsb (%rsi,%rcx), %xmm1
movdqa %xmm1, %xmm8
pcmpgtb %xmm0, %xmm8
pand %xmm1, %xmm8
pcmpeqb %xmm14, %xmm8
por %xmm13, %xmm8
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
movdqa (%rcx,%r11), %xmm1
pand 0x26adef(%rip), %xmm1   # 0x62bc10
movdqa (%r13,%rcx), %xmm13
pand %xmm8, %xmm13
pandn %xmm2, %xmm8
por %xmm13, %xmm8
movdqa %xmm8, (%r13,%rcx)
por %xmm1, %xmm8
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
movdqa %xmm8, (%rcx,%r11)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %r8, %r11
pand %xmm6, %xmm11
movdqa (%rcx,%r11), %xmm1
pand 0x26adb0(%rip), %xmm1   # 0x62bc20
por %xmm11, %xmm1
pxor %xmm7, %xmm1
movdqa %xmm1, (%rcx,%r11)
movdqa %xmm14, %xmm11
psubsb %xmm10, %xmm11
movdqa (%r14,%rcx), %xmm8
psubsb %xmm4, %xmm8
movdqa %xmm11, %xmm10
pcmpgtb %xmm8, %xmm10
movdqa %xmm11, %xmm13
pand %xmm10, %xmm13
movdqa %xmm10, %xmm1
pandn %xmm8, %xmm1
por %xmm13, %xmm1
movdqa %xmm1, (%r12,%rcx)
cmpq %rdx, %r10
jae 0x3c0ee2
pand 0x26a9e5(%rip), %xmm10  # 0x62b8b0
pxor %xmm5, %xmm10
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq 0x30(%rsp), %r11
movdqa %xmm10, (%rcx,%r11)
movdqa %xmm14, %xmm1
pcmpgtb %xmm12, %xmm1
pand %xmm1, %xmm14
pandn %xmm12, %xmm1
movdqa %xmm1, %xmm12
por %xmm14, %xmm12
movdqa 0x60(%rsp), %xmm4
psubsb %xmm4, %xmm9
movdqa %xmm11, %xmm1
pcmpgtb %xmm9, %xmm1
pmovmskb %xmm1, %r11d
cmpl $0xffff, %r11d          # imm = 0xFFFF
movdqa 0xc0(%rsp), %xmm10
je 0x3c0f73
movdqa %xmm15, %xmm14
psubsb %xmm4, %xmm14
movdqa %xmm11, %xmm15
pcmpgtb %xmm14, %xmm15
movdqa %xmm11, %xmm1
pand %xmm15, %xmm1
pandn %xmm14, %xmm15
por %xmm1, %xmm15
movdqa (%rbp,%rcx), %xmm1
addq $0x10, %rcx
cmpq %rcx, %rdi
jne 0x3c0dbc
incl %eax
cmpl $0x10, %eax
jne 0x3c0d6f
movdqa %xmm12, %xmm1
movdqa 0x80(%rsp), %xmm4
pcmpgtb %xmm4, %xmm1
pmovmskb %xmm1, %eax
testl %eax, %eax
je 0x3c1055
movdqa %xmm12, %xmm1
psrldq $0x8, %xmm1             # xmm1 = xmm1[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm12, %xmm8
pcmpgtb %xmm1, %xmm8
movdqa %xmm12, %xmm9
pand %xmm8, %xmm9
pandn %xmm1, %xmm8
por %xmm9, %xmm8
movdqa %xmm8, %xmm1
psrldq $0x4, %xmm1             # xmm1 = xmm1[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movdqa %xmm8, %xmm9
pcmpgtb %xmm1, %xmm9
pand %xmm9, %xmm8
pandn %xmm1, %xmm9
por %xmm8, %xmm9
movdqa %xmm9, %xmm1
psrldq $0x2, %xmm1             # xmm1 = xmm1[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
movdqa %xmm9, %xmm8
pcmpgtb %xmm1, %xmm8
pand %xmm8, %xmm9
pandn %xmm1, %xmm8
por %xmm9, %xmm8
movdqa %xmm8, %xmm9
psrldq $0x1, %xmm9             # xmm9 = xmm9[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
movdqa %xmm8, %xmm1
pcmpgtb %xmm9, %xmm1
pand %xmm1, %xmm8
pandn %xmm9, %xmm1
por %xmm8, %xmm1
movdqa %xmm1, 0xf0(%rsp)
movsbl 0xf0(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl %eax, 0x5c(%rsp)
jl 0x3c106b
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm4      # xmm4 = xmm1[0,0,0,0]
movq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
addq %rdi, 0x30(%rsp)
addq %rdi, %r8
movq %r12, %rax
cmpq %rdx, %r10
jne 0x3c0add
jmp 0x3c1079
orb $0x40, 0xc(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpb $0x7f, 0x8(%rsp)
jne 0x3c1084
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
callq 0x20be2e
xorl %ecx, %ecx
testl %eax, %eax
je 0x3c10a1
movq 0x18(%rsp), %rdi
xorl %r8d, %r8d
xorl %esi, %esi
jmp 0x3c126b
movq 0x48(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0xc(%rsp), %r8d
cmpl %ecx, %r8d
movq 0x18(%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), %rsi
decl %esi
movq 0x98(%rsp), %rdx
testl $0x7ffffff0, %edx       # imm = 0x7FFFFFF0
je 0x3c1246
andl $0x7ffffff0, %edx       # imm = 0x7FFFFFF0
movl 0x8(%rsp), %r9d
je 0x3c124d
movd %esi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movzbl %r9b, %eax
movd %eax, %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
movd 0x20(%rsp), %xmm2
pshufd $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
movdqa 0x26899b(%rip), %xmm3   # 0x629ad0
xorl %eax, %eax
movdqa 0x268b71(%rip), %xmm4   # 0x629cb0
pshufd $0xf5, %xmm2, %xmm5     # xmm5 = xmm2[1,1,3,3]
movdqa 0x2689a4(%rip), %xmm6   # 0x629af0
movd (%rdi,%rax), %xmm7
pcmpeqb %xmm1, %xmm7
punpcklbw %xmm7, %xmm7    # xmm7 = xmm7[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm7, %xmm7    # xmm7 = xmm7[0,0,1,1,2,2,3,3]
movdqa %xmm3, %xmm8
psrld $0x4, %xmm8
movdqa %xmm3, %xmm9
pand %xmm4, %xmm9
pshufd $0xf5, %xmm9, %xmm10    # xmm10 = xmm9[1,1,3,3]
pmuludq %xmm2, %xmm9
pshufd $0xe8, %xmm9, %xmm9     # xmm9 = xmm9[0,2,2,3]
pmuludq %xmm5, %xmm10
pshufd $0xe8, %xmm10, %xmm10   # xmm10 = xmm10[0,2,2,3]
punpckldq %xmm10, %xmm9   # xmm9 = xmm9[0],xmm10[0],xmm9[1],xmm10[1]
paddd %xmm8, %xmm9
movdqa %xmm0, %xmm8
pcmpgtd %xmm9, %xmm8
pand %xmm8, %xmm9
pandn %xmm0, %xmm8
por %xmm9, %xmm8
pand %xmm7, %xmm8
pandn %xmm0, %xmm7
movdqa %xmm7, %xmm0
por %xmm8, %xmm0
addq $0x4, %rax
paddd %xmm6, %xmm3
cmpq %rax, %rdx
jne 0x3c114c
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
pand %xmm2, %xmm0
pandn %xmm1, %xmm2
por %xmm0, %xmm2
pshufd $0x55, %xmm2, %xmm0     # xmm0 = xmm2[1,1,1,1]
movdqa %xmm0, %xmm1
pcmpgtd %xmm2, %xmm1
pand %xmm1, %xmm2
pandn %xmm0, %xmm1
por %xmm2, %xmm1
movd %xmm1, %esi
jmp 0x3c1267
callq 0x1c010f
jmp 0x3c1242
callq 0x1c00e9
jmp 0x3c1242
callq 0x1c00c3
jmp 0x3c1242
callq 0x1c009d
jmp 0x3c1242
callq 0x1c0077
jmp 0x3c1242
callq 0x1c0051
jmp 0x3c1242
callq 0x1c002b
jmp 0x3c1242
callq 0x1c0005
xorl %eax, %eax
jmp 0x3c12ae
movl 0x8(%rsp), %r9d
jmp 0x3c1267
xorl %eax, %eax
movl %eax, %ecx
shrl $0x4, %ecx
cmpl %esi, %ecx
cmovgel %esi, %ecx
cmpb %r9b, (%rdi,%rax)
cmovel %ecx, %esi
incq %rax
cmpl %eax, %edx
jne 0x3c124f
movsbl %r9b, %ecx
movl %ecx, (%rbx)
movl %esi, 0x4(%rbx)
movl %r8d, 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 $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq