// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_striped_sse41_128_8.c
// Function: parasail_nw_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 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;
    __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;
    int8_t* restrict boundary = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    int8_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    parasail_result_t *result = NULL;
    __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;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m128i*)profile->profile8.score;
    vGapO = _mm_set1_epi8(open);
    vGapE = _mm_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 = _mm_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    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_NW | 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);
    boundary = parasail_memalign_int8_t(16, 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;
            __m128i_8_t h;
            __m128i_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;
            }
            _mm_store_si128(&pvHStore[index], h.m);
            _mm_store_si128(&pvE[index], e.m);
            _mm_store_si128(&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) {
        __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 -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 = _mm_load_si128(&pvHStore[segLen - 1]);
        vH = _mm_slli_si128(vH, 1);

        /* insert upper boundary condition */
        vH = _mm_insert_epi8(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 = _mm_load_si128(pvE + i);

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

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

            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) {
            int64_t tmp = boundary[j+1]-open;
            int8_t tmp2 = tmp < INT8_MIN ? INT8_MIN : tmp;
            __m128i vHp = _mm_load_si128(&pvHLoad[segLen - 1]);
            vHp = _mm_slli_si128(vHp, 1);
            vHp = _mm_insert_epi8(vHp, boundary[j], 0);
            vEF_opn = _mm_slli_si128(vEF_opn, 1);
            vEF_opn = _mm_insert_epi8(vEF_opn, tmp2, 0);
            vF_ext = _mm_slli_si128(vF_ext, 1);
            vF_ext = _mm_insert_epi8(vF_ext, NEG_LIMIT, 0);
            vF = _mm_slli_si128(vF, 1);
            vF = _mm_insert_epi8(vF, tmp2, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 1);
            vFa_ext = _mm_insert_epi8(vFa_ext, NEG_LIMIT, 0);
            vFa = _mm_slli_si128(vFa, 1);
            vFa = _mm_insert_epi8(vFa, tmp2, 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);
                vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm_max_epi8(vSaturationCheckMax, vH);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_adds_epi8(vHp, _mm_load_si128(vP + i));
                    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);
                }
                /* 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:
        {
        }
    }

    /* extract last value from the last column */
    {
        __m128i vH = _mm_load_si128(pvHStore + offset);
        for (k=0; k<position; ++k) {
            vH = _mm_slli_si128 (vH, 1);
        }
        score = (int8_t) _mm_extract_epi8 (vH, 15);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi8(vSaturationCheckMin, vNegLimit),
            _mm_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %ecx, 0xc(%rsp)
movq %rsi, 0x88(%rsp)
testq %rdi, %rdi
je 0x4834c3
movq 0x18(%rdi), %rax
movq %rax, 0xa8(%rsp)
testq %rax, %rax
je 0x4834ca
movq 0x10(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x4834d1
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x4834d8
cmpq $0x0, 0x88(%rsp)
je 0x4834df
movl %edx, %r12d
testl %edx, %edx
jle 0x4834e6
cmpl $0x0, 0xc(%rsp)
js 0x4834ed
testl %r8d, %r8d
js 0x4834f4
movl %r8d, 0x48(%rsp)
leal -0x1(%r13), %eax
addq $0xf, %r13
shrq $0x4, %r13
movl %eax, 0x7c(%rsp)
cltd
idivl %r13d
movl %eax, %r14d
movl %edx, %r15d
movl 0xc(%rsp), %edx
movl %edx, %ebp
negl %ebp
movq 0x80(%rsp), %rsi
movl 0x20(%rsi), %eax
movl %eax, %ecx
negb %cl
cmpl %ebp, %eax
movzbl %cl, %eax
cmovgl %edx, %eax
movl %eax, 0x1c(%rsp)
movb $0x7e, %al
subb 0x1c(%rsi), %al
movb %al, 0x10(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r13d, %edi
movl %r12d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x4834f9
movq %rax, %rbx
movl %r15d, 0x78(%rsp)
movl %r14d, 0x3c(%rsp)
orl $0x10180801, 0xc(%rax)  # imm = 0x10180801
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x58(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x20(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x60(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %r13, %rsi
movq %rax, %r13
movl $0x10, %edi
movq %rsi, 0x28(%rsp)
callq 0x2ea474
movq %rax, %r15
movq %r12, 0x40(%rsp)
leal 0x1(%r12), %esi
movl $0x10, %edi
movq %rsi, 0x50(%rsp)
callq 0x2094c8
movq 0x58(%rsp), %r11
testq %r11, %r11
sete %dl
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %dl, %cl
cmpq $0x0, 0x60(%rsp)
sete %sil
movq %r14, 0x30(%rsp)
testq %r14, %r14
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %r13, %r13
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 0x4834f9
movq %rax, 0x68(%rsp)
movq 0x40(%rsp), %rax
decl %eax
movl %eax, 0x38(%rsp)
movl $0xf, %eax
subl 0x3c(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0xc(%rsp), %ecx
movd %ecx, %xmm4
pxor %xmm0, %xmm0
pshufb %xmm0, %xmm4
movl 0x48(%rsp), %edx
movd %edx, %xmm5
pshufb %xmm0, %xmm5
movl 0x1c(%rsp), %eax
addb $-0x7f, %al
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
movd %eax, %xmm1
pshufb %xmm0, %xmm1
movdqa %xmm1, 0x90(%rsp)
movzbl 0x10(%rsp), %eax
movd %eax, %xmm8
pshufb %xmm0, %xmm8
movl %ecx, %eax
movl %edx, %ecx
movslq %ebp, %rdx
movl 0x28(%rsp), %esi
negq %rax
movq %rsi, %rdi
movq %rcx, 0x10(%rsp)
imulq %rcx, %rdi
xorl %r8d, %r8d
movq $-0x80, %r9
movq 0x60(%rsp), %r14
movq %r11, %rcx
movq %rdx, %r10
xorl %r11d, %r11d
cmpq $-0x7f, %r10
movq $-0x80, %r12
cmovgeq %r10, %r12
movb %r12b, 0xd0(%rsp,%r11)
leaq (%rax,%r10), %r12
cmpq $-0x7f, %r12
cmovlq %r9, %r12
movb %r12b, 0xc0(%rsp,%r11)
incq %r11
subq %rdi, %r10
cmpq $0x10, %r11
jne 0x482ee5
movq %r8, %r10
shlq $0x4, %r10
movaps 0xd0(%rsp), %xmm0
movq %rcx, %r11
movaps %xmm0, (%rcx,%r10)
movdqa 0xc0(%rsp), %xmm0
movdqa %xmm0, (%r14,%r10)
movq 0x30(%rsp), %rcx
movdqa %xmm0, (%rcx,%r10)
incq %r8
subq 0x10(%rsp), %rdx
cmpq %rsi, %r8
jne 0x482edc
movq 0x68(%rsp), %rdi
movb $0x0, (%rdi)
movl $0x1, %eax
movl 0x48(%rsp), %edx
movq 0x50(%rsp), %r8
cmpl $-0x7f, %ebp
movl $0xffffff80, %ecx       # imm = 0xFFFFFF80
cmovgel %ebp, %ecx
movb %cl, (%rdi,%rax)
incq %rax
subl %edx, %ebp
cmpq %rax, %r8
jne 0x482f70
movq 0x28(%rsp), %r8
cmpl $0x1, %r8d
adcl $0x0, %r8d
shlq $0x4, %r8
xorl %eax, %eax
movdqa 0x1131dd(%rip), %xmm0   # 0x596180
movq 0x40(%rsp), %rdx
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa %xmm0, (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %r8
jne 0x482fa8
movq 0x28(%rsp), %rax
decl %eax
movl %edx, %r10d
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq %rcx, 0x58(%rsp)
movq %rsi, %rcx
shlq $0x4, %rcx
xorl %edx, %edx
shlq $0x4, %rax
movq %rax, 0x40(%rsp)
movdqa 0x11315e(%rip), %xmm9   # 0x596150
movdqa 0x1131b5(%rip), %xmm12  # 0x5961b0
movdqa 0x11319c(%rip), %xmm13  # 0x5961a0
movdqa 0x1749a3(%rip), %xmm14  # 0x5f79b0
movdqa 0x1749aa(%rip), %xmm15  # 0x5f79c0
movq %rcx, 0x50(%rsp)
movq %rcx, 0x10(%rsp)
xorl %r9d, %r9d
movdqa %xmm8, 0xb0(%rsp)
movdqa 0x90(%rsp), %xmm7
movq 0x30(%rsp), %rax
movq %r13, %rbp
movq %rax, %r13
movq 0x20(%rsp), %r12
movq 0x40(%rsp), %rcx
movdqa (%r11,%rcx), %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, (%rdi,%r9), %xmm0
movq %r11, 0x20(%rsp)
leaq (%r11,%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x88(%rsp), %rcx
movzbl (%rcx,%r9), %ecx
movslq (%rax,%rcx,4), %rax
movq %rsi, %rdi
imulq %rax, %rdi
shlq $0x4, %rdi
addq 0xa8(%rsp), %rdi
movq %r9, 0x48(%rsp)
incq %r9
movl $0x1, %eax
xorl %ecx, %ecx
movdqa 0x90(%rsp), %xmm11
movdqa (%r14,%rcx), %xmm10
paddsb (%rdi,%rcx), %xmm0
movdqa %xmm0, %xmm1
pmaxsb %xmm10, %xmm1
movdqa %xmm1, %xmm6
pmaxsb %xmm11, %xmm6
movdqa %xmm6, (%r12,%rcx)
movq 0x10(%rbx), %r11
movq (%r11), %r11
pcmpeqb %xmm6, %xmm0
pcmpgtb %xmm11, %xmm1
paddb %xmm9, %xmm1
pblendvb %xmm0, 0x113078(%rip), %xmm1 # 0x596170
addq %rdx, %r11
movdqa (%rcx,%r11), %xmm0
por %xmm1, %xmm0
movdqa %xmm1, (%r15,%rcx)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %rdx, %r11
movdqa %xmm0, (%rcx,%r11)
movdqa %xmm6, %xmm3
psubsb %xmm4, %xmm3
movdqa %xmm10, %xmm0
psubsb %xmm5, %xmm0
pmaxsb %xmm3, %xmm0
movdqa %xmm0, (%r14,%rcx)
movdqa (%r13,%rcx), %xmm1
psubsb %xmm5, %xmm1
movdqa %xmm3, %xmm0
pmaxsb %xmm1, %xmm0
movdqa %xmm0, (%rbp,%rcx)
cmpq %r10, %r9
jae 0x483181
movdqa %xmm3, %xmm0
pcmpgtb %xmm1, %xmm0
movdqa 0x11302a(%rip), %xmm1   # 0x596190
pblendvb %xmm0, 0x113011(%rip), %xmm1 # 0x596180
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq 0x10(%rsp), %r11
movdqa %xmm1, (%rcx,%r11)
movdqa %xmm11, %xmm2
psubsb %xmm5, %xmm2
cmpq %rsi, %rax
jae 0x4831ba
movq 0x10(%rbx), %r11
movq (%r11), %r11
movdqa %xmm3, %xmm0
pcmpgtb %xmm2, %xmm0
movdqa %xmm12, %xmm1
pblendvb %xmm0, %xmm13, %xmm1
addq %rdx, %r11
por 0x10(%rcx,%r11), %xmm1
movdqa %xmm1, 0x10(%rcx,%r11)
pmaxsb %xmm6, %xmm7
pminsb %xmm10, %xmm8
pminsb %xmm11, %xmm8
pminsb %xmm6, %xmm8
movdqa %xmm3, %xmm11
pmaxsb %xmm2, %xmm11
movq 0x20(%rsp), %r11
movdqa (%r11,%rcx), %xmm0
addq $0x10, %rcx
incq %rax
cmpq %rcx, %r8
jne 0x4830b5
movq $0x0, 0x30(%rsp)
movdqa %xmm11, %xmm0
movq 0x68(%rsp), %rcx
movq 0x48(%rsp), %r14
movsbl 0x1(%rcx,%r14), %eax
subl 0xc(%rsp), %eax
cmpl $-0x7f, %eax
movl $0xffffff80, %r11d      # imm = 0xFFFFFF80
cmovll %r11d, %eax
movq 0x28(%rsp), %r11
movdqa (%r11), %xmm6
pslldq $0x1, %xmm6             # xmm6 = zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, (%rcx,%r14), %xmm6
pslldq $0x1, %xmm3             # xmm3 = zero,xmm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, %eax, %xmm3
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, %eax, %xmm0
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, 0x1c(%rsp), %xmm2
pslldq $0x1, %xmm11            # xmm11 = zero,xmm11[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
pinsrb $0x0, %eax, %xmm11
movb $0x1, %al
movl $0x1, %r11d
xorl %ecx, %ecx
movdqa %xmm0, %xmm10
movdqa (%r12,%rcx), %xmm0
movdqa %xmm0, %xmm1
pmaxsb %xmm10, %xmm1
movdqa %xmm1, (%r12,%rcx)
paddsb (%rdi,%rcx), %xmm6
pcmpeqb %xmm1, %xmm6
pcmpgtb %xmm10, %xmm0
por %xmm6, %xmm0
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rdx, %r14
movdqa %xmm9, %xmm6
pblendvb %xmm0, (%r15,%rcx), %xmm6
movdqa (%rcx,%r14), %xmm0
pand %xmm14, %xmm0
movdqa %xmm6, (%r15,%rcx)
por %xmm0, %xmm6
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rdx, %r14
movdqa %xmm6, (%rcx,%r14)
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rdx, %r14
pcmpgtb %xmm2, %xmm3
movdqa %xmm12, %xmm6
movdqa %xmm3, %xmm0
pblendvb %xmm0, %xmm13, %xmm6
movdqa (%rcx,%r14), %xmm0
pand %xmm15, %xmm0
por %xmm6, %xmm0
movdqa %xmm0, (%rcx,%r14)
movdqa %xmm1, %xmm3
psubsb %xmm4, %xmm3
movdqa (%r13,%rcx), %xmm6
psubsb %xmm5, %xmm6
movdqa %xmm3, %xmm0
pmaxsb %xmm6, %xmm0
movdqa %xmm0, (%rbp,%rcx)
cmpq %r10, %r9
jae 0x483363
movdqa %xmm3, %xmm0
pcmpgtb %xmm6, %xmm0
movdqa 0x112e48(%rip), %xmm6   # 0x596190
pblendvb %xmm0, 0x112e2f(%rip), %xmm6 # 0x596180
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq 0x10(%rsp), %r14
movdqa %xmm6, (%rcx,%r14)
pminsb %xmm1, %xmm8
pmaxsb %xmm1, %xmm7
movdqa %xmm10, %xmm0
psubsb %xmm5, %xmm0
movdqa %xmm3, %xmm1
pcmpgtb %xmm0, %xmm1
pmovmskb %xmm1, %r14d
cmpl $0xffff, %r14d          # imm = 0xFFFF
je 0x4833c8
movdqa %xmm11, %xmm2
psubsb %xmm5, %xmm2
movdqa %xmm3, %xmm11
pmaxsb %xmm2, %xmm11
movq 0x20(%rsp), %rax
movdqa (%rax,%rcx), %xmm6
cmpq %rsi, %r11
setb %al
addq $0x10, %rcx
incq %r11
movdqa %xmm0, %xmm10
cmpq %rcx, %r8
jne 0x48327c
jmp 0x4833cd
movdqa %xmm10, %xmm0
testb $0x1, %al
jne 0x4833e7
movq 0x30(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl $0xf, %ecx
movq %rax, 0x30(%rsp)
jb 0x483205
movq 0x50(%rsp), %rax
addq %rax, 0x10(%rsp)
addq %rax, %rdx
movq %r12, %r11
movq %rbp, %rax
cmpq 0x58(%rsp), %r9
movq 0x60(%rsp), %r14
movq 0x68(%rsp), %rdi
jne 0x48303b
movl 0x78(%rsp), %eax
shlq $0x4, %rax
movdqa (%r12,%rax), %xmm0
cmpl $0xe, 0x3c(%rsp)
jg 0x483442
movl 0x74(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x38(%rsp), %edx
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %eax
jne 0x483437
jmp 0x483446
movl 0x38(%rsp), %edx
movdqa 0x90(%rsp), %xmm1
pcmpgtb %xmm8, %xmm1
pcmpgtb 0xb0(%rsp), %xmm7
por %xmm1, %xmm7
pmovmskb %xmm7, %eax
testl %eax, %eax
je 0x483475
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x48347f
pextrb $0xf, %xmm0, %eax
movl 0x7c(%rsp), %ecx
movsbl %al, %eax
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x20(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x4834fb
callq 0x1dd713
jmp 0x4834f9
callq 0x1dd6ed
jmp 0x4834f9
callq 0x1dd6c7
jmp 0x4834f9
callq 0x1dd6a1
jmp 0x4834f9
callq 0x1dd67b
jmp 0x4834f9
callq 0x1dd655
jmp 0x4834f9
callq 0x1dd62f
jmp 0x4834f9
callq 0x1dd609
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq