// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_striped_sse2_128_32.c
// Function: parasail_nw_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 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;
    int32_t* restrict boundary = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    int32_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->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;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m128i*)profile->profile32.score;
    vGapO = _mm_set1_epi32(open);
    vGapE = _mm_set1_epi32(gap);
    NEG_LIMIT = (-open < matrix->min ? INT32_MIN + open : INT32_MIN - matrix->min) + 1;
    POS_LIMIT = INT32_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    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_NW | 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);
    boundary = parasail_memalign_int32_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_32_t h;
            __m128i_32_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT32_MIN ? INT32_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT32_MIN ? INT32_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 < INT32_MIN ? INT32_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 4 bytes */
        vH = _mm_load_si128(&pvHStore[segLen - 1]);
        vH = _mm_slli_si128(vH, 4);

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

            {
                __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __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),
                        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_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) {
            int64_t tmp = boundary[j+1]-open;
            int32_t tmp2 = tmp < INT32_MIN ? INT32_MIN : tmp;
            __m128i vHp = _mm_load_si128(&pvHLoad[segLen - 1]);
            vHp = _mm_slli_si128(vHp, 4);
            vHp = _mm_insert_epi32_rpl(vHp, boundary[j], 0);
            vEF_opn = _mm_slli_si128(vEF_opn, 4);
            vEF_opn = _mm_insert_epi32_rpl(vEF_opn, tmp2, 0);
            vF_ext = _mm_slli_si128(vF_ext, 4);
            vF_ext = _mm_insert_epi32_rpl(vF_ext, NEG_LIMIT, 0);
            vF = _mm_slli_si128(vF, 4);
            vF = _mm_insert_epi32_rpl(vF, tmp2, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 4);
            vFa_ext = _mm_insert_epi32_rpl(vFa_ext, NEG_LIMIT, 0);
            vFa = _mm_slli_si128(vFa, 4);
            vFa = _mm_insert_epi32_rpl(vFa, tmp2, 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);
                vSaturationCheckMin = _mm_min_epi32_rpl(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm_max_epi32_rpl(vSaturationCheckMax, vH);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_add_epi32(vHp, _mm_load_si128(vP + i));
                    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);
                }
                /* 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:
        {
        }
    }

    /* 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, 4);
        }
        score = (int32_t) _mm_extract_epi32_rpl (vH, 3);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi32(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi32(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, 0x78(%rsp)
testq %rdi, %rdi
je 0x39bba6
movq 0x48(%rdi), %rax
movq %rax, 0xa8(%rsp)
testq %rax, %rax
je 0x39bbad
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x39bbb4
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x39bbbb
cmpq $0x0, 0x78(%rsp)
je 0x39bbc2
movl %r8d, %r12d
movl %edx, %r8d
testl %edx, %edx
jle 0x39bbc9
cmpl $0x0, 0x4(%rsp)
js 0x39bbd0
testl %r12d, %r12d
js 0x39bbd7
leal -0x1(%r13), %r14d
addq $0x3, %r13
shrq $0x2, %r13
movl %r14d, %eax
cltd
idivl %r13d
movl %eax, 0x34(%rsp)
movl %edx, %r15d
movl 0x4(%rsp), %ecx
movl %ecx, %ebp
negl %ebp
movq 0x70(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %esi       # imm = 0x80000000
orl %esi, %ecx
subl %eax, %esi
cmpl %ebp, %eax
cmovgl %ecx, %esi
movl %esi, 0x14(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x18(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r13d, %edi
movl %r8d, %esi
movq %r8, 0x8(%rsp)
callq 0x2097d1
testq %rax, %rax
je 0x39bbdc
movq %rax, %rbx
movl %r15d, 0x64(%rsp)
movl %r14d, 0x60(%rsp)
orl $0x4480801, 0xc(%rax)   # imm = 0x4480801
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x48(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x68(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x20(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r15
movq 0x8(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
movq %rsi, 0x40(%rsp)
callq 0x2094d5
movq 0x48(%rsp), %r11
movq %r14, %rdi
testq %r11, %r11
sete %dl
cmpq $0x0, 0x28(%rsp)
movq 0x68(%rsp), %r14
sete %cl
orb %dl, %cl
testq %r14, %r14
sete %sil
cmpq $0x0, 0x20(%rsp)
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rdi, %rdi
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 0x39bbdc
movq %rdi, 0x38(%rsp)
movq %rax, 0x50(%rsp)
movq 0x8(%rsp), %rax
decl %eax
movl %eax, 0x30(%rsp)
movl $0x3, %eax
subl 0x34(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x4(%rsp), %eax
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
movd %r12d, %xmm0
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0x14(%rsp), %ecx
incl %ecx
movl %ecx, 0x14(%rsp)
movd %ecx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x80(%rsp)
movd 0x18(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm5      # xmm5 = xmm0[0,0,0,0]
movl %eax, %eax
movl %r13d, %edx
movl %r12d, %ecx
movq %r13, 0x18(%rsp)
imull %r13d, %ecx
xorl %esi, %esi
movq $-0x80000000, %rdi      # imm = 0x80000000
movl %ebp, %r8d
movq %r11, %r13
movl %r8d, %r9d
xorl %r10d, %r10d
movslq %r9d, %r9
movl %r9d, 0xd0(%rsp,%r10,4)
movq %r9, %r11
subq %rax, %r11
cmpq $-0x7fffffff, %r11      # imm = 0x80000001
cmovlq %rdi, %r11
movl %r11d, 0xc0(%rsp,%r10,4)
incq %r10
subl %ecx, %r9d
cmpq $0x4, %r10
jne 0x39b4c1
movq %rsi, %r9
shlq $0x4, %r9
movaps 0xd0(%rsp), %xmm0
movq %r13, %r11
movaps %xmm0, (%r13,%r9)
movdqa 0xc0(%rsp), %xmm0
movdqa %xmm0, (%r14,%r9)
movq 0x20(%rsp), %r10
movdqa %xmm0, (%r10,%r9)
incq %rsi
subl %r12d, %r8d
cmpq %rdx, %rsi
jne 0x39b4b8
movq 0x50(%rsp), %rdi
movl $0x0, (%rdi)
movl $0x1, %eax
movq 0x40(%rsp), %rcx
movl %ebp, (%rdi,%rax,4)
incq %rax
subl %r12d, %ebp
cmpq %rax, %rcx
jne 0x39b543
movq 0x18(%rsp), %r13
cmpl $0x1, %r13d
adcl $0x0, %r13d
shlq $0x4, %r13
xorl %eax, %eax
movdqa 0x25c324(%rip), %xmm0   # 0x5f7890
movq 0x8(%rsp), %rsi
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa %xmm0, (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %r13
jne 0x39b571
movq 0x18(%rsp), %rax
decl %eax
movl %esi, %r9d
cmpl $0x2, %esi
movl $0x1, %ecx
cmovgel %esi, %ecx
movq %rcx, 0xa0(%rsp)
movq %rdx, %rsi
shlq $0x4, %rsi
xorl %ecx, %ecx
shlq $0x4, %rax
movq %rax, 0x40(%rsp)
movdqa 0x25bf93(%rip), %xmm6   # 0x5f7550
movdqa 0x25bf6a(%rip), %xmm10  # 0x5f7530
movdqa 0x25bf71(%rip), %xmm11  # 0x5f7540
movq %rsi, 0x98(%rsp)
movq %rsi, 0x8(%rsp)
xorl %r10d, %r10d
movdqa %xmm5, 0xb0(%rsp)
movdqa 0x80(%rsp), %xmm4
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rbp
movq 0x28(%rsp), %r12
movq %r11, %rax
movq 0x40(%rsp), %r8
addq %r8, %r11
movq %r11, 0x48(%rsp)
movq %rax, 0x28(%rsp)
pshufd $0x90, (%rax,%r8), %xmm15 # xmm15 = mem[0,0,1,2]
movss (%rdi,%r10,4), %xmm0
movq %rsi, %rdi
movss %xmm0, %xmm15           # xmm15 = xmm0[0],xmm15[1,2,3]
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x78(%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, 0x18(%rsp)
incq %r10
movl $0x1, %r8d
xorl %r11d, %r11d
movdqa 0x80(%rsp), %xmm14
paddd (%rsi,%r11), %xmm15
movdqa (%r14,%r11), %xmm0
movdqa %xmm15, %xmm1
pcmpgtd %xmm0, %xmm1
movdqa %xmm15, %xmm7
pand %xmm1, %xmm7
pandn %xmm0, %xmm1
por %xmm7, %xmm1
movdqa %xmm1, %xmm8
pcmpgtd %xmm14, %xmm8
pand %xmm8, %xmm1
movdqa %xmm8, %xmm7
pandn %xmm14, %xmm7
por %xmm1, %xmm7
movdqa %xmm7, (%r12,%r11)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rcx, %rax
pcmpeqd %xmm7, %xmm15
paddd %xmm6, %xmm8
movdqa %xmm15, %xmm1
pandn %xmm8, %xmm1
pand 0x25a4b1(%rip), %xmm15  # 0x5f5b90
por %xmm1, %xmm15
movdqa (%r11,%rax), %xmm1
por %xmm15, %xmm1
movdqa %xmm15, (%r15,%r11)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rcx, %rax
movdqa %xmm1, (%r11,%rax)
movdqa %xmm7, %xmm13
psubd %xmm2, %xmm13
movdqa %xmm0, %xmm1
psubd %xmm3, %xmm1
movdqa %xmm13, %xmm15
pcmpgtd %xmm1, %xmm15
movdqa %xmm13, %xmm9
pand %xmm15, %xmm9
pandn %xmm1, %xmm15
por %xmm9, %xmm15
movdqa %xmm15, (%r14,%r11)
movdqa (%rdi,%r11), %xmm9
psubd %xmm3, %xmm9
movdqa %xmm13, %xmm12
pcmpgtd %xmm9, %xmm12
movdqa %xmm13, %xmm15
pand %xmm12, %xmm15
movdqa %xmm12, %xmm1
pandn %xmm9, %xmm1
por %xmm15, %xmm1
movdqa %xmm1, (%rbp,%r11)
cmpq %r9, %r10
jae 0x39b799
pand 0x25bd92(%rip), %xmm12  # 0x5f7510
pxor 0x25bd99(%rip), %xmm12  # 0x5f7520
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq 0x8(%rsp), %rax
movdqa %xmm12, (%r11,%rax)
movdqa %xmm14, %xmm1
psubd %xmm3, %xmm1
movdqa %xmm13, %xmm15
pcmpgtd %xmm1, %xmm15
cmpq %rdx, %r8
jae 0x39b7d8
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rcx, %rax
movdqa %xmm15, %xmm9
pand %xmm10, %xmm9
pxor %xmm11, %xmm9
por 0x10(%r11,%rax), %xmm9
movdqa %xmm9, 0x10(%r11,%rax)
movdqa %xmm4, %xmm9
pcmpgtd %xmm7, %xmm4
pand %xmm4, %xmm9
pandn %xmm7, %xmm4
por %xmm9, %xmm4
movdqa %xmm5, %xmm9
pcmpgtd %xmm7, %xmm9
pand %xmm9, %xmm7
pandn %xmm5, %xmm9
por %xmm7, %xmm9
movdqa %xmm9, %xmm7
pcmpgtd %xmm0, %xmm7
pand %xmm7, %xmm0
pandn %xmm9, %xmm7
por %xmm0, %xmm7
movdqa %xmm7, %xmm5
pcmpgtd %xmm14, %xmm5
pand %xmm5, %xmm14
pandn %xmm7, %xmm5
por %xmm14, %xmm5
movdqa %xmm13, %xmm0
pand %xmm15, %xmm0
pandn %xmm1, %xmm15
movdqa %xmm15, %xmm14
por %xmm0, %xmm14
movq 0x28(%rsp), %rax
movdqa (%rax,%r11), %xmm15
addq $0x10, %r11
incq %r8
cmpq %r11, %r13
jne 0x39b66f
movq %rdi, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movdqa %xmm14, %xmm15
movq 0x50(%rsp), %rdi
movl (%rdi,%r10,4), %eax
subl 0x4(%rsp), %eax
movd %eax, %xmm9
movq 0x48(%rsp), %rax
pshufd $0x90, (%rax), %xmm7    # xmm7 = mem[0,0,1,2]
movq 0x18(%rsp), %rax
movss (%rdi,%rax,4), %xmm0
movss %xmm0, %xmm7            # xmm7 = xmm0[0],xmm7[1,2,3]
pshufd $0x90, %xmm13, %xmm13   # xmm13 = xmm13[0,0,1,2]
movss %xmm9, %xmm13           # xmm13 = xmm9[0],xmm13[1,2,3]
pshufd $0x90, %xmm15, %xmm0    # xmm0 = xmm15[0,0,1,2]
movss %xmm9, %xmm0            # xmm0 = xmm9[0],xmm0[1,2,3]
pshufd $0x90, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,2]
movss 0x14(%rsp), %xmm12
movss %xmm12, %xmm1           # xmm1 = xmm12[0],xmm1[1,2,3]
pshufd $0x90, %xmm14, %xmm14   # xmm14 = xmm14[0,0,1,2]
movss %xmm9, %xmm14           # xmm14 = xmm9[0],xmm14[1,2,3]
movb $0x1, %al
movl $0x1, %r11d
xorl %r8d, %r8d
movq 0x38(%rsp), %rdi
movdqa (%r12,%r8), %xmm9
movdqa %xmm9, %xmm12
pcmpgtd %xmm0, %xmm12
pand %xmm12, %xmm9
movdqa %xmm12, %xmm15
pandn %xmm0, %xmm15
por %xmm9, %xmm15
movdqa %xmm15, (%r12,%r8)
paddd (%rsi,%r8), %xmm7
pcmpeqd %xmm15, %xmm7
por %xmm12, %xmm7
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
movdqa (%r8,%r14), %xmm9
pand 0x25bf65(%rip), %xmm9   # 0x5f78a0
movdqa (%r15,%r8), %xmm12
pand %xmm7, %xmm12
pandn %xmm6, %xmm7
por %xmm12, %xmm7
movdqa %xmm7, (%r15,%r8)
por %xmm9, %xmm7
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
movdqa %xmm7, (%r8,%r14)
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq %rcx, %r14
pcmpgtd %xmm1, %xmm13
pand %xmm10, %xmm13
movdqa (%r8,%r14), %xmm7
pand 0x25bf24(%rip), %xmm7   # 0x5f78b0
por %xmm13, %xmm7
pxor %xmm11, %xmm7
movdqa %xmm7, (%r8,%r14)
movdqa %xmm15, %xmm13
psubd %xmm2, %xmm13
movdqa (%rdi,%r8), %xmm9
psubd %xmm3, %xmm9
movdqa %xmm13, %xmm8
pcmpgtd %xmm9, %xmm8
movdqa %xmm13, %xmm12
pand %xmm8, %xmm12
movdqa %xmm8, %xmm7
pandn %xmm9, %xmm7
por %xmm12, %xmm7
movdqa %xmm7, (%rbp,%r8)
cmpq %r9, %r10
jae 0x39ba04
pand 0x25bb27(%rip), %xmm8   # 0x5f7510
pxor 0x25bb2e(%rip), %xmm8   # 0x5f7520
movq 0x10(%rbx), %r14
movq (%r14), %r14
addq 0x8(%rsp), %r14
movdqa %xmm8, (%r8,%r14)
movdqa %xmm5, %xmm7
pcmpgtd %xmm15, %xmm7
movdqa %xmm15, %xmm8
pand %xmm7, %xmm8
pandn %xmm5, %xmm7
movdqa %xmm7, %xmm5
por %xmm8, %xmm5
movdqa %xmm4, %xmm7
pcmpgtd %xmm15, %xmm4
pand %xmm4, %xmm7
pandn %xmm15, %xmm4
por %xmm7, %xmm4
movdqa %xmm0, %xmm15
psubd %xmm3, %xmm15
movdqa %xmm13, %xmm7
pcmpgtd %xmm15, %xmm7
movmskps %xmm7, %r14d
cmpl $0xf, %r14d
je 0x39baa5
movaps %xmm14, %xmm1
psubd %xmm3, %xmm1
movdqa %xmm13, %xmm14
pcmpgtd %xmm1, %xmm14
movdqa %xmm13, %xmm0
pand %xmm14, %xmm0
pandn %xmm1, %xmm14
por %xmm0, %xmm14
movq 0x28(%rsp), %rax
movaps (%rax,%r8), %xmm7
cmpq %rdx, %r11
setb %al
addq $0x10, %r8
incq %r11
movdqa %xmm15, %xmm0
cmpq %r8, %r13
jne 0x39b8e8
jmp 0x39baaa
movdqa %xmm0, %xmm15
testb $0x1, %al
jne 0x39bac4
movq 0x20(%rsp), %rdi
leal 0x1(%rdi), %eax
cmpl $0x3, %edi
movq %rax, 0x20(%rsp)
jb 0x39b87c
movq 0x98(%rsp), %rax
addq %rax, 0x8(%rsp)
addq %rax, %rcx
movq %r12, %r11
movq %rbp, %rsi
cmpq 0xa0(%rsp), %r10
movq 0x68(%rsp), %r14
movq 0x50(%rsp), %rdi
jne 0x39b5f6
movl 0x64(%rsp), %eax
shlq $0x4, %rax
movdqa (%r12,%rax), %xmm0
cmpl $0x2, 0x34(%rsp)
jg 0x39bb25
movl 0x5c(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x30(%rsp), %edx
pslldq $0x4, %xmm0             # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
decl %eax
jne 0x39bb1a
jmp 0x39bb29
movl 0x30(%rsp), %edx
movdqa 0x80(%rsp), %xmm1
pcmpgtd %xmm5, %xmm1
pcmpgtd 0xb0(%rsp), %xmm4
por %xmm1, %xmm4
movmskps %xmm4, %eax
testl %eax, %eax
je 0x39bb56
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x39bb63
pshufd $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
movd %xmm0, %eax
movl 0x60(%rsp), %ecx
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x38(%rsp), %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x39bbde
callq 0x1bef4b
jmp 0x39bbdc
callq 0x1bef25
jmp 0x39bbdc
callq 0x1beeff
jmp 0x39bbdc
callq 0x1beed9
jmp 0x39bbdc
callq 0x1beeb3
jmp 0x39bbdc
callq 0x1bee8d
jmp 0x39bbdc
callq 0x1bee67
jmp 0x39bbdc
callq 0x1bee41
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop