// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_striped_sse2_128_32.c
// Function: parasail_sw_trace_striped_profile_sse2_128_32
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;
    int32_t score = 0;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    int32_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->profile32.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 = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m128i*)profile->profile32.score;
    vGapO = _mm_set1_epi32(open);
    vGapE = _mm_set1_epi32(gap);
    vZero = _mm_setzero_si128();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT32_MAX - (int32_t)(matrix->max+1);
    vTZero = _mm_set1_epi32(PARASAIL_ZERO);
    vTIns  = _mm_set1_epi32(PARASAIL_INS);
    vTDel  = _mm_set1_epi32(PARASAIL_DEL);
    vTDiag = _mm_set1_epi32(PARASAIL_DIAG);
    vTDiagE= _mm_set1_epi32(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi32(PARASAIL_INS_E);
    vTDiagF= _mm_set1_epi32(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi32(PARASAIL_DEL_F);
    vTMask = _mm_set1_epi32(PARASAIL_ZERO_MASK);
    vFTMask= _mm_set1_epi32(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_32 | PARASAIL_FLAG_LANES_4;

    /* 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_epi32(-open), segLen);
    parasail_memset___m128i(pvEaStore, _mm_set1_epi32(-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_sub_epi32(vZero,vGapO);

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

        /* 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_add_epi32(vH, _mm_load_si128(vP + i));
            vH_dag = _mm_max_epi32_rpl(vH_dag, vZero);
            vH = _mm_max_epi32_rpl(vH_dag, vE);
            vH = _mm_max_epi32_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_epi32(vH, vZero);
                __m128i case1 = _mm_cmpeq_epi32(vH, vH_dag);
                __m128i case2 = _mm_cmpeq_epi32(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_epi32_rpl(vH, vMaxH);
            vEF_opn = _mm_sub_epi32(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm_sub_epi32(vE, vGapE);
            vE = _mm_max_epi32_rpl(vEF_opn, vE_ext);
            _mm_store_si128(pvE + i, vE);
            {
                __m128i vEa = _mm_load_si128(pvEaLoad + i);
                __m128i vEa_ext = _mm_sub_epi32(vEa, vGapE);
                vEa = _mm_max_epi32_rpl(vEF_opn, vEa_ext);
                _mm_store_si128(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m128i cond = _mm_cmpgt_epi32(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_sub_epi32(vF, vGapE);
            vF = _mm_max_epi32_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_epi32(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, 4);
            vEF_opn = _mm_slli_si128(vEF_opn, 4);
            vEF_opn = _mm_insert_epi32_rpl(vEF_opn, -open, 0);
            vF_ext = _mm_slli_si128(vF_ext, 4);
            vF_ext = _mm_insert_epi32_rpl(vF_ext, NEG_INF, 0);
            vF = _mm_slli_si128(vF, 4);
            vF = _mm_insert_epi32_rpl(vF, -open, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 4);
            vFa_ext = _mm_insert_epi32_rpl(vFa_ext, NEG_INF, 0);
            vFa = _mm_slli_si128(vFa, 4);
            vFa = _mm_insert_epi32_rpl(vFa, -open, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi32_rpl(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_add_epi32(vHp, _mm_load_si128(vP + i));
                    vHp = _mm_max_epi32_rpl(vHp, vZero);
                    case1 = _mm_cmpeq_epi32(vH, vHp);
                    case2 = _mm_cmpeq_epi32(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_epi32_rpl(vH, vMaxH);
                /* Update vF value. */
                {
                    __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m128i cond = _mm_cmpgt_epi32(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_sub_epi32(vH, vGapO);
                vF_ext = _mm_sub_epi32(vF, vGapE);
                {
                    __m128i vEa = _mm_load_si128(pvEaLoad + i);
                    __m128i vEa_ext = _mm_sub_epi32(vEa, vGapE);
                    vEa = _mm_max_epi32_rpl(vEF_opn, vEa_ext);
                    _mm_store_si128(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m128i cond = _mm_cmpgt_epi32(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_epi32(vF_ext, vEF_opn),
                                _mm_cmpeq_epi32(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm_max_epi32_rpl(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm_sub_epi32(vFa, vGapE);
                vFa = _mm_max_epi32_rpl(vEF_opn, vFa_ext);
                vHp = _mm_load_si128(pvHLoad + i);
            }
        }
end:
        {
        }

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

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

    if (score == INT32_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. */
        {
            int32_t *t = (int32_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, 0x78(%rsp)
testq %rdi, %rdi
je 0x3bb5f9
movq 0x48(%rdi), %rax
movq %rax, 0xb0(%rsp)
testq %rax, %rax
je 0x3bb600
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x3bb607
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x3bb60e
cmpq $0x0, 0x78(%rsp)
je 0x3bb615
movl %edx, %r15d
testl %edx, %edx
jle 0x3bb61c
testl %ecx, %ecx
js 0x3bb623
movl %r8d, %ebp
testl %r8d, %r8d
js 0x3bb62a
movl %ecx, 0x10(%rsp)
leaq 0x3(%r12), %r14
movq %r14, %r13
shrq $0x2, %r13
movl $0x7ffffffe, %ecx       # imm = 0x7FFFFFFE
movq 0x70(%rsp), %rax
subl 0x1c(%rax), %ecx
movl %ecx, 0x4c(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r13d, %edi
movl %r15d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3bb62f
movq %rax, %rbx
movl %ebp, 0x50(%rsp)
movq %r12, 0x90(%rsp)
movq %r15, 0x40(%rsp)
movq %r14, 0x98(%rsp)
orl $0x4480804, 0xc(%rax)   # imm = 0x4480804
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r14
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, 0x38(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %r13, %rsi
movq %rax, %r13
movl $0x10, %edi
movq %rsi, 0x30(%rsp)
callq 0x2f600c
movq %rax, %rdx
movq %r15, %xmm0
movq %r14, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq 0x38(%rsp), %xmm1
movq %r12, 0x28(%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 0x3bb631
testq %rbp, %rbp
je 0x3bb631
testq %r13, %r13
je 0x3bb631
testq %rdx, %rdx
je 0x3bb631
movq %rdx, 0x20(%rsp)
movd 0x10(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x80(%rsp)
movd 0x50(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x50(%rsp)
pxor %xmm0, %xmm0
movq %r15, %rdi
movq 0x30(%rsp), %r12
movq %r12, %rsi
callq 0x2f6015
movl 0x10(%rsp), %eax
negl %eax
movl %eax, 0x10(%rsp)
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x60(%rsp)
movq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x2f6015
movq 0x28(%rsp), %rdi
movaps 0x60(%rsp), %xmm0
movq %r12, %rsi
callq 0x2f6015
shlq $0x4, %r12
xorl %ecx, %ecx
movdqa 0x270ca6(%rip), %xmm0   # 0x62baf0
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
movdqa %xmm0, (%rdx,%rcx)
addq $0x10, %rcx
cmpq %rcx, %r12
jne 0x3bae4a
pxor %xmm0, %xmm0
pxor %xmm1, %xmm1
psubd 0x80(%rsp), %xmm1
movdqa %xmm1, 0xc0(%rsp)
movq 0x30(%rsp), %rax
leal -0x1(%rax), %edx
movl 0x40(%rsp), %ecx
movl %eax, %esi
movq %rsi, 0xa0(%rsp)
shlq $0x4, %rsi
movl $0xc0000000, 0xc(%rsp)  # imm = 0xC0000000
xorl %edi, %edi
shlq $0x4, %rdx
movq %rdx, 0xa8(%rsp)
movdqa 0x2708df(%rip), %xmm2   # 0x62b790
movdqa 0x26ec36(%rip), %xmm11  # 0x629af0
movdqa 0x27088e(%rip), %xmm3   # 0x62b750
movdqa 0x270896(%rip), %xmm4   # 0x62b760
movdqa 0x27089e(%rip), %xmm5   # 0x62b770
movdqa 0x2708a6(%rip), %xmm6   # 0x62b780
movdqa 0x270c2d(%rip), %xmm9   # 0x62bb10
movq %rsi, 0x60(%rsp)
xorl %r9d, %r9d
movl $0x0, 0x14(%rsp)
pxor %xmm10, %xmm10
pxor %xmm7, %xmm7
movq 0x28(%rsp), %rax
movdqa %xmm7, 0xd0(%rsp)
movq 0x20(%rsp), %r10
movq %r10, 0x18(%rsp)
movq %rbp, %r12
movq %rax, %rbp
movq %r14, 0xb8(%rsp)
movq %r15, %r14
movq %r9, %rax
movq 0xa8(%rsp), %r11
leaq (%r15,%r11), %rdx
movq %rdx, 0x28(%rsp)
movq 0x70(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x78(%rsp), %r8
movzbl (%r8,%r9), %r9d
movslq (%rdx,%r9,4), %r9
movq 0xa0(%rsp), %rdx
imulq %r9, %rdx
shlq $0x4, %rdx
addq 0xb0(%rsp), %rdx
leal -0x2(%rax), %r9d
cmpl %r9d, 0x14(%rsp)
movq 0xb8(%rsp), %r15
cmoveq %r15, %r10
movq %r10, 0x20(%rsp)
cmoveq 0x18(%rsp), %r15
movdqa (%r14,%r11), %xmm14
pslldq $0x4, %xmm14            # xmm14 = zero,zero,zero,zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11]
movq %rax, 0x18(%rsp)
leaq 0x1(%rax), %r9
movl $0x1, %eax
xorl %r11d, %r11d
movdqa 0xc0(%rsp), %xmm12
paddd (%rdx,%r11), %xmm14
movq 0x38(%rsp), %r8
movdqa (%r8,%r11), %xmm15
movdqa %xmm14, %xmm7
pcmpgtd %xmm0, %xmm7
pand %xmm14, %xmm7
movdqa %xmm7, %xmm13
pcmpgtd %xmm15, %xmm13
movdqa %xmm7, %xmm14
pand %xmm13, %xmm14
pandn %xmm15, %xmm13
por %xmm14, %xmm13
movdqa %xmm13, %xmm14
pcmpgtd %xmm12, %xmm14
pand %xmm14, %xmm13
movdqa %xmm14, %xmm1
pandn %xmm12, %xmm1
por %xmm13, %xmm1
movdqa %xmm1, (%r15,%r11)
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %rdi, %r10
pcmpeqd %xmm1, %xmm7
movdqa %xmm1, %xmm13
pcmpeqd %xmm0, %xmm13
pandn %xmm7, %xmm13
paddd %xmm2, %xmm14
pand %xmm11, %xmm13
pandn %xmm14, %xmm7
por %xmm13, %xmm7
movdqa (%r11,%r10), %xmm13
por %xmm7, %xmm13
movdqa %xmm7, (%r13,%r11)
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %rdi, %r10
movdqa %xmm13, (%r11,%r10)
movdqa %xmm1, %xmm8
psubd 0x80(%rsp), %xmm8
movdqa 0x50(%rsp), %xmm13
psubd %xmm13, %xmm15
movdqa %xmm8, %xmm7
pcmpgtd %xmm15, %xmm7
movdqa %xmm8, %xmm14
pand %xmm7, %xmm14
pandn %xmm15, %xmm7
por %xmm14, %xmm7
movdqa %xmm7, (%r8,%r11)
movdqa (%rbp,%r11), %xmm14
psubd %xmm13, %xmm14
movdqa %xmm8, %xmm13
pcmpgtd %xmm14, %xmm13
movdqa %xmm8, %xmm15
pand %xmm13, %xmm15
movdqa %xmm13, %xmm7
pandn %xmm14, %xmm7
por %xmm15, %xmm7
movdqa %xmm7, (%r12,%r11)
cmpq %rcx, %r9
jae 0x3bb0f8
pand %xmm3, %xmm13
pxor %xmm4, %xmm13
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq 0x60(%rsp), %r10
movdqa %xmm13, (%r11,%r10)
movdqa %xmm12, %xmm15
psubd 0x50(%rsp), %xmm15
movdqa %xmm8, %xmm12
pcmpgtd %xmm15, %xmm12
cmpq 0x30(%rsp), %rax
jae 0x3bb13a
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %rdi, %r10
movdqa %xmm12, %xmm7
pand %xmm5, %xmm7
pxor %xmm6, %xmm7
por 0x10(%r11,%r10), %xmm7
movdqa %xmm7, 0x10(%r11,%r10)
movdqa %xmm1, %xmm7
pcmpgtd %xmm10, %xmm7
pand %xmm7, %xmm1
pandn %xmm10, %xmm7
movdqa %xmm7, %xmm10
por %xmm1, %xmm10
movdqa %xmm8, %xmm1
pand %xmm12, %xmm1
pandn %xmm15, %xmm12
por %xmm1, %xmm12
movaps (%r14,%r11), %xmm14
addq $0x10, %r11
incq %rax
cmpq %r11, %rsi
jne 0x3bafaf
xorl %eax, %eax
movdqa %xmm12, %xmm14
movl 0x10(%rsp), %r8d
movdqa 0x50(%rsp), %xmm13
pshufd $0x90, %xmm14, %xmm14   # xmm14 = xmm14[0,0,1,2]
movd %r8d, %xmm1
movss %xmm1, %xmm14           # xmm14 = xmm1[0],xmm14[1,2,3]
pshufd $0x90, %xmm15, %xmm15   # xmm15 = xmm15[0,0,1,2]
movss 0x2709d0(%rip), %xmm7   # 0x62bb80
movss %xmm7, %xmm15           # xmm15 = xmm7[0],xmm15[1,2,3]
pshufd $0x90, %xmm12, %xmm12   # xmm12 = xmm12[0,0,1,2]
movss %xmm1, %xmm12           # xmm12 = xmm1[0],xmm12[1,2,3]
pshufd $0x90, %xmm8, %xmm8     # xmm8 = xmm8[0,0,1,2]
movss %xmm1, %xmm8            # xmm8 = xmm1[0],xmm8[1,2,3]
movq 0x28(%rsp), %r10
movdqa (%r10), %xmm7
pslldq $0x4, %xmm7             # xmm7 = zero,zero,zero,zero,xmm7[0,1,2,3,4,5,6,7,8,9,10,11]
xorl %r11d, %r11d
pcmpgtd %xmm15, %xmm8
movdqa (%r15,%r11), %xmm1
movdqa %xmm13, %xmm11
movdqa %xmm1, %xmm13
pcmpgtd %xmm12, %xmm13
pand %xmm13, %xmm1
movdqa %xmm13, %xmm15
pandn %xmm12, %xmm15
por %xmm1, %xmm15
movdqa %xmm15, (%r15,%r11)
paddd (%rdx,%r11), %xmm7
movdqa %xmm7, %xmm1
pcmpgtd %xmm0, %xmm1
pand %xmm7, %xmm1
pcmpeqd %xmm15, %xmm1
por %xmm13, %xmm1
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %rdi, %r10
movdqa (%r11,%r10), %xmm7
pand 0x2708bb(%rip), %xmm7   # 0x62bb00
movdqa (%r13,%r11), %xmm13
pand %xmm1, %xmm13
pandn %xmm2, %xmm1
por %xmm13, %xmm1
movdqa %xmm1, (%r13,%r11)
por %xmm7, %xmm1
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %rdi, %r10
movdqa %xmm1, (%r11,%r10)
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq %rdi, %r10
pand %xmm5, %xmm8
movdqa (%r11,%r10), %xmm1
pand %xmm9, %xmm1
por %xmm8, %xmm1
pxor %xmm6, %xmm1
movdqa %xmm1, (%r11,%r10)
movdqa %xmm15, %xmm8
psubd 0x80(%rsp), %xmm8
movdqa (%rbp,%r11), %xmm1
psubd %xmm11, %xmm1
movdqa %xmm8, %xmm11
pcmpgtd %xmm1, %xmm11
movdqa %xmm8, %xmm13
pand %xmm11, %xmm13
movdqa %xmm11, %xmm7
pandn %xmm1, %xmm7
por %xmm13, %xmm7
movdqa %xmm7, (%r12,%r11)
cmpq %rcx, %r9
jae 0x3bb302
pand %xmm3, %xmm11
pxor %xmm4, %xmm11
movq 0x10(%rbx), %r10
movq (%r10), %r10
addq 0x60(%rsp), %r10
movdqa %xmm11, (%r11,%r10)
movdqa %xmm15, %xmm1
pcmpgtd %xmm10, %xmm1
pand %xmm1, %xmm15
pandn %xmm10, %xmm1
movdqa %xmm1, %xmm10
por %xmm15, %xmm10
movdqa 0x50(%rsp), %xmm13
psubd %xmm13, %xmm12
movdqa %xmm8, %xmm1
pcmpgtd %xmm12, %xmm1
movmskps %xmm1, %r10d
cmpl $0xf, %r10d
movdqa 0x26e7a9(%rip), %xmm11  # 0x629af0
je 0x3bb38e
movaps %xmm14, %xmm15
psubd %xmm13, %xmm15
movdqa %xmm8, %xmm14
pcmpgtd %xmm15, %xmm14
movdqa %xmm8, %xmm1
pand %xmm14, %xmm1
pandn %xmm15, %xmm14
por %xmm1, %xmm14
movdqa (%r14,%r11), %xmm7
addq $0x10, %r11
cmpq %r11, %rsi
jne 0x3bb1dd
incl %eax
cmpl $0x4, %eax
jne 0x3bb192
movdqa %xmm10, %xmm1
movdqa 0xd0(%rsp), %xmm7
pcmpgtd %xmm7, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
je 0x3bb40c
movdqa %xmm10, %xmm1
psrldq $0x8, %xmm1             # xmm1 = xmm1[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm10, %xmm8
pcmpgtd %xmm1, %xmm8
movdqa %xmm10, %xmm7
pand %xmm8, %xmm7
pandn %xmm1, %xmm8
por %xmm7, %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, %xmm7
pcmpgtd %xmm1, %xmm7
pand %xmm7, %xmm8
pandn %xmm1, %xmm7
por %xmm8, %xmm7
movd %xmm7, %eax
movl %eax, 0xc(%rsp)
cmpl 0x4c(%rsp), %eax
jg 0x3bb422
pshufd $0x0, %xmm7, %xmm7      # xmm7 = xmm7[0,0,0,0]
movq 0x18(%rsp), %rax
movl %eax, 0x14(%rsp)
addq %rsi, 0x60(%rsp)
addq %rsi, %rdi
movq %r12, %rax
cmpq %rcx, %r9
jne 0x3baf01
jmp 0x3bb430
orb $0x40, 0xc(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpl $0x7fffffff, 0xc(%rsp)  # imm = 0x7FFFFFFF
jne 0x3bb43e
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
callq 0x20be2e
xorl %ecx, %ecx
testl %eax, %eax
je 0x3bb4a0
xorl %r8d, %r8d
movq 0x20(%rsp), %rdi
xorl %r9d, %r9d
movl %r8d, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r9d, 0x8(%rbx)
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq 0x38(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %rbx, %rax
jmp 0x3bb631
movq 0x40(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0x14(%rsp), %r9d
cmpl %ecx, %r9d
movq 0x20(%rsp), %rcx
movq %rcx, %rdi
cmoveq %r14, %rdi
movq %r14, %rdx
cmoveq %rcx, %rdx
cmpl %eax, %r9d
cmoveq %r15, %rdi
cmoveq %r14, %rdx
movq %rdx, %r14
cmoveq %rcx, %r15
movq 0x90(%rsp), %rax
movl %eax, %ecx
decl %ecx
movq 0x98(%rsp), %rsi
testl $0x7ffffffc, %esi       # imm = 0x7FFFFFFC
movdqa 0x26e5f5(%rip), %xmm10  # 0x629af0
je 0x3bb643
andl $0x7ffffffc, %esi       # imm = 0x7FFFFFFC
movl 0xc(%rsp), %r8d
je 0x3bb64d
movd %ecx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movd %r8d, %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movd 0x30(%rsp), %xmm2
pshufd $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
movdqa 0x26e598(%rip), %xmm3   # 0x629ad0
xorl %eax, %eax
movdqa 0x26e59e(%rip), %xmm4   # 0x629ae0
pshufd $0xf5, %xmm2, %xmm5     # xmm5 = xmm2[1,1,3,3]
movdqu (%rdi,%rax,4), %xmm6
pcmpeqd %xmm1, %xmm6
movdqa %xmm3, %xmm7
psrld $0x2, %xmm7
movdqa %xmm3, %xmm8
pand %xmm4, %xmm8
pshufd $0xf5, %xmm8, %xmm9     # xmm9 = xmm8[1,1,3,3]
pmuludq %xmm2, %xmm8
pshufd $0xe8, %xmm8, %xmm8     # xmm8 = xmm8[0,2,2,3]
pmuludq %xmm5, %xmm9
pshufd $0xe8, %xmm9, %xmm9     # xmm9 = xmm9[0,2,2,3]
punpckldq %xmm9, %xmm8    # xmm8 = xmm8[0],xmm9[0],xmm8[1],xmm9[1]
paddd %xmm7, %xmm8
movdqa %xmm0, %xmm7
pcmpgtd %xmm8, %xmm7
pand %xmm7, %xmm8
pandn %xmm0, %xmm7
por %xmm8, %xmm7
pand %xmm6, %xmm7
pandn %xmm0, %xmm6
movdqa %xmm6, %xmm0
por %xmm7, %xmm0
addq $0x4, %rax
paddd %xmm10, %xmm3
cmpq %rax, %rsi
jne 0x3bb547
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, %ecx
jmp 0x3bb457
callq 0x1bf3b3
jmp 0x3bb62f
callq 0x1bf38d
jmp 0x3bb62f
callq 0x1bf367
jmp 0x3bb62f
callq 0x1bf341
jmp 0x3bb62f
callq 0x1bf31b
jmp 0x3bb62f
callq 0x1bf2f5
jmp 0x3bb62f
callq 0x1bf2cf
jmp 0x3bb62f
callq 0x1bf2a9
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %r8d
jmp 0x3bb457
xorl %eax, %eax
movl %ecx, %edx
movl %eax, %ecx
shrl $0x2, %ecx
cmpl %edx, %ecx
cmovgel %edx, %ecx
cmpl %r8d, (%rdi,%rax,4)
cmovnel %edx, %ecx
incq %rax
cmpl %eax, %esi
jne 0x3bb64f
jmp 0x3bb457
nop