// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_trace_striped_sse2_128_16.c
// Function: parasail_sw_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 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;
    int16_t score = 0;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    int16_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->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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m128i*)profile->profile16.score;
    vGapO = _mm_set1_epi16(open);
    vGapE = _mm_set1_epi16(gap);
    vZero = _mm_setzero_si128();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT16_MAX - (int16_t)(matrix->max+1);
    vTZero = _mm_set1_epi16(PARASAIL_ZERO);
    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_SW | 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);
    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_epi16(-open), segLen);
    parasail_memset___m128i(pvEaStore, _mm_set1_epi16(-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_epi16(vZero,vGapO);

        /* load final segment of pvHStore and shift left by 2 bytes */
        vH = _mm_load_si128(&pvHStore[segLen - 1]);
        vH = _mm_slli_si128(vH, 2);

        /* 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_epi16(vH, _mm_load_si128(vP + i));
            vH_dag = _mm_max_epi16(vH_dag, vZero);
            vH = _mm_max_epi16(vH_dag, vE);
            vH = _mm_max_epi16(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_epi16(vH, vZero);
                __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),
                        _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_epi16(vH, vMaxH);
            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) {
            __m128i vHp = _mm_load_si128(&pvHLoad[segLen - 1]);
            vHp = _mm_slli_si128(vHp, 2);
            vEF_opn = _mm_slli_si128(vEF_opn, 2);
            vEF_opn = _mm_insert_epi16(vEF_opn, -open, 0);
            vF_ext = _mm_slli_si128(vF_ext, 2);
            vF_ext = _mm_insert_epi16(vF_ext, NEG_INF, 0);
            vF = _mm_slli_si128(vF, 2);
            vF = _mm_insert_epi16(vF, -open, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 2);
            vFa_ext = _mm_insert_epi16(vFa_ext, NEG_INF, 0);
            vFa = _mm_slli_si128(vFa, 2);
            vFa = _mm_insert_epi16(vFa, -open, 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);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_adds_epi16(vHp, _mm_load_si128(vP + i));
                    vHp = _mm_max_epi16(vHp, vZero);
                    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);
                }
                vMaxH = _mm_max_epi16(vH, vMaxH);
                /* 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:
        {
        }

        {
            __m128i vCompare = _mm_cmpgt_epi16(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi16_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm_set1_epi16(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

    if (score == INT16_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. */
        {
            int16_t *t = (int16_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 $0xe8, %rsp
movq %rsi, 0x58(%rsp)
testq %rdi, %rdi
je 0x39f640
movq 0x30(%rdi), %rax
movq %rax, 0xb8(%rsp)
testq %rax, %rax
je 0x39f647
movq 0x10(%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x39f64e
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
jle 0x39f655
cmpq $0x0, 0x58(%rsp)
je 0x39f65c
movl %edx, %ebp
testl %edx, %edx
jle 0x39f663
testl %ecx, %ecx
js 0x39f66a
testl %r8d, %r8d
js 0x39f671
movl %r8d, 0x70(%rsp)
movl %ecx, 0xc(%rsp)
leaq 0x7(%r14), %r15
movq %r15, %r12
shrq $0x3, %r12
movq 0x50(%rsp), %rax
movl 0x1c(%rax), %r13d
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %ebp, %esi
callq 0x2097d1
testq %rax, %rax
je 0x39f676
movq %rax, %rbx
movl %r13d, 0x4(%rsp)
movl %ebp, 0x20(%rsp)
movq %r15, 0x98(%rsp)
movq %r14, 0xa0(%rsp)
orl $0x8280804, 0xc(%rax)   # imm = 0x8280804
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r15
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %r12, %r13
movq %rax, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x38(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x18(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r13, 0x28(%rsp)
movq %r13, %rsi
callq 0x2ea474
movq %rax, %rcx
xorl %eax, %eax
testq %r15, %r15
je 0x39f6c7
testq %r12, %r12
je 0x39f6c7
cmpq $0x0, 0x38(%rsp)
je 0x39f6c7
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0x39f6c7
testq %r14, %r14
je 0x39f6c7
testq %rbp, %rbp
je 0x39f6c7
testq %rcx, %rcx
je 0x39f6c7
movq %rcx, 0x30(%rsp)
movl 0xc(%rsp), %r13d
movd %r13d, %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, 0x80(%rsp)
movd 0x70(%rsp), %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, 0x70(%rsp)
pxor %xmm0, %xmm0
movq %r15, %rdi
movq 0x28(%rsp), %rsi
callq 0x2ea47d
negl %r13d
movl %r13d, 0xc(%rsp)
movd %r13d, %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, 0x60(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %r13
movq %r13, %rsi
callq 0x2ea47d
movq 0x18(%rsp), %rdi
movaps 0x60(%rsp), %xmm0
movq %r13, %rsi
callq 0x2ea47d
movl %r13d, %eax
movq %rax, 0x60(%rsp)
movq %rax, %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movdqa 0x256bb7(%rip), %xmm0   # 0x5f5bf0
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa %xmm0, (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %rdx
jne 0x39f039
pxor %xmm0, %xmm0
pxor %xmm1, %xmm1
psubsw 0x80(%rsp), %xmm1
movdqa %xmm1, 0xd0(%rsp)
movq 0x28(%rsp), %rsi
leal -0x1(%rsi), %ecx
movl $0x7ffe, %eax           # imm = 0x7FFE
subl 0x4(%rsp), %eax
cmpl $0x1, %esi
adcl $0x0, %esi
cwtl
movl %eax, 0x4c(%rsp)
movl 0x20(%rsp), %edi
movl %edi, %r8d
cmpl $0x2, %edi
movl $0x1, %eax
cmovgel %edi, %eax
movq %rax, 0x40(%rsp)
shlq $0x4, %rsi
movw $0x8000, %ax            # imm = 0x8000
movl %eax, 0x8(%rsp)
xorl %r9d, %r9d
shlq $0x4, %rcx
movq %rcx, 0xb0(%rsp)
movdqa 0x258532(%rip), %xmm2   # 0x5f75f0
movdqa 0x256c0a(%rip), %xmm5   # 0x5f5cd0
movdqa 0x258502(%rip), %xmm6   # 0x5f75d0
movdqa 0x25850a(%rip), %xmm7   # 0x5f75e0
movdqa 0x258851(%rip), %xmm8   # 0x5f7930
movdqa 0x258858(%rip), %xmm9   # 0x5f7940
movq %rdx, 0x20(%rsp)
xorl %eax, %eax
xorl %r11d, %r11d
pxor %xmm10, %xmm10
pxor %xmm1, %xmm1
movdqa %xmm1, 0xc0(%rsp)
movq 0x18(%rsp), %rcx
movq %rdx, 0xa8(%rsp)
movq 0x30(%rsp), %r10
movq %r10, 0x10(%rsp)
movq %r14, %r13
movq %rcx, %r14
movq %r12, %rdx
movq %r15, %r12
movl %r11d, %r15d
movq 0xb0(%rsp), %r11
leaq (%r12,%r11), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rdi
movzbl (%rdi,%rcx), %edi
movslq (%rax,%rdi,4), %rdi
movq 0x60(%rsp), %rax
imulq %rdi, %rax
shlq $0x4, %rax
addq 0xb8(%rsp), %rax
leal -0x2(%rcx), %edi
movl %r15d, 0x4(%rsp)
cmpl %edi, %r15d
cmoveq %rdx, %r10
movq %r10, 0x30(%rsp)
movq %rdx, %r15
cmoveq 0x10(%rsp), %r15
movdqa (%r12,%r11), %xmm13
pslldq $0x2, %xmm13            # xmm13 = zero,zero,xmm13[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movq %rcx, 0x10(%rsp)
leaq 0x1(%rcx), %rdi
movl $0x1, %ecx
xorl %edx, %edx
movdqa 0xd0(%rsp), %xmm3
movq 0x38(%rsp), %r11
movdqa (%r11,%rdx), %xmm14
paddsw (%rax,%rdx), %xmm13
pmaxsw %xmm0, %xmm13
movdqa %xmm13, %xmm1
pmaxsw %xmm14, %xmm1
movdqa %xmm1, %xmm15
pmaxsw %xmm3, %xmm15
movdqa %xmm15, (%r15,%rdx)
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %r9, %r10
pcmpeqw %xmm15, %xmm13
movdqa %xmm15, %xmm11
pcmpgtw %xmm0, %xmm11
pand %xmm13, %xmm11
pand 0x2583fe(%rip), %xmm11  # 0x5f7600
pcmpgtw %xmm3, %xmm1
paddw %xmm2, %xmm1
pandn %xmm1, %xmm13
por %xmm11, %xmm13
movdqa (%rdx,%r10), %xmm1
por %xmm13, %xmm1
movdqa %xmm13, (%rbp,%rdx)
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %r9, %r10
movdqa %xmm1, (%rdx,%r10)
movdqa %xmm15, %xmm1
psubsw 0x80(%rsp), %xmm1
movdqa 0x70(%rsp), %xmm4
psubsw %xmm4, %xmm14
pmaxsw %xmm1, %xmm14
movdqa %xmm14, (%r11,%rdx)
movdqa (%r14,%rdx), %xmm11
psubsw %xmm4, %xmm11
movdqa %xmm1, %xmm12
pmaxsw %xmm11, %xmm12
movdqa %xmm12, (%r13,%rdx)
cmpq %r8, %rdi
jae 0x39f2a5
movdqa %xmm1, %xmm12
pcmpgtw %xmm11, %xmm12
pand 0x258332(%rip), %xmm12  # 0x5f75c0
pxor %xmm5, %xmm12
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq 0x20(%rsp), %r10
movdqa %xmm12, (%rdx,%r10)
movdqa %xmm3, %xmm14
psubsw %xmm4, %xmm14
cmpq 0x60(%rsp), %rcx
jae 0x39f2df
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %r9, %r10
movdqa %xmm1, %xmm3
pcmpgtw %xmm14, %xmm3
pand %xmm6, %xmm3
pxor %xmm7, %xmm3
por 0x10(%rdx,%r10), %xmm3
movdqa %xmm3, 0x10(%rdx,%r10)
pmaxsw %xmm15, %xmm10
movdqa %xmm1, %xmm3
pmaxsw %xmm14, %xmm3
movdqa (%r12,%rdx), %xmm13
addq $0x10, %rdx
incq %rcx
cmpq %rdx, %rsi
jne 0x39f1ab
xorl %edx, %edx
movdqa %xmm3, %xmm15
movl 0xc(%rsp), %r11d
pslldq $0x2, %xmm15            # xmm15 = zero,zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %r11d, %xmm15
pslldq $0x2, %xmm14            # xmm14 = zero,zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movl $0x8000, %ecx           # imm = 0x8000
pinsrw $0x0, %ecx, %xmm14
pslldq $0x2, %xmm3             # xmm3 = zero,zero,xmm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %r11d, %xmm3
pslldq $0x2, %xmm1             # xmm1 = zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %r11d, %xmm1
movq 0x18(%rsp), %rcx
movdqa (%rcx), %xmm11
pslldq $0x2, %xmm11            # xmm11 = zero,zero,xmm11[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
xorl %ecx, %ecx
movdqa (%r15,%rcx), %xmm13
movdqa %xmm13, %xmm12
pmaxsw %xmm3, %xmm12
movdqa %xmm12, (%r15,%rcx)
paddsw (%rax,%rcx), %xmm11
pmaxsw %xmm0, %xmm11
pcmpeqw %xmm12, %xmm11
pcmpgtw %xmm3, %xmm13
por %xmm11, %xmm13
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %r9, %r10
movdqa (%rcx,%r10), %xmm11
pand %xmm8, %xmm11
movdqa (%rbp,%rcx), %xmm4
pand %xmm13, %xmm4
pandn %xmm2, %xmm13
por %xmm4, %xmm13
movdqa %xmm13, (%rbp,%rcx)
por %xmm11, %xmm13
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %r9, %r10
movdqa %xmm13, (%rcx,%r10)
movdqa 0x70(%rsp), %xmm13
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %r9, %r10
pcmpgtw %xmm14, %xmm1
pand %xmm6, %xmm1
movdqa (%rcx,%r10), %xmm4
pand %xmm9, %xmm4
por %xmm1, %xmm4
pxor %xmm7, %xmm4
movdqa %xmm4, (%rcx,%r10)
movdqa %xmm12, %xmm1
psubsw 0x80(%rsp), %xmm1
movdqa (%r14,%rcx), %xmm11
psubsw %xmm13, %xmm11
movdqa %xmm1, %xmm4
pmaxsw %xmm11, %xmm4
movdqa %xmm4, (%r13,%rcx)
cmpq %r8, %rdi
jae 0x39f452
movdqa %xmm1, %xmm4
pcmpgtw %xmm11, %xmm4
pand 0x258184(%rip), %xmm4   # 0x5f75c0
pxor %xmm5, %xmm4
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq 0x20(%rsp), %r10
movdqa %xmm4, (%rcx,%r10)
pmaxsw %xmm12, %xmm10
movdqa %xmm3, %xmm12
psubsw %xmm13, %xmm12
movdqa %xmm1, %xmm4
pcmpgtw %xmm12, %xmm4
pmovmskb %xmm4, %r10d
xorl $0xffff, %r10d          # imm = 0xFFFF
setne %r10b
je 0x39f4b1
movdqa %xmm15, %xmm14
psubsw %xmm13, %xmm14
movdqa %xmm1, %xmm15
pmaxsw %xmm14, %xmm15
movdqa (%r12,%rcx), %xmm11
addq $0x10, %rcx
movdqa %xmm12, %xmm3
cmpq %rcx, %rsi
jne 0x39f354
xorl %ecx, %ecx
movdqa %xmm12, %xmm3
jmp 0x39f4b6
movl $0x21, %ecx
testl %ecx, %ecx
jne 0x39f4c7
incl %edx
cmpl $0x8, %edx
jne 0x39f30f
jmp 0x39f4cc
cmpl $0x21, %ecx
jne 0x39f52b
movdqa %xmm10, %xmm1
pcmpgtw 0xc0(%rsp), %xmm1
pmovmskb %xmm1, %eax
movb $0x1, %r10b
testl %eax, %eax
je 0x39f52b
movdqa %xmm10, %xmm1
psrldq $0x8, %xmm1             # xmm1 = xmm1[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pmaxsw %xmm10, %xmm1
movdqa %xmm1, %xmm3
psrldq $0x4, %xmm3             # xmm3 = xmm3[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
pmaxsw %xmm1, %xmm3
movdqa %xmm3, %xmm1
psrldq $0x2, %xmm1             # xmm1 = xmm1[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
pmaxsw %xmm3, %xmm1
movd %xmm1, %eax
movl %eax, 0x8(%rsp)
cwtl
cmpl %eax, 0x4c(%rsp)
movl 0x4(%rsp), %r11d
jge 0x39f537
orb $0x40, 0xc(%rbx)
xorl %r10d, %r10d
jmp 0x39f530
movl 0x4(%rsp), %r11d
movq 0x10(%rsp), %rax
jmp 0x39f552
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0xc0(%rsp)
movq 0x10(%rsp), %rax
movl %eax, %r11d
testb %r10b, %r10b
je 0x39f57a
movq 0xa8(%rsp), %rdx
addq %rdx, 0x20(%rsp)
addq %rdx, %r9
movq %rdi, %rax
movq %r13, %rcx
cmpq 0x40(%rsp), %rdi
jne 0x39f111
jmp 0x39f57f
movq %rax, 0x40(%rsp)
movl %r11d, 0x4(%rsp)
movzwl 0x8(%rsp), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x39f594
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
callq 0x20a805
xorl %ecx, %ecx
testl %eax, %eax
je 0x39f5b2
movq 0x30(%rsp), %rdi
xorl %r10d, %r10d
xorl %r8d, %r8d
jmp 0x39f683
movq 0x40(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0x4(%rsp), %r10d
cmpl %ecx, %r10d
movq 0x30(%rsp), %rcx
movq %rcx, %rdi
cmoveq %r12, %rdi
movq %r12, %rdx
cmoveq %rcx, %rdx
cmpl %eax, %r10d
cmoveq %r15, %rdi
cmoveq %r12, %rdx
movq %rdx, %r12
cmoveq %rcx, %r15
movq 0xa0(%rsp), %r8
decl %r8d
testl $0x7ffffff8, 0x98(%rsp) # imm = 0x7FFFFFF8
je 0x39f67a
movq 0x28(%rsp), %r9
movl %r9d, %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
shll $0x3, %eax
xorl %ecx, %ecx
movl 0x8(%rsp), %r11d
cmpw %r11w, (%rdi,%rcx,2)
jne 0x39f637
movl %ecx, %edx
shrl $0x3, %edx
movl %ecx, %esi
andl $0x7, %esi
imull %r9d, %esi
addl %edx, %esi
cmpl %r8d, %esi
cmovll %esi, %r8d
incq %rcx
cmpl %ecx, %eax
jne 0x39f619
jmp 0x39f67f
callq 0x1bfa6d
jmp 0x39f676
callq 0x1bfa47
jmp 0x39f676
callq 0x1bfa21
jmp 0x39f676
callq 0x1bf9fb
jmp 0x39f676
callq 0x1bf9d5
jmp 0x39f676
callq 0x1bf9af
jmp 0x39f676
callq 0x1bf989
jmp 0x39f676
callq 0x1bf963
xorl %eax, %eax
jmp 0x39f6c7
movl 0x8(%rsp), %r11d
movswl %r11w, %ecx
movl %ecx, (%rbx)
movl %r8d, 0x4(%rbx)
movl %r10d, 0x8(%rbx)
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq 0x38(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)