// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_scan_sse2_128_32.c
// Function: parasail_nw_trace_scan_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 pvP = NULL;
    __m128i* restrict pvE = NULL;
    int32_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    __m128i vZero;
    int32_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    parasail_result_t *result = NULL;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTDiag;
    __m128i vTDiagE;
    __m128i vTInsE;
    __m128i vTDiagF;
    __m128i vTDelF;

    /* 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;
    pvP = (__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;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    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);
    vNegInfFront = _mm_insert_epi32_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_add_epi32(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi32(-segLen*gap), 4));

    /* 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_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_4;

    /* initialize heap variables */
    pvE = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int32_t(16, s2Len+1);
    pvHt= parasail_memalign___m128i(16, segLen);
    pvH = parasail_memalign___m128i(16, segLen);
    pvGapper = parasail_memalign___m128i(16, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!boundary) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvGapper) 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(&pvH[index], h.m);
            _mm_store_si128(&pvE[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;
        }
    }

    {
        __m128i vGapper = _mm_sub_epi32(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_sub_epi32(vGapper, vGapE);
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        __m128i vE_ext;
        __m128i vE_opn;
        __m128i vHt;
        __m128i vF;
        __m128i vF_ext;
        __m128i vF_opn;
        __m128i vH;
        __m128i vHp;
        __m128i *pvW;
        __m128i vW;
        __m128i case1;
        __m128i case2;
        __m128i vGapper;
        __m128i vT;
        __m128i vET;
        __m128i vFT;

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm_load_si128(pvH+(segLen-1));
        vHp = _mm_slli_si128(vHp, 4);
        vHp = _mm_insert_epi32_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_sub_epi32(vNegLimit, pvGapper[0]);
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm_load_si128(pvH+i);
            vE = _mm_load_si128(pvE+i);
            vW = _mm_load_si128(pvW+i);
            vGapper = _mm_load_si128(pvGapper+i);
            vE_opn = _mm_sub_epi32(vH, vGapO);
            vE_ext = _mm_sub_epi32(vE, vGapE);
            case1 = _mm_cmpgt_epi32(vE_opn, vE_ext);
            vET = _mm_blendv_epi8_rpl(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm_max_epi32_rpl(vE_opn, vE_ext);
            vSaturationCheckMin = _mm_min_epi32_rpl(vSaturationCheckMin, vE);
            vGapper = _mm_add_epi32(vHt, vGapper);
            vF = _mm_max_epi32_rpl(vF, vGapper);
            vHp = _mm_add_epi32(vHp, vW);
            vHt = _mm_max_epi32_rpl(vE, vHp);
            _mm_store_si128(pvE+i, vE);
            _mm_store_si128(pvHt+i, vHt);
            _mm_store_si128(pvH+i, vHp);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm_slli_si128(vHt, 4);
        vHt = _mm_insert_epi32_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm_load_si128(pvGapper);
        vGapper = _mm_add_epi32(vHt, vGapper);
        vF = _mm_max_epi32_rpl(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 4);
            vFt = _mm_add_epi32(vFt, vSegLenXgap);
            vF = _mm_max_epi32_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 4);
        vF = _mm_add_epi32(vF, vNegInfFront);
        vH = _mm_max_epi32_rpl(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm_load_si128(pvH+i);
            vHt = _mm_load_si128(pvHt+i);
            vF_opn = _mm_sub_epi32(vH, vGapO);
            vF_ext = _mm_sub_epi32(vF, vGapE);
            vF = _mm_max_epi32_rpl(vF_opn, vF_ext);
            case1 = _mm_cmpgt_epi32(vF_opn, vF_ext);
            vFT = _mm_blendv_epi8_rpl(vTDelF, vTDiagF, case1);
            vH = _mm_max_epi32_rpl(vHt, vF);
            case1 = _mm_cmpeq_epi32(vH, vHp);
            case2 = _mm_cmpeq_epi32(vH, vF);
            vT = _mm_blendv_epi8_rpl(
                    _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm_or_si128(vT, vET);
            vT = _mm_or_si128(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi32_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi32_rpl(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm_max_epi32_rpl(vSaturationCheckMax, vH);
        }
    }

    /* extract last value from the last column */
    {
        __m128i vH = _mm_load_si128(pvH + 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(pvGapper);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(boundary);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x38(%rsp)
testq %rdi, %rdi
je 0x3a4528
movq 0x48(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x3a452f
movq 0x10(%rdi), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x3a4536
movl 0x8(%rdi), %r15d
testl %r15d, %r15d
jle 0x3a453d
cmpq $0x0, 0x38(%rsp)
je 0x3a4544
movl %edx, %ebx
testl %edx, %edx
jle 0x3a454b
testl %ecx, %ecx
js 0x3a4552
testl %r8d, %r8d
js 0x3a4559
movl %r8d, 0x1c(%rsp)
leal -0x1(%r15), %eax
addq $0x3, %r15
shrq $0x2, %r15
movl %eax, 0x18(%rsp)
xorl %edx, %edx
divl %r15d
movl %eax, %r12d
movl %edx, %ebp
movl %ecx, %r13d
negl %r13d
movq 0x30(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %esi       # imm = 0x80000000
movl %ecx, 0x20(%rsp)
orl %esi, %ecx
subl %eax, %esi
cmpl %r13d, %eax
cmovgl %ecx, %esi
movl %esi, 0x50(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x40(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r15d, %edi
movl %ebx, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3a455e
movq %rax, %r14
movl %ebp, 0x14(%rsp)
movl %r12d, 0xc(%rsp)
orl $0x4480401, 0xc(%rax)   # imm = 0x4480401
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, %r12
movq %rbx, 0x70(%rsp)
leal 0x1(%rbx), %esi
movl $0x10, %edi
movq %rsi, 0x68(%rsp)
callq 0x20a62d
movq %rax, (%rsp)
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, %rbx
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %r12, %xmm0
movq (%rsp), %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %rbp, %xmm1
movq %rbx, %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 %edx, %edx
testl %ecx, %ecx
jne 0x3a4560
testq %rax, %rax
je 0x3a4560
movq 0x70(%rsp), %r9
leal -0x1(%r9), %ecx
movl %ecx, 0x10(%rsp)
movl $0x3, %edx
subl 0xc(%rsp), %edx
movd 0x20(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
movl 0x1c(%rsp), %r10d
movd %r10d, %xmm1
pshufd $0x0, %xmm1, %xmm3      # xmm3 = xmm1[0,0,0,0]
movl 0x50(%rsp), %ecx
incl %ecx
movd %ecx, %xmm4
pshufd $0x0, %xmm4, %xmm1      # xmm1 = xmm4[0,0,0,0]
movdqa %xmm1, 0x20(%rsp)
movd 0x40(%rsp), %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0x80(%rsp)
movl %r15d, %esi
imull %r10d, %esi
negl %esi
movd %esi, %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
pslldq $0x4, %xmm1             # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
movdqa %xmm4, 0x50(%rsp)
paddd %xmm4, %xmm1
movdqa %xmm1, 0x40(%rsp)
movd %r13d, %xmm1
pshufd $0x0, %xmm1, %xmm5      # xmm5 = xmm1[0,0,0,0]
pshufd $0x44, %xmm0, %xmm7     # xmm7 = xmm0[0,1,0,1]
movd %r15d, %xmm0
pshufd $0x44, %xmm0, %xmm8     # xmm8 = xmm0[0,1,0,1]
movdqa 0x284f6b(%rip), %xmm9   # 0x628e80
pmuludq %xmm8, %xmm9
pmuludq 0x284f6d(%rip), %xmm8   # 0x628e90
xorl %esi, %esi
pshufd $0xf5, %xmm3, %xmm10    # xmm10 = xmm3[1,1,3,3]
movdqa 0x285a5c(%rip), %xmm11  # 0x629990
movdqa 0x285af3(%rip), %xmm12  # 0x629a30
pshufd $0xf5, %xmm12, %xmm13   # xmm13 = xmm12[1,1,3,3]
movdqa 0x285af4(%rip), %xmm14  # 0x629a40
movq %rbx, %rdi
movq %r12, %r8
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm9, %xmm1
paddq %xmm0, %xmm1
paddq %xmm8, %xmm0
movdqa %xmm0, %xmm4
punpcklqdq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0]
punpckhqdq %xmm1, %xmm0    # xmm0 = xmm0[1],xmm1[1]
pmuludq %xmm10, %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pmuludq %xmm3, %xmm4
pshufd $0xe8, %xmm4, %xmm1     # xmm1 = xmm4[0,2,2,3]
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movdqa %xmm5, %xmm4
psubd %xmm1, %xmm4
pxor %xmm15, %xmm15
pcmpgtd %xmm4, %xmm15
pshufd $0xee, %xmm4, %xmm0     # xmm0 = xmm4[2,3,2,3]
movdqa %xmm4, (%rdi)
punpckldq %xmm15, %xmm4   # xmm4 = xmm4[0],xmm15[0],xmm4[1],xmm15[1]
pxor %xmm1, %xmm1
pcmpgtd %xmm0, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
psubq %xmm7, %xmm0
psubq %xmm7, %xmm4
movdqa %xmm4, %xmm1
pxor %xmm11, %xmm1
pshufd $0xf5, %xmm1, %xmm15    # xmm15 = xmm1[1,1,3,3]
pcmpeqd %xmm13, %xmm15
pcmpgtd %xmm12, %xmm1
pshufd $0xa0, %xmm1, %xmm6     # xmm6 = xmm1[0,0,2,2]
pand %xmm15, %xmm6
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
por %xmm6, %xmm1
pand %xmm1, %xmm4
pandn %xmm14, %xmm1
por %xmm4, %xmm1
movdqa %xmm0, %xmm4
pxor %xmm11, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pcmpeqd %xmm13, %xmm6
pcmpgtd %xmm12, %xmm4
pshufd $0xa0, %xmm4, %xmm15    # xmm15 = xmm4[0,0,2,2]
pand %xmm6, %xmm15
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
por %xmm15, %xmm4
pand %xmm4, %xmm0
pandn %xmm14, %xmm4
por %xmm0, %xmm4
shufps $0x88, %xmm4, %xmm1     # xmm1 = xmm1[0,2],xmm4[0,2]
movaps %xmm1, (%r8)
incq %rsi
addq $0x10, %r8
addq $0x10, %rdi
cmpq %rsi, %r15
jne 0x3a3f52
movq (%rsp), %rcx
movl $0x0, (%rcx)
movl %r9d, %esi
movq 0x68(%rsp), %r11
andl $-0x2, %r11d
leaq -0x1(%rsi), %rdi
movq %rdi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movl %r10d, %edi
negl %edi
addl %r10d, %r10d
xorl %r8d, %r8d
movdqa 0x284e09(%rip), %xmm4   # 0x628e90
movdqa 0x284e11(%rip), %xmm6   # 0x628ea0
pcmpeqd %xmm7, %xmm7
movq %r8, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
por %xmm4, %xmm1
movdqa %xmm0, %xmm8
pxor %xmm6, %xmm8
pxor %xmm6, %xmm1
movdqa %xmm1, %xmm9
pcmpgtd %xmm8, %xmm9
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm8     # xmm8 = xmm1[1,1,3,3]
pand %xmm9, %xmm8
pshufd $0xf5, %xmm9, %xmm1     # xmm1 = xmm9[1,1,3,3]
por %xmm8, %xmm1
movd %xmm1, %r9d
notl %r9d
testb $0x1, %r9b
je 0x3a40eb
movq (%rsp), %rcx
movl %r13d, 0x4(%rcx,%r8,4)
pxor %xmm7, %xmm1
pextrw $0x4, %xmm1, %r9d
testb $0x1, %r9b
je 0x3a4108
leal (%rdi,%r13), %r9d
movq (%rsp), %rcx
movl %r9d, 0x8(%rcx,%r8,4)
addq $0x2, %r8
subl %r10d, %r13d
cmpq %r8, %r11
jne 0x3a4093
pxor %xmm0, %xmm0
psubd %xmm2, %xmm0
leal -0x1(%r15), %r8d
shlq $0x4, %r8
movq %rax, %rdi
addq %r8, %rdi
movl %r15d, %r9d
movdqa %xmm0, (%rdi)
psubd %xmm3, %xmm0
addq $-0x10, %rdi
decl %r9d
jg 0x3a4131
movq %rbx, %rdi
addq %r8, %rdi
movq %r15, %r8
shlq $0x4, %r8
xorl %r9d, %r9d
movl %r15d, %r10d
movdqa 0x2875f2(%rip), %xmm10  # 0x62b750
movdqa 0x2875f9(%rip), %xmm12  # 0x62b760
movdqa 0x287610(%rip), %xmm8   # 0x62b780
movdqa 0x287617(%rip), %xmm9   # 0x62b790
xorl %r11d, %r11d
movdqa 0x20(%rsp), %xmm7
movdqa 0x80(%rsp), %xmm6
movdqa %xmm9, %xmm5
movdqa %xmm8, %xmm13
pshufd $0x90, (%rdi), %xmm14   # xmm14 = mem[0,0,1,2]
movq (%rsp), %rcx
movss (%rcx,%r11,4), %xmm0
movss %xmm0, %xmm14           # xmm14 = xmm0[0],xmm14[1,2,3]
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %r15
movq 0x38(%rsp), %rcx
movzbl (%rcx,%r11), %r13d
movslq (%r15,%r13,4), %r15
imulq %r10, %r15
shlq $0x4, %r15
addq 0x78(%rsp), %r15
movdqa 0x20(%rsp), %xmm0
movdqa %xmm0, %xmm15
psubd (%rax), %xmm15
xorl %r13d, %r13d
movdqa %xmm10, %xmm11
movdqa (%rbx,%r13), %xmm9
movdqa (%r12,%r13), %xmm8
movdqa %xmm9, %xmm4
psubd %xmm2, %xmm4
psubd %xmm3, %xmm8
movdqa %xmm4, %xmm1
pcmpgtd %xmm8, %xmm1
movdqa %xmm1, %xmm10
pand %xmm11, %xmm10
pxor %xmm12, %xmm10
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
addq %r9, %rcx
paddd (%rax,%r13), %xmm15
paddd (%r15,%r13), %xmm14
movdqa %xmm10, (%r13,%rcx)
pand %xmm1, %xmm4
pandn %xmm8, %xmm1
por %xmm4, %xmm1
movdqa %xmm6, %xmm4
pcmpgtd %xmm1, %xmm4
movdqa %xmm0, %xmm8
pcmpgtd %xmm15, %xmm0
pand %xmm0, %xmm8
pandn %xmm15, %xmm0
movdqa %xmm1, %xmm15
movdqa %xmm1, %xmm10
movdqa %xmm1, (%r12,%r13)
pand %xmm4, %xmm1
pandn %xmm6, %xmm4
movdqa %xmm4, %xmm6
por %xmm1, %xmm6
por %xmm8, %xmm0
pcmpgtd %xmm14, %xmm15
pand %xmm15, %xmm10
pandn %xmm14, %xmm15
por %xmm10, %xmm15
movdqa %xmm15, (%rbp,%r13)
movdqa %xmm14, (%rbx,%r13)
addq $0x10, %r13
movdqa %xmm9, %xmm14
cmpq %r13, %r8
jne 0x3a41e6
movdqa %xmm11, %xmm10
pshufd $0x90, %xmm15, %xmm4    # xmm4 = xmm15[0,0,1,2]
movq (%rsp), %rcx
movss 0x4(%rcx,%r11,4), %xmm1
incq %r11
movss %xmm1, %xmm4            # xmm4 = xmm1[0],xmm4[1,2,3]
movdqa (%rax), %xmm1
paddd %xmm4, %xmm1
movdqa %xmm0, %xmm14
pcmpgtd %xmm1, %xmm14
pand %xmm14, %xmm0
pandn %xmm1, %xmm14
por %xmm0, %xmm14
movb $0x1, %r15b
movdqa 0x40(%rsp), %xmm8
movdqa %xmm14, %xmm0
movdqa %xmm14, %xmm1
pslldq $0x4, %xmm14            # xmm14 = zero,zero,zero,zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11]
paddd %xmm8, %xmm14
pcmpgtd %xmm14, %xmm0
pand %xmm0, %xmm1
pandn %xmm14, %xmm0
movdqa %xmm0, %xmm14
por %xmm1, %xmm14
testb $0x1, %r15b
movl $0x0, %r15d
jne 0x3a42fe
pslldq $0x4, %xmm14            # xmm14 = zero,zero,zero,zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11]
paddd 0x50(%rsp), %xmm14
movdqa %xmm14, %xmm15
pcmpgtd %xmm4, %xmm15
movdqa %xmm14, %xmm0
pand %xmm15, %xmm0
pandn %xmm4, %xmm15
por %xmm0, %xmm15
xorl %r15d, %r15d
movdqa 0x287402(%rip), %xmm12  # 0x62b770
movdqa %xmm13, %xmm8
movdqa %xmm5, %xmm9
movdqa 0x28576f(%rip), %xmm11  # 0x629af0
movq 0x10(%r14), %rcx
movq (%rcx), %r13
addq %r9, %r13
movdqa (%rbp,%r15), %xmm0
psubd %xmm2, %xmm15
psubd %xmm3, %xmm14
movdqa %xmm15, %xmm1
pcmpgtd %xmm14, %xmm1
movdqa %xmm1, %xmm4
pandn %xmm14, %xmm4
pand %xmm1, %xmm15
movdqa %xmm15, %xmm14
por %xmm4, %xmm14
pand %xmm12, %xmm1
pxor %xmm8, %xmm1
movdqa %xmm0, %xmm4
pcmpgtd %xmm14, %xmm4
movdqa %xmm4, %xmm8
pandn %xmm14, %xmm8
pand %xmm4, %xmm0
por %xmm8, %xmm0
movdqa (%rbx,%r15), %xmm8
pcmpeqd %xmm0, %xmm8
paddd %xmm9, %xmm4
movdqa %xmm8, %xmm9
pandn %xmm4, %xmm9
pand %xmm11, %xmm8
por %xmm9, %xmm8
movdqa %xmm5, %xmm9
por (%r15,%r13), %xmm1
por %xmm8, %xmm1
movdqa %xmm13, %xmm8
movdqa %xmm1, (%r15,%r13)
movdqa %xmm0, (%rbx,%r15)
movdqa %xmm6, %xmm1
pcmpgtd %xmm0, %xmm1
movdqa %xmm7, %xmm4
pcmpgtd %xmm0, %xmm7
pand %xmm7, %xmm4
pandn %xmm0, %xmm7
movdqa %xmm0, %xmm15
pand %xmm1, %xmm0
pandn %xmm6, %xmm1
por %xmm0, %xmm1
movdqa %xmm1, %xmm6
pcmpgtd %xmm14, %xmm6
movdqa %xmm14, %xmm0
pand %xmm6, %xmm0
pandn %xmm1, %xmm6
por %xmm0, %xmm6
por %xmm4, %xmm7
addq $0x10, %r15
cmpq %r15, %r8
jne 0x3a4381
addq %r8, %r9
cmpq %rsi, %r11
movdqa 0x2872d4(%rip), %xmm12  # 0x62b760
jne 0x3a418b
movl 0x14(%rsp), %ecx
shlq $0x4, %rcx
movdqa (%rbx,%rcx), %xmm0
cmpl $0x2, 0xc(%rsp)
jg 0x3a44b3
xorl %esi, %esi
pslldq $0x4, %xmm0             # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
incl %esi
cmpl %edx, %esi
jl 0x3a44a8
movdqa 0x20(%rsp), %xmm1
pcmpgtd %xmm6, %xmm1
pcmpgtd 0x80(%rsp), %xmm7
por %xmm1, %xmm7
movmskps %xmm7, %ecx
testl %ecx, %ecx
movl 0x10(%rsp), %esi
je 0x3a44e2
orb $0x40, 0xc(%r14)
xorl %edx, %edx
xorl %esi, %esi
xorl %ecx, %ecx
jmp 0x3a44ef
pshufd $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
movd %xmm0, %edx
movl 0x18(%rsp), %ecx
movl %edx, (%r14)
movl %ecx, 0x4(%r14)
movl %esi, 0x8(%r14)
movq %rax, %rdi
callq 0x20a60d
movq %rbx, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq (%rsp), %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r14, %rdx
jmp 0x3a4560
callq 0x1bc80f
jmp 0x3a455e
callq 0x1bc7e9
jmp 0x3a455e
callq 0x1bc7c3
jmp 0x3a455e
callq 0x1bc79d
jmp 0x3a455e
callq 0x1bc777
jmp 0x3a455e
callq 0x1bc751
jmp 0x3a455e
callq 0x1bc72b
jmp 0x3a455e
callq 0x1bc705
xorl %edx, %edx
movq %rdx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)