// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_striped_sse2_128_16.c
// Function: parasail_nw_trace_striped_profile_sse2_128_16
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;
    int16_t* restrict boundary = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    int16_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->profile16.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 = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m128i*)profile->profile16.score;
    vGapO = _mm_set1_epi16(open);
    vGapE = _mm_set1_epi16(gap);
    NEG_LIMIT = (-open < matrix->min ? INT16_MIN + open : INT16_MIN - matrix->min) + 1;
    POS_LIMIT = INT16_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm_set1_epi16(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vTIns  = _mm_set1_epi16(PARASAIL_INS);
    vTDel  = _mm_set1_epi16(PARASAIL_DEL);
    vTDiag = _mm_set1_epi16(PARASAIL_DIAG);
    vTDiagE = _mm_set1_epi16(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi16(PARASAIL_INS_E);
    vTDiagF = _mm_set1_epi16(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi16(PARASAIL_DEL_F);
    vTMask = _mm_set1_epi16(PARASAIL_ZERO_MASK);
    vFTMask = _mm_set1_epi16(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_16 | PARASAIL_FLAG_LANES_8;

    /* 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_int16_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_16_t h;
            __m128i_16_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT16_MIN ? INT16_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT16_MIN ? INT16_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 < INT16_MIN ? INT16_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 2 bytes */
        vH = _mm_load_si128(&pvHStore[segLen - 1]);
        vH = _mm_slli_si128(vH, 2);

        /* insert upper boundary condition */
        vH = _mm_insert_epi16(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_epi16(vH, _mm_load_si128(vP + i));
            vH = _mm_max_epi16(vH_dag, vE);
            vH = _mm_max_epi16(vH, vF);
            /* Save vH values. */
            _mm_store_si128(pvHStore + i, vH);
            vSaturationCheckMax = _mm_max_epi16(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vF);

            {
                __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __m128i case1 = _mm_cmpeq_epi16(vH, vH_dag);
                __m128i case2 = _mm_cmpeq_epi16(vH, vF);
                __m128i vT = _mm_blendv_epi8_rpl(
                        _mm_blendv_epi8_rpl(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_epi16(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm_subs_epi16(vE, vGapE);
            vE = _mm_max_epi16(vEF_opn, vE_ext);
            _mm_store_si128(pvE + i, vE);
            {
                __m128i vEa = _mm_load_si128(pvEaLoad + i);
                __m128i vEa_ext = _mm_subs_epi16(vEa, vGapE);
                vEa = _mm_max_epi16(vEF_opn, vEa_ext);
                _mm_store_si128(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m128i cond = _mm_cmpgt_epi16(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_epi16(vF, vGapE);
            vF = _mm_max_epi16(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m128i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m128i cond = _mm_cmpgt_epi16(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) {
            int64_t tmp = boundary[j+1]-open;
            int16_t tmp2 = tmp < INT16_MIN ? INT16_MIN : tmp;
            __m128i vHp = _mm_load_si128(&pvHLoad[segLen - 1]);
            vHp = _mm_slli_si128(vHp, 2);
            vHp = _mm_insert_epi16(vHp, boundary[j], 0);
            vEF_opn = _mm_slli_si128(vEF_opn, 2);
            vEF_opn = _mm_insert_epi16(vEF_opn, tmp2, 0);
            vF_ext = _mm_slli_si128(vF_ext, 2);
            vF_ext = _mm_insert_epi16(vF_ext, NEG_LIMIT, 0);
            vF = _mm_slli_si128(vF, 2);
            vF = _mm_insert_epi16(vF, tmp2, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 2);
            vFa_ext = _mm_insert_epi16(vFa_ext, NEG_LIMIT, 0);
            vFa = _mm_slli_si128(vFa, 2);
            vFa = _mm_insert_epi16(vFa, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi16(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
                vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm_max_epi16(vSaturationCheckMax, vH);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_adds_epi16(vHp, _mm_load_si128(vP + i));
                    case1 = _mm_cmpeq_epi16(vH, vHp);
                    case2 = _mm_cmpeq_epi16(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);
                }
                /* Update vF value. */
                {
                    __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m128i cond = _mm_cmpgt_epi16(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_epi16(vH, vGapO);
                vF_ext = _mm_subs_epi16(vF, vGapE);
                {
                    __m128i vEa = _mm_load_si128(pvEaLoad + i);
                    __m128i vEa_ext = _mm_subs_epi16(vEa, vGapE);
                    vEa = _mm_max_epi16(vEF_opn, vEa_ext);
                    _mm_store_si128(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m128i cond = _mm_cmpgt_epi16(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_epi16(vF_ext, vEF_opn),
                                _mm_cmpeq_epi16(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm_max_epi16(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm_subs_epi16(vFa, vGapE);
                vFa = _mm_max_epi16(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, 2);
        }
        score = (int16_t) _mm_extract_epi16 (vH, 7);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi16(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi16(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, 0x4(%rsp)
movq %rsi, 0x88(%rsp)
testq %rdi, %rdi
je 0x39dea1
movq 0x30(%rdi), %rax
movq %rax, 0xa8(%rsp)
testq %rax, %rax
je 0x39dea8
movq 0x10(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x39deaf
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x39deb6
cmpq $0x0, 0x88(%rsp)
je 0x39debd
movl %edx, %r12d
testl %edx, %edx
jle 0x39dec4
cmpl $0x0, 0x4(%rsp)
js 0x39decb
testl %r8d, %r8d
js 0x39ded2
movl %r8d, 0x40(%rsp)
leal -0x1(%r13), %eax
addq $0x7, %r13
shrq $0x3, %r13
movl %eax, 0x7c(%rsp)
cltd
idivl %r13d
movl %eax, %r14d
movl %edx, %r15d
movl 0x4(%rsp), %ecx
movl %ecx, %ebp
negl %ebp
movq 0x80(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negl %esi
cmpl %ebp, %eax
cmovgl %ecx, %esi
movl %esi, 0x14(%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x8(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r13d, %edi
movl %r12d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x39ded7
movq %rax, %rbx
movl %r15d, 0x78(%rsp)
movl %r14d, 0x2c(%rsp)
orl $0x8280801, 0xc(%rax)   # imm = 0x8280801
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x58(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x18(%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, 0x30(%rsp)
callq 0x2ea474
movq %rax, %r15
movq %r12, 0x38(%rsp)
leal 0x1(%r12), %esi
movl $0x10, %edi
movq %rsi, 0x50(%rsp)
callq 0x2094cd
movq 0x58(%rsp), %r11
testq %r11, %r11
sete %dl
cmpq $0x0, 0x18(%rsp)
sete %cl
orb %dl, %cl
cmpq $0x0, 0x60(%rsp)
sete %sil
movq %r14, 0x20(%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 0x39ded7
movq %r13, 0x48(%rsp)
movq %rax, 0x68(%rsp)
movq 0x38(%rsp), %rax
decl %eax
movl %eax, 0x28(%rsp)
movl $0x7, %eax
subl 0x2c(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x4(%rsp), %eax
movd %eax, %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
movl 0x40(%rsp), %edx
movd %edx, %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0x14(%rsp), %ecx
addl $0xffff8001, %ecx       # imm = 0xFFFF8001
movl %ecx, 0x14(%rsp)
movd %ecx, %xmm0
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, 0x90(%rsp)
movd 0x8(%rsp), %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm5      # xmm5 = xmm0[0,0,0,0]
movl %eax, %eax
movl %edx, %ecx
movslq %ebp, %rsi
movl 0x30(%rsp), %edx
negq %rax
movq %rdx, %rdi
movq %rcx, 0x8(%rsp)
imulq %rcx, %rdi
xorl %r8d, %r8d
movq $-0x7fff, %r9           # imm = 0x8001
movq $-0x8000, %r10          # imm = 0x8000
movq 0x60(%rsp), %r14
movq %r11, %r13
movq %rsi, %r11
xorl %r12d, %r12d
cmpq %r9, %r11
movq $-0x8000, %rcx          # imm = 0x8000
cmovgeq %r11, %rcx
movw %cx, 0xd0(%rsp,%r12,2)
leaq (%rax,%r11), %rcx
cmpq %r9, %rcx
cmovlq %r10, %rcx
movw %cx, 0xc0(%rsp,%r12,2)
incq %r12
subq %rdi, %r11
cmpq $0x8, %r12
jne 0x39d889
movq %r8, %rcx
shlq $0x4, %rcx
movaps 0xd0(%rsp), %xmm0
movq %r13, %r11
movaps %xmm0, (%r13,%rcx)
movdqa 0xc0(%rsp), %xmm0
movdqa %xmm0, (%r14,%rcx)
movq 0x20(%rsp), %r12
movdqa %xmm0, (%r12,%rcx)
incq %r8
subq 0x8(%rsp), %rsi
cmpq %rdx, %r8
jne 0x39d880
movq 0x68(%rsp), %rdi
movw $0x0, (%rdi)
movl $0x1, %eax
movl 0x40(%rsp), %esi
movq 0x50(%rsp), %r8
cmpl $0xffff8001, %ebp       # imm = 0xFFFF8001
movl $0xffff8000, %ecx       # imm = 0xFFFF8000
cmovgel %ebp, %ecx
movw %cx, (%rdi,%rax,2)
incq %rax
subl %esi, %ebp
cmpq %rax, %r8
jne 0x39d917
movq 0x30(%rsp), %r13
cmpl $0x1, %r13d
movq %r13, %r8
adcl $0x0, %r13d
shlq $0x4, %r13
xorl %eax, %eax
movdqa 0x25829f(%rip), %xmm0   # 0x5f5bf0
movq 0x38(%rsp), %rsi
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa %xmm0, (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %r13
jne 0x39d956
leal -0x1(%r8), %eax
movl %esi, %r9d
cmpl $0x2, %esi
movl $0x1, %ecx
cmovgel %esi, %ecx
movq %rcx, 0x58(%rsp)
movq %rdx, %rsi
shlq $0x4, %rsi
xorl %ecx, %ecx
shlq $0x4, %rax
movq %rax, 0x30(%rsp)
movdqa 0x259c54(%rip), %xmm6   # 0x5f75f0
movdqa 0x259c5b(%rip), %xmm12  # 0x5f7600
movdqa 0x259c22(%rip), %xmm10  # 0x5f75d0
movdqa 0x259c29(%rip), %xmm11  # 0x5f75e0
movdqa 0x259f80(%rip), %xmm13  # 0x5f7940
movq %rsi, 0x50(%rsp)
movq %rsi, 0x8(%rsp)
xorl %r8d, %r8d
movdqa %xmm5, 0xb0(%rsp)
movdqa 0x90(%rsp), %xmm4
movq 0x20(%rsp), %rsi
movq 0x48(%rsp), %rbp
movq 0x18(%rsp), %r12
movq %r8, %r10
movq 0x30(%rsp), %r8
movdqa (%r11,%r8), %xmm8
pslldq $0x2, %xmm8             # xmm8 = zero,zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, (%rdi,%r10,2), %xmm8
movq %rsi, %rdi
movq %r11, 0x18(%rsp)
leaq (%r11,%r8), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x88(%rsp), %rsi
movzbl (%rsi,%r10), %esi
movslq (%rax,%rsi,4), %rax
movq %rdx, %rsi
imulq %rax, %rsi
shlq $0x4, %rsi
addq 0xa8(%rsp), %rsi
movq %r10, 0x40(%rsp)
leaq 0x1(%r10), %r8
movl $0x1, %eax
xorl %r10d, %r10d
movdqa 0x90(%rsp), %xmm9
movdqa (%r14,%r10), %xmm1
paddsw (%rsi,%r10), %xmm8
movdqa %xmm8, %xmm0
pmaxsw %xmm1, %xmm0
movdqa %xmm0, %xmm7
pmaxsw %xmm9, %xmm7
movdqa %xmm7, (%r12,%r10)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %rcx, %r11
pcmpeqw %xmm7, %xmm8
pcmpgtw %xmm9, %xmm0
paddw %xmm6, %xmm0
movdqa %xmm8, %xmm14
pandn %xmm0, %xmm14
pand %xmm12, %xmm8
por %xmm14, %xmm8
movdqa (%r10,%r11), %xmm0
por %xmm8, %xmm0
movdqa %xmm8, (%r15,%r10)
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %rcx, %r11
movdqa %xmm0, (%r10,%r11)
movdqa %xmm7, %xmm0
psubsw %xmm2, %xmm0
movdqa %xmm1, %xmm8
psubsw %xmm3, %xmm8
pmaxsw %xmm0, %xmm8
movdqa %xmm8, (%r14,%r10)
movdqa (%rdi,%r10), %xmm8
psubsw %xmm3, %xmm8
movdqa %xmm0, %xmm14
pmaxsw %xmm8, %xmm14
movdqa %xmm14, (%rbp,%r10)
cmpq %r9, %r8
jae 0x39db42
movdqa %xmm0, %xmm14
pcmpgtw %xmm8, %xmm14
pand 0x259a99(%rip), %xmm14  # 0x5f75c0
pxor 0x2581a0(%rip), %xmm14  # 0x5f5cd0
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq 0x8(%rsp), %r11
movdqa %xmm14, (%r10,%r11)
movdqa %xmm9, %xmm14
psubsw %xmm3, %xmm14
cmpq %rdx, %rax
jae 0x39db7d
movq 0x10(%rbx), %r11
movq (%r11), %r11
addq %rcx, %r11
movdqa %xmm0, %xmm8
pcmpgtw %xmm14, %xmm8
pand %xmm10, %xmm8
pxor %xmm11, %xmm8
por 0x10(%r10,%r11), %xmm8
movdqa %xmm8, 0x10(%r10,%r11)
pmaxsw %xmm7, %xmm4
pminsw %xmm1, %xmm5
pminsw %xmm9, %xmm5
pminsw %xmm7, %xmm5
movdqa %xmm0, %xmm9
pmaxsw %xmm14, %xmm9
movq 0x18(%rsp), %r11
movdqa (%r11,%r10), %xmm8
addq $0x10, %r10
incq %rax
cmpq %r10, %r13
jne 0x39da65
movq %rdi, 0x48(%rsp)
movq $0x0, 0x20(%rsp)
movdqa %xmm9, %xmm1
movq 0x68(%rsp), %rdi
movswl (%rdi,%r8,2), %eax
subl 0x4(%rsp), %eax
cmpl $0xffff8001, %eax       # imm = 0xFFFF8001
movl $0xffff8000, %r10d      # imm = 0xFFFF8000
cmovll %r10d, %eax
movq 0x38(%rsp), %r10
movdqa (%r10), %xmm8
pslldq $0x2, %xmm8             # xmm8 = zero,zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movq 0x40(%rsp), %r10
pinsrw $0x0, (%rdi,%r10,2), %xmm8
pslldq $0x2, %xmm0             # xmm0 = zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %eax, %xmm0
pslldq $0x2, %xmm1             # xmm1 = zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %eax, %xmm1
pslldq $0x2, %xmm14            # xmm14 = zero,zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, 0x14(%rsp), %xmm14
pslldq $0x2, %xmm9             # xmm9 = zero,zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %eax, %xmm9
movb $0x1, %r10b
movl $0x1, %eax
xorl %r11d, %r11d
movdqa %xmm1, %xmm7
movq 0x48(%rsp), %rdi
movdqa (%r12,%r11), %xmm1
movdqa %xmm1, %xmm15
pmaxsw %xmm7, %xmm15
movdqa %xmm15, (%r12,%r11)
paddsw (%rsi,%r11), %xmm8
pcmpeqw %xmm15, %xmm8
pcmpgtw %xmm7, %xmm1
por %xmm8, %xmm1
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
movdqa (%r11,%r14), %xmm8
pand 0x259cac(%rip), %xmm8   # 0x5f7930
movdqa (%r15,%r11), %xmm12
pand %xmm1, %xmm12
pandn %xmm6, %xmm1
por %xmm12, %xmm1
movdqa %xmm1, (%r15,%r11)
por %xmm8, %xmm1
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
movdqa %xmm1, (%r11,%r14)
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
pcmpgtw %xmm14, %xmm0
pand %xmm10, %xmm0
movdqa (%r11,%r14), %xmm1
pand %xmm13, %xmm1
por %xmm0, %xmm1
pxor %xmm11, %xmm1
movdqa %xmm1, (%r11,%r14)
movdqa %xmm15, %xmm0
psubsw %xmm2, %xmm0
movdqa (%rdi,%r11), %xmm1
psubsw %xmm3, %xmm1
movdqa %xmm0, %xmm8
pmaxsw %xmm1, %xmm8
movdqa %xmm8, (%rbp,%r11)
cmpq %r9, %r8
jae 0x39dd38
movdqa %xmm0, %xmm8
pcmpgtw %xmm1, %xmm8
pand 0x2598a3(%rip), %xmm8   # 0x5f75c0
pxor 0x257faa(%rip), %xmm8   # 0x5f5cd0
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq 0x8(%rsp), %r14
movdqa %xmm8, (%r11,%r14)
pminsw %xmm15, %xmm5
pmaxsw %xmm15, %xmm4
movdqa %xmm7, %xmm1
psubsw %xmm3, %xmm1
movdqa %xmm0, %xmm8
pcmpgtw %xmm1, %xmm8
pmovmskb %xmm8, %r14d
cmpl $0xffff, %r14d          # imm = 0xFFFF
je 0x39dd9e
movdqa %xmm9, %xmm14
psubsw %xmm3, %xmm14
movdqa %xmm0, %xmm9
pmaxsw %xmm14, %xmm9
movq 0x18(%rsp), %r10
movdqa (%r10,%r11), %xmm8
cmpq %rdx, %rax
setb %r10b
addq $0x10, %r11
incq %rax
movdqa %xmm1, %xmm7
cmpq %r11, %r13
jne 0x39dc41
jmp 0x39dda2
movdqa %xmm7, %xmm1
testb $0x1, %r10b
jne 0x39ddbe
movq 0x20(%rsp), %rdi
leal 0x1(%rdi), %eax
cmpl $0x7, %edi
movq %rax, 0x20(%rsp)
jb 0x39dbc6
movq 0x50(%rsp), %rax
addq %rax, 0x8(%rsp)
addq %rax, %rcx
movq %r12, %r11
movq %rbp, %rsi
cmpq 0x58(%rsp), %r8
movq 0x60(%rsp), %r14
movq 0x68(%rsp), %rdi
movdqa 0x259817(%rip), %xmm12  # 0x5f7600
jne 0x39d9e4
movl 0x78(%rsp), %eax
shlq $0x4, %rax
movdqa (%r12,%rax), %xmm0
cmpl $0x6, 0x2c(%rsp)
jg 0x39de22
movl 0x74(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x28(%rsp), %edx
pslldq $0x2, %xmm0             # xmm0 = zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
decl %eax
jne 0x39de17
jmp 0x39de26
movl 0x28(%rsp), %edx
movdqa 0x90(%rsp), %xmm1
pcmpgtw %xmm5, %xmm1
pcmpgtw 0xb0(%rsp), %xmm4
por %xmm1, %xmm4
pmovmskb %xmm4, %eax
testl %eax, %eax
je 0x39de54
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x39de5d
pextrw $0x7, %xmm0, %eax
movl 0x7c(%rsp), %ecx
cwtl
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x48(%rsp), %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x18(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x39ded9
callq 0x1bf5f9
jmp 0x39ded7
callq 0x1bf5d3
jmp 0x39ded7
callq 0x1bf5ad
jmp 0x39ded7
callq 0x1bf587
jmp 0x39ded7
callq 0x1bf561
jmp 0x39ded7
callq 0x1bf53b
jmp 0x39ded7
callq 0x1bf515
jmp 0x39ded7
callq 0x1bf4ef
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop