// File: /workspace/github_c_makefile_star2_O3/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 $0xb8, %rsp
movl %ecx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
testq %rdi, %rdi
je 0x3b9ab0
movq 0x48(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x3b9ab7
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x3b9abe
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x3b9ac5
cmpq $0x0, 0x68(%rsp)
je 0x3b9acc
movl %edx, %r9d
testl %edx, %edx
jle 0x3b9ad3
cmpl $0x0, 0x8(%rsp)
js 0x3b9ada
testl %r8d, %r8d
js 0x3b9ae1
movl %r8d, 0x40(%rsp)
leal -0x1(%r13), %ebp
addq $0x3, %r13
shrq $0x2, %r13
movl %ebp, %eax
xorl %edx, %edx
divl %r13d
movl %eax, %r14d
movl %edx, %r12d
movl 0x8(%rsp), %ecx
movl %ecx, %r15d
negl %r15d
movq 0x60(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %esi       # imm = 0x80000000
orl %esi, %ecx
subl %eax, %esi
cmpl %r15d, %eax
cmovgl %ecx, %esi
movl %esi, 0xc(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x38(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r13d, %edi
movl %r9d, %esi
movq %r9, 0x10(%rsp)
callq 0x20adf4
testq %rax, %rax
je 0x3b9ae6
movq %rax, %rbx
movl %r12d, 0x5c(%rsp)
movl %r14d, 0x24(%rsp)
movl %ebp, 0x58(%rsp)
orl $0x4480801, 0xc(%rax)   # imm = 0x4480801
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, 0x88(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, 0x48(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r14
movq 0x10(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
movq %rsi, 0x30(%rsp)
callq 0x20a62d
movq 0x28(%rsp), %r11
movq 0x88(%rsp), %r10
movq 0x48(%rsp), %rdi
movq %r10, %xmm0
movq %r12, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %rdi, %xmm1
movq %r11, %xmm2
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
pxor %xmm2, %xmm2
movq %rbp, 0x18(%rsp)
testq %rbp, %rbp
movq %rax, %rbp
sete %al
testq %r14, %r14
sete %cl
testq %rbp, %rbp
sete %dl
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, %esi
testl %esi, %esi
setne %sil
orb %al, %cl
orb %dl, %cl
orb %sil, %cl
jne 0x3b9ae6
movq 0x10(%rsp), %r9
leal -0x1(%r9), %eax
movl %eax, 0x20(%rsp)
movl $0x3, %eax
subl 0x24(%rsp), %eax
movl %eax, 0x54(%rsp)
movd 0x8(%rsp), %xmm1
pshufd $0x0, %xmm1, %xmm2      # xmm2 = xmm1[0,0,0,0]
movl 0x40(%rsp), %r8d
movd %r8d, %xmm0
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x70(%rsp)
movd 0x38(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xa0(%rsp)
movd %r15d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movd %r13d, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
movdqa 0x26fbbb(%rip), %xmm5   # 0x628e80
pmuludq %xmm4, %xmm5
pmuludq 0x26fbbf(%rip), %xmm4   # 0x628e90
xorl %eax, %eax
pshufd $0xf5, %xmm3, %xmm6     # xmm6 = xmm3[1,1,3,3]
movdqa 0x2706b0(%rip), %xmm7   # 0x629990
movdqa 0x270747(%rip), %xmm8   # 0x629a30
pshufd $0xf5, %xmm8, %xmm9     # xmm9 = xmm8[1,1,3,3]
movdqa 0x270748(%rip), %xmm10  # 0x629a40
movq %r10, %rcx
movq %rdi, %rdx
movq %r11, %rsi
movq %rax, %xmm11
pshufd $0x44, %xmm11, %xmm11   # xmm11 = xmm11[0,1,0,1]
movdqa %xmm5, %xmm12
paddq %xmm11, %xmm12
paddq %xmm4, %xmm11
movdqa %xmm11, %xmm13
punpcklqdq %xmm12, %xmm13  # xmm13 = xmm13[0],xmm12[0]
punpckhqdq %xmm12, %xmm11  # xmm11 = xmm11[1],xmm12[1]
pmuludq %xmm6, %xmm11
pshufd $0xe8, %xmm11, %xmm11   # xmm11 = xmm11[0,2,2,3]
pmuludq %xmm3, %xmm13
pshufd $0xe8, %xmm13, %xmm13   # xmm13 = xmm13[0,2,2,3]
punpckldq %xmm11, %xmm13  # xmm13 = xmm13[0],xmm11[0],xmm13[1],xmm11[1]
movdqa %xmm0, %xmm12
psubd %xmm13, %xmm12
pxor %xmm13, %xmm13
pcmpgtd %xmm12, %xmm13
pshufd $0xee, %xmm12, %xmm11   # xmm11 = xmm12[2,3,2,3]
movdqa %xmm12, (%rcx)
punpckldq %xmm13, %xmm12  # xmm12 = xmm12[0],xmm13[0],xmm12[1],xmm13[1]
pxor %xmm13, %xmm13
pcmpgtd %xmm11, %xmm13
punpckldq %xmm13, %xmm11  # xmm11 = xmm11[0],xmm13[0],xmm11[1],xmm13[1]
psubq %xmm1, %xmm11
psubq %xmm1, %xmm12
movdqa %xmm12, %xmm13
pxor %xmm7, %xmm13
pshufd $0xf5, %xmm13, %xmm14   # xmm14 = xmm13[1,1,3,3]
pcmpeqd %xmm9, %xmm14
pcmpgtd %xmm8, %xmm13
pshufd $0xa0, %xmm13, %xmm15   # xmm15 = xmm13[0,0,2,2]
pand %xmm14, %xmm15
pshufd $0xf5, %xmm13, %xmm13   # xmm13 = xmm13[1,1,3,3]
por %xmm15, %xmm13
pand %xmm13, %xmm12
pandn %xmm10, %xmm13
por %xmm12, %xmm13
movdqa %xmm11, %xmm12
pxor %xmm7, %xmm12
pshufd $0xf5, %xmm12, %xmm14   # xmm14 = xmm12[1,1,3,3]
pcmpeqd %xmm9, %xmm14
pcmpgtd %xmm8, %xmm12
pshufd $0xa0, %xmm12, %xmm15   # xmm15 = xmm12[0,0,2,2]
pand %xmm14, %xmm15
pshufd $0xf5, %xmm12, %xmm12   # xmm12 = xmm12[1,1,3,3]
por %xmm15, %xmm12
pand %xmm12, %xmm11
pandn %xmm10, %xmm12
por %xmm11, %xmm12
shufps $0x88, %xmm12, %xmm13   # xmm13 = xmm13[0,2],xmm12[0,2]
movaps %xmm13, (%rdx)
movaps %xmm13, (%rsi)
incq %rax
addq $0x10, %rsi
addq $0x10, %rdx
addq $0x10, %rcx
cmpq %rax, %r13
jne 0x3b9301
movl $0x0, (%rbp)
movl %r9d, %esi
movq 0x30(%rsp), %r9
andl $-0x2, %r9d
leaq -0x1(%rsi), %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movl %r8d, %eax
negl %eax
addl %r8d, %r8d
xorl %ecx, %ecx
movdqa 0x26fa38(%rip), %xmm1   # 0x628e90
movdqa 0x26fa40(%rip), %xmm4   # 0x628ea0
pcmpeqd %xmm5, %xmm5
movq %rcx, %xmm6
pshufd $0x44, %xmm6, %xmm6     # xmm6 = xmm6[0,1,0,1]
por %xmm1, %xmm6
movdqa %xmm0, %xmm7
pxor %xmm4, %xmm7
pxor %xmm4, %xmm6
movdqa %xmm6, %xmm8
pcmpgtd %xmm7, %xmm8
pcmpeqd %xmm7, %xmm6
pshufd $0xf5, %xmm6, %xmm7     # xmm7 = xmm6[1,1,3,3]
pand %xmm8, %xmm7
pshufd $0xf5, %xmm8, %xmm6     # xmm6 = xmm8[1,1,3,3]
por %xmm7, %xmm6
movd %xmm6, %edx
notl %edx
testb $0x1, %dl
je 0x3b94b0
movl %r15d, 0x4(%rbp,%rcx,4)
pxor %xmm5, %xmm6
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x3b94c6
leal (%rax,%r15), %edx
movl %edx, 0x8(%rbp,%rcx,4)
addq $0x2, %rcx
subl %r8d, %r15d
cmpq %rcx, %r9
jne 0x3b9464
movq %r13, 0x10(%rsp)
movq %r13, %rdi
shlq $0x4, %rdi
xorl %eax, %eax
movaps 0x272609(%rip), %xmm0   # 0x62baf0
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movaps %xmm0, (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %rdi
jne 0x3b94e7
movq 0x10(%rsp), %rax
leal -0x1(%rax), %ecx
xorl %r9d, %r9d
shlq $0x4, %rcx
movq %rcx, 0x38(%rsp)
movl %eax, %eax
movq %rax, 0x30(%rsp)
movdqa 0x272272(%rip), %xmm6   # 0x62b790
movdqa 0x2705ca(%rip), %xmm7   # 0x629af0
movdqa 0x272241(%rip), %xmm10  # 0x62b770
movdqa 0x272248(%rip), %xmm11  # 0x62b780
movq %rdi, %r11
xorl %ecx, %ecx
movdqa 0xa0(%rsp), %xmm5
movdqa 0x70(%rsp), %xmm4
movq 0x28(%rsp), %rax
movq %rbp, 0x90(%rsp)
movq 0x18(%rsp), %r15
movq %rax, 0x18(%rsp)
movq %r12, %r13
movq %r10, %r12
movq %rcx, %r10
movq 0x38(%rsp), %rax
leaq (%r12,%rax), %rcx
movq %rcx, 0x40(%rsp)
pshufd $0x90, (%r12,%rax), %xmm13 # xmm13 = mem[0,0,1,2]
movss (%rbp,%r10,4), %xmm0
movss %xmm0, %xmm13           # xmm13 = xmm0[0],xmm13[1,2,3]
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x68(%rsp), %rax
movzbl (%rax,%r10), %edx
movslq (%rcx,%rdx,4), %r8
imulq 0x30(%rsp), %r8
shlq $0x4, %r8
addq 0x98(%rsp), %r8
movq %r10, 0x28(%rsp)
leaq 0x1(%r10), %rcx
movl $0x1, %r10d
xorl %edx, %edx
movdqa 0x70(%rsp), %xmm14
movq %r12, %rbp
paddd (%r8,%rdx), %xmm13
movq 0x48(%rsp), %r12
movdqa (%r12,%rdx), %xmm1
movdqa %xmm13, %xmm0
pcmpgtd %xmm1, %xmm0
movdqa %xmm13, %xmm12
pand %xmm0, %xmm12
pandn %xmm1, %xmm0
por %xmm12, %xmm0
movdqa %xmm0, %xmm12
pcmpgtd %xmm14, %xmm12
pand %xmm12, %xmm0
movdqa %xmm12, %xmm15
pandn %xmm14, %xmm15
por %xmm0, %xmm15
movdqa %xmm15, (%r13,%rdx)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
pcmpeqd %xmm15, %xmm13
paddd %xmm6, %xmm12
movdqa %xmm13, %xmm0
pandn %xmm12, %xmm0
pand %xmm7, %xmm13
por %xmm0, %xmm13
movdqa (%rdx,%rax), %xmm0
por %xmm13, %xmm0
movdqa %xmm13, (%r14,%rdx)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa %xmm0, (%rdx,%rax)
movdqa %xmm15, %xmm9
psubd %xmm2, %xmm9
movdqa %xmm1, %xmm0
psubd %xmm3, %xmm0
movdqa %xmm9, %xmm13
pcmpgtd %xmm0, %xmm13
movdqa %xmm9, %xmm12
pand %xmm13, %xmm12
pandn %xmm0, %xmm13
por %xmm12, %xmm13
movdqa %xmm13, (%r12,%rdx)
movq 0x18(%rsp), %rax
movdqa (%rax,%rdx), %xmm12
psubd %xmm3, %xmm12
movdqa %xmm9, %xmm8
pcmpgtd %xmm12, %xmm8
movdqa %xmm9, %xmm13
pand %xmm8, %xmm13
movdqa %xmm8, %xmm0
pandn %xmm12, %xmm0
por %xmm13, %xmm0
movdqa %xmm0, (%r15,%rdx)
cmpq %rsi, %rcx
jae 0x3b9700
pand 0x272069(%rip), %xmm8   # 0x62b750
pxor 0x272070(%rip), %xmm8   # 0x62b760
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r11, %rax
movdqa %xmm8, (%rdx,%rax)
movdqa %xmm14, %xmm0
psubd %xmm3, %xmm0
movdqa %xmm9, %xmm13
pcmpgtd %xmm0, %xmm13
cmpq 0x10(%rsp), %r10
movq %rbp, %r12
jae 0x3b9744
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa %xmm13, %xmm8
pand %xmm10, %xmm8
pxor %xmm11, %xmm8
por 0x10(%rdx,%rax), %xmm8
movdqa %xmm8, 0x10(%rdx,%rax)
movdqa %xmm4, %xmm8
pcmpgtd %xmm15, %xmm4
pand %xmm4, %xmm8
pandn %xmm15, %xmm4
por %xmm8, %xmm4
movdqa %xmm5, %xmm8
pcmpgtd %xmm15, %xmm8
pand %xmm8, %xmm15
pandn %xmm5, %xmm8
por %xmm15, %xmm8
movdqa %xmm8, %xmm12
pcmpgtd %xmm1, %xmm12
pand %xmm12, %xmm1
pandn %xmm8, %xmm12
por %xmm1, %xmm12
movdqa %xmm12, %xmm5
pcmpgtd %xmm14, %xmm5
pand %xmm5, %xmm14
pandn %xmm12, %xmm5
por %xmm14, %xmm5
movdqa %xmm9, %xmm1
pand %xmm13, %xmm1
pandn %xmm0, %xmm13
movdqa %xmm13, %xmm14
por %xmm1, %xmm14
movaps (%r12,%rdx), %xmm13
addq $0x10, %rdx
incq %r10
cmpq %rdx, %rdi
jne 0x3b95ce
xorl %r10d, %r10d
movdqa %xmm14, %xmm1
movq 0x90(%rsp), %rbp
movl (%rbp,%rcx,4), %eax
subl 0x8(%rsp), %eax
movd %eax, %xmm8
movq 0x40(%rsp), %rax
pshufd $0x90, (%rax), %xmm13   # xmm13 = mem[0,0,1,2]
movq 0x28(%rsp), %rax
movss (%rbp,%rax,4), %xmm12
movss %xmm12, %xmm13          # xmm13 = xmm12[0],xmm13[1,2,3]
pshufd $0x90, %xmm9, %xmm9     # xmm9 = xmm9[0,0,1,2]
movss %xmm8, %xmm9            # xmm9 = xmm8[0],xmm9[1,2,3]
pshufd $0x90, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,2]
movss %xmm8, %xmm1            # xmm1 = xmm8[0],xmm1[1,2,3]
pshufd $0x90, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,2]
movss 0xc(%rsp), %xmm12
movss %xmm12, %xmm0           # xmm0 = xmm12[0],xmm0[1,2,3]
pshufd $0x90, %xmm14, %xmm14   # xmm14 = xmm14[0,0,1,2]
movss %xmm8, %xmm14           # xmm14 = xmm8[0],xmm14[1,2,3]
xorl %edx, %edx
movdqa (%r13,%rdx), %xmm8
movdqa %xmm8, %xmm12
pcmpgtd %xmm1, %xmm12
pand %xmm12, %xmm8
movdqa %xmm12, %xmm15
pandn %xmm1, %xmm15
por %xmm8, %xmm15
movdqa %xmm15, (%r13,%rdx)
paddd (%r8,%rdx), %xmm13
pcmpgtd %xmm0, %xmm9
pcmpeqd %xmm15, %xmm13
por %xmm12, %xmm13
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa (%rdx,%rax), %xmm0
pand 0x272266(%rip), %xmm0   # 0x62bb00
movdqa (%r14,%rdx), %xmm8
pand %xmm13, %xmm8
pandn %xmm6, %xmm13
por %xmm8, %xmm13
movdqa %xmm13, (%r14,%rdx)
por %xmm0, %xmm13
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa %xmm13, (%rdx,%rax)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
pand %xmm10, %xmm9
movdqa (%rdx,%rax), %xmm0
pand 0x27222a(%rip), %xmm0   # 0x62bb10
por %xmm9, %xmm0
pxor %xmm11, %xmm0
movdqa %xmm0, (%rdx,%rax)
movdqa %xmm15, %xmm9
psubd %xmm2, %xmm9
movq 0x18(%rsp), %rax
movdqa (%rax,%rdx), %xmm8
psubd %xmm3, %xmm8
movdqa %xmm9, %xmm0
pcmpgtd %xmm8, %xmm0
movdqa %xmm9, %xmm12
pand %xmm0, %xmm12
movdqa %xmm0, %xmm13
pandn %xmm8, %xmm13
por %xmm12, %xmm13
movdqa %xmm13, (%r15,%rdx)
cmpq %rsi, %rcx
jae 0x3b995c
pand 0x271e0b(%rip), %xmm0   # 0x62b750
pxor 0x271e13(%rip), %xmm0   # 0x62b760
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r11, %rax
movdqa %xmm0, (%rdx,%rax)
movdqa %xmm5, %xmm0
pcmpgtd %xmm15, %xmm0
movdqa %xmm15, %xmm8
pand %xmm0, %xmm8
pandn %xmm5, %xmm0
movdqa %xmm0, %xmm5
por %xmm8, %xmm5
movdqa %xmm4, %xmm0
pcmpgtd %xmm15, %xmm4
pand %xmm4, %xmm0
pandn %xmm15, %xmm4
por %xmm0, %xmm4
psubd %xmm3, %xmm1
movdqa %xmm9, %xmm0
pcmpgtd %xmm1, %xmm0
movmskps %xmm0, %eax
cmpl $0xf, %eax
je 0x3b99ed
movaps %xmm14, %xmm0
psubd %xmm3, %xmm0
movdqa %xmm9, %xmm14
pcmpgtd %xmm0, %xmm14
movdqa %xmm9, %xmm8
pand %xmm14, %xmm8
pandn %xmm0, %xmm14
por %xmm8, %xmm14
movdqa (%r12,%rdx), %xmm13
addq $0x10, %rdx
cmpq %rdx, %rdi
jne 0x3b9842
incl %r10d
cmpl $0x4, %r10d
jne 0x3b97e6
addq %rdi, %r11
addq %rdi, %r9
movq %r13, %r10
movq %r15, %rax
cmpq %rsi, %rcx
jne 0x3b9559
movl 0x5c(%rsp), %eax
shlq $0x4, %rax
movdqa (%r13,%rax), %xmm0
cmpl $0x2, 0x24(%rsp)
jg 0x3b9a2f
xorl %eax, %eax
movl 0x20(%rsp), %edx
movl 0x54(%rsp), %ecx
pslldq $0x4, %xmm0             # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
incl %eax
cmpl %ecx, %eax
jl 0x3b9a22
jmp 0x3b9a33
movl 0x20(%rsp), %edx
movdqa 0x70(%rsp), %xmm1
pcmpgtd %xmm5, %xmm1
pcmpgtd 0xa0(%rsp), %xmm4
por %xmm1, %xmm4
movmskps %xmm4, %eax
testl %eax, %eax
je 0x3b9a5d
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x3b9a6a
pshufd $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
movd %xmm0, %eax
movl 0x58(%rsp), %ecx
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
movq %rbp, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x18(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x48(%rsp), %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
jmp 0x3b9ae8
callq 0x1bef3f
jmp 0x3b9ae6
callq 0x1bef19
jmp 0x3b9ae6
callq 0x1beef3
jmp 0x3b9ae6
callq 0x1beecd
jmp 0x3b9ae6
callq 0x1beea7
jmp 0x3b9ae6
callq 0x1bee81
jmp 0x3b9ae6
callq 0x1bee5b
jmp 0x3b9ae6
callq 0x1bee35
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)