// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_trace_scan_sse2_128_32.c
// Function: parasail_sg_flags_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,
        int s1_beg, int s1_end, int s2_beg, int s2_end)
{
    /* 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 vMaxH;
    __m128i vPosMask;
    __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;
    vMaxH = vNegLimit;
    vPosMask = _mm_cmpeq_epi32(_mm_set1_epi32(position),
            _mm_set_epi32(0,1,2,3));
    vNegInfFront = vZero;
    vNegInfFront = _mm_insert_epi32_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_add_epi32(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi32(-segLen*gap), 4));
    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);

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 16, sizeof(__m128i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SG | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_4;
    result->flag |= s1_beg ? PARASAIL_FLAG_SG_S1_BEG : 0;
    result->flag |= s1_end ? PARASAIL_FLAG_SG_S1_END : 0;
    result->flag |= s2_beg ? PARASAIL_FLAG_SG_S2_BEG : 0;
    result->flag |= s2_end ? PARASAIL_FLAG_SG_S2_END : 0;

    /* 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 = s1_beg ? 0 : (-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 = s2_beg ? 0 : (-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);
            /* long queries and/or large penalties will break the pseudo prefix scan */
            vSaturationCheckMin = _mm_min_epi32_rpl(vSaturationCheckMin, vGapper);
        }
    }

    /* 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 vector containing last value from column */
        {
            __m128i vCompare;
            vH = _mm_load_si128(pvH + offset);
            vCompare = _mm_and_si128(vPosMask, _mm_cmpgt_epi32(vH, vMaxH));
            vMaxH = _mm_max_epi32_rpl(vH, vMaxH);
            if (_mm_movemask_epi8(vCompare)) {
                end_ref = j;
            }
        }
    } 

    /* max last value from all columns */
    if (s2_end)
    {
        for (k=0; k<position; ++k) {
            vMaxH = _mm_slli_si128(vMaxH, 4);
        }
        score = (int32_t) _mm_extract_epi32_rpl(vMaxH, 3);
        end_query = s1Len-1;
    }

    /* max of last column */
    if (s1_end)
    {
        /* Trace the alignment ending position on read. */
        int32_t *t = (int32_t*)pvH;
        int32_t column_len = segLen * segWidth;
        for (i = 0; i<column_len; ++i, ++t) {
            int32_t temp = i / segWidth + i % segWidth * segLen;
            if (temp >= s1Len) continue;
            if (*t > score) {
                score = *t;
                end_query = temp;
                end_ref = s2Len-1;
            }
            else if (*t == score && end_ref == s2Len-1 && temp < end_query) {
                end_query = temp;
            }
        }
    }

    if (!s1_end && !s2_end) {
        /* 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);
            end_ref = s2Len - 1;
            end_query = s1Len - 1;
        }
    }

    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 $0xf8, %rsp
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x3a50d8
movq 0x48(%rdi), %rax
movq %rax, 0xb8(%rsp)
testq %rax, %rax
je 0x3a50df
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x3a50e6
movl %ecx, %r15d
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jle 0x3a50ed
cmpq $0x0, 0x78(%rsp)
je 0x3a50f4
movl %edx, %r10d
testl %edx, %edx
jle 0x3a50fb
testl %r15d, %r15d
js 0x3a5102
testl %r8d, %r8d
js 0x3a5109
movl %r9d, 0x20(%rsp)
movl %r8d, 0x38(%rsp)
leal -0x1(%rcx), %eax
movq %rcx, 0xb0(%rsp)
leaq 0x3(%rcx), %r14
movq %r14, %r12
shrq $0x2, %r12
movl %eax, 0x3c(%rsp)
xorl %edx, %edx
divl %r12d
movl %eax, 0x14(%rsp)
movl %edx, %ebp
movl %r15d, %r13d
negl %r13d
movq 0x70(%rsp), %rsi
movl 0x20(%rsi), %eax
movl $0x80000000, %edx       # imm = 0x80000000
movl %r15d, %ecx
orl %edx, %ecx
subl %eax, %edx
cmpl %r13d, %eax
cmovgl %ecx, %edx
movl %edx, 0x18(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rsi), %eax
movl %eax, 0x50(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %r10d, %esi
movq %r10, 0x68(%rsp)
callq 0x20adf4
testq %rax, %rax
je 0x3a510e
movq %rax, %rbx
movl %r15d, 0x40(%rsp)
movl %ebp, 0x30(%rsp)
movq %r14, 0xa0(%rsp)
movl 0x140(%rsp), %edi
xorl %eax, %eax
cmpl $0x0, 0x20(%rsp)
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x130(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x138(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %edi, 0x34(%rsp)
testl %edi, %edi
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%rbx), %eax
orl $0x4480402, %eax        # imm = 0x4480402
movl %eax, 0xc(%rbx)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, %r15
movq 0x68(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
movq %rsi, 0xa8(%rsp)
callq 0x20a62d
movq %rax, 0x8(%rsp)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r12, 0x28(%rsp)
movq %r12, %rsi
callq 0x2f600c
movq %r15, %xmm0
movq 0x8(%rsp), %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %r14, %xmm1
movq %rbp, %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 0x3a5110
testq %rax, %rax
je 0x3a5110
movq 0x68(%rsp), %r8
leal -0x1(%r8), %ecx
movl %ecx, 0x4(%rsp)
movl $0x3, %edx
subl 0x14(%rsp), %edx
movd 0x40(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
movl 0x38(%rsp), %r9d
movd %r9d, %xmm1
pshufd $0x0, %xmm1, %xmm3      # xmm3 = xmm1[0,0,0,0]
movl 0x18(%rsp), %ecx
incl %ecx
movl %ecx, 0x18(%rsp)
movd %ecx, %xmm4
pshufd $0x0, %xmm4, %xmm1      # xmm1 = xmm4[0,0,0,0]
movdqa %xmm1, 0x90(%rsp)
movd 0x50(%rsp), %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0xc0(%rsp)
movl %edx, 0x1c(%rsp)
movd %edx, %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0x40(%rsp)
movq 0x28(%rsp), %r10
movl %r10d, %ecx
imull %r9d, %ecx
negl %ecx
movd %ecx, %xmm1
pshufd $0x0, %xmm1, %xmm6      # xmm6 = xmm1[0,0,0,0]
pslldq $0x4, %xmm6             # xmm6 = zero,zero,zero,zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11]
movdqa %xmm4, 0xe0(%rsp)
paddd %xmm4, %xmm6
movd %r13d, %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0x50(%rsp)
pshufd $0x44, %xmm0, %xmm7     # xmm7 = xmm0[0,1,0,1]
movd %r10d, %xmm0
pshufd $0x44, %xmm0, %xmm8     # xmm8 = xmm0[0,1,0,1]
movdqa 0x284555(%rip), %xmm9   # 0x628e80
pmuludq %xmm8, %xmm9
pmuludq 0x284557(%rip), %xmm8   # 0x628e90
xorl %ecx, %ecx
pshufd $0xf5, %xmm3, %xmm0     # xmm0 = xmm3[1,1,3,3]
movdqa %xmm0, 0x80(%rsp)
movdqa 0x28503e(%rip), %xmm11  # 0x629990
movdqa 0x2850d5(%rip), %xmm12  # 0x629a30
pshufd $0xf5, %xmm12, %xmm13   # xmm13 = xmm12[1,1,3,3]
movdqa 0x2850d6(%rip), %xmm14  # 0x629a40
movq %rbp, %rdx
movq %r15, %rsi
movl 0x20(%rsp), %edi
movl 0x138(%rsp), %r11d
movq 0xa8(%rsp), %r12
pxor %xmm5, %xmm5
testl %edi, %edi
je 0x3a4992
pxor %xmm0, %xmm0
jmp 0x3a49df
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm9, %xmm4
paddq %xmm0, %xmm4
paddq %xmm8, %xmm0
movdqa %xmm0, %xmm15
punpcklqdq %xmm4, %xmm15   # xmm15 = xmm15[0],xmm4[0]
punpckhqdq %xmm4, %xmm0    # xmm0 = xmm0[1],xmm4[1]
pmuludq 0x80(%rsp), %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pmuludq %xmm3, %xmm15
pshufd $0xe8, %xmm15, %xmm4    # xmm4 = xmm15[0,2,2,3]
punpckldq %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1]
movdqa 0x50(%rsp), %xmm0
psubd %xmm4, %xmm0
pxor %xmm4, %xmm4
pcmpgtd %xmm0, %xmm4
movdqa %xmm0, %xmm15
punpckldq %xmm4, %xmm15   # xmm15 = xmm15[0],xmm4[0],xmm15[1],xmm4[1]
pshufd $0xee, %xmm0, %xmm4     # xmm4 = xmm0[2,3,2,3]
pcmpgtd %xmm4, %xmm5
punpckldq %xmm5, %xmm4    # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
psubq %xmm7, %xmm4
psubq %xmm7, %xmm15
movdqa %xmm15, %xmm5
pxor %xmm11, %xmm5
pshufd $0xf5, %xmm5, %xmm1     # xmm1 = xmm5[1,1,3,3]
pcmpeqd %xmm13, %xmm1
pcmpgtd %xmm12, %xmm5
pshufd $0xa0, %xmm5, %xmm10    # xmm10 = xmm5[0,0,2,2]
pand %xmm1, %xmm10
pshufd $0xf5, %xmm5, %xmm1     # xmm1 = xmm5[1,1,3,3]
por %xmm10, %xmm1
pand %xmm1, %xmm15
pandn %xmm14, %xmm1
por %xmm15, %xmm1
movdqa %xmm4, %xmm5
pxor %xmm11, %xmm5
pshufd $0xf5, %xmm5, %xmm10    # xmm10 = xmm5[1,1,3,3]
pcmpeqd %xmm13, %xmm10
pcmpgtd %xmm12, %xmm5
pshufd $0xa0, %xmm5, %xmm15    # xmm15 = xmm5[0,0,2,2]
pand %xmm10, %xmm15
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
por %xmm15, %xmm5
pand %xmm5, %xmm4
pandn %xmm14, %xmm5
por %xmm4, %xmm5
shufps $0x88, %xmm5, %xmm1     # xmm1 = xmm1[0,2],xmm5[0,2]
movdqa %xmm0, (%rdx)
movaps %xmm1, (%rsi)
incq %rcx
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %r10
jne 0x3a4984
movq 0x8(%rsp), %rcx
movl $0x0, (%rcx)
movl %r8d, %ecx
andl $-0x2, %r12d
movq %rcx, 0x80(%rsp)
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movl %r9d, %ecx
negl %ecx
addl %r9d, %r9d
xorl %edx, %edx
movdqa 0x2843b9(%rip), %xmm1   # 0x628e90
movdqa 0x2843c1(%rip), %xmm4   # 0x628ea0
pcmpeqd %xmm5, %xmm5
xorl %esi, %esi
movq %rsi, %xmm7
pshufd $0x44, %xmm7, %xmm7     # xmm7 = xmm7[0,1,0,1]
por %xmm1, %xmm7
movdqa %xmm0, %xmm8
pxor %xmm4, %xmm8
pxor %xmm4, %xmm7
movdqa %xmm7, %xmm9
pcmpgtd %xmm8, %xmm9
pcmpeqd %xmm8, %xmm7
pshufd $0xf5, %xmm7, %xmm8     # xmm8 = xmm7[1,1,3,3]
pand %xmm9, %xmm8
pshufd $0xf5, %xmm9, %xmm7     # xmm7 = xmm9[1,1,3,3]
por %xmm8, %xmm7
movd %xmm7, %edi
notl %edi
testb $0x1, %dil
je 0x3a4b48
testl %r11d, %r11d
movl $0x0, %edi
cmovel %r13d, %edi
movq 0x8(%rsp), %r8
movl %edi, 0x4(%r8,%rsi,4)
pxor %xmm5, %xmm7
pextrw $0x4, %xmm7, %edi
testb $0x1, %dil
je 0x3a4b6b
leal (%rcx,%r13), %edi
testl %r11d, %r11d
cmovnel %edx, %edi
movq 0x8(%rsp), %r8
movl %edi, 0x8(%r8,%rsi,4)
addq $0x2, %rsi
subl %r9d, %r13d
cmpq %rsi, %r12
jne 0x3a4ae5
pxor %xmm0, %xmm0
psubd %xmm2, %xmm0
leal -0x1(%r10), %r9d
shlq $0x4, %r9
movq %rax, %rcx
addq %r9, %rcx
movl %r10d, %edx
movdqa 0xc0(%rsp), %xmm7
movdqa %xmm0, (%rcx)
psubd %xmm3, %xmm0
movdqa %xmm7, %xmm1
pcmpgtd %xmm0, %xmm1
movdqa %xmm0, %xmm4
pand %xmm1, %xmm4
pandn %xmm7, %xmm1
movdqa %xmm1, %xmm7
por %xmm4, %xmm7
addq $-0x10, %rcx
decl %edx
jg 0x3a4b9d
addq %rbp, %r9
movl 0x30(%rsp), %r10d
movq %r10, 0x20(%rsp)
shlq $0x4, %r10
addq %rbp, %r10
movq 0x28(%rsp), %rcx
movq %rcx, %r11
shlq $0x4, %r11
xorl %r12d, %r12d
movl %ecx, %r13d
movdqa 0x286b58(%rip), %xmm11  # 0x62b750
movdqa 0x286b5f(%rip), %xmm12  # 0x62b760
movdqa 0x286b86(%rip), %xmm10  # 0x62b790
movdqa 0x40(%rsp), %xmm0
pcmpeqd 0x284e58(%rip), %xmm0   # 0x629a70
movdqa %xmm0, 0x40(%rsp)
xorl %esi, %esi
movl 0x4(%rsp), %edi
movdqa 0x90(%rsp), %xmm0
movdqa %xmm0, %xmm8
movdqa %xmm0, %xmm1
movdqa %xmm6, 0xd0(%rsp)
movdqa %xmm10, %xmm15
movdqa %xmm1, 0x50(%rsp)
pshufd $0x90, (%r9), %xmm1     # xmm1 = mem[0,0,1,2]
movq 0x8(%rsp), %rcx
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, %xmm1            # xmm1 = xmm0[0],xmm1[1,2,3]
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x78(%rsp), %rdx
movzbl (%rdx,%rsi), %edx
movslq (%rcx,%rdx,4), %rcx
imulq %r13, %rcx
shlq $0x4, %rcx
addq 0xb8(%rsp), %rcx
movdqa 0x90(%rsp), %xmm4
movdqa %xmm4, %xmm0
psubd (%rax), %xmm0
xorl %edx, %edx
movdqa %xmm11, %xmm13
movdqa %xmm12, %xmm14
movdqa (%rbp,%rdx), %xmm11
movdqa (%r15,%rdx), %xmm10
movdqa %xmm11, %xmm5
psubd %xmm2, %xmm5
psubd %xmm3, %xmm10
movdqa %xmm5, %xmm9
pcmpgtd %xmm10, %xmm9
movdqa %xmm9, %xmm12
pand %xmm13, %xmm12
pxor %xmm14, %xmm12
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %r12, %r8
paddd (%rax,%rdx), %xmm0
paddd (%rcx,%rdx), %xmm1
movdqa %xmm12, (%rdx,%r8)
pand %xmm9, %xmm5
pandn %xmm10, %xmm9
por %xmm5, %xmm9
movdqa %xmm7, %xmm5
pcmpgtd %xmm9, %xmm5
movdqa %xmm4, %xmm10
pcmpgtd %xmm0, %xmm4
pand %xmm4, %xmm10
pandn %xmm0, %xmm4
movdqa %xmm9, %xmm0
movdqa %xmm9, %xmm12
movdqa %xmm9, (%r15,%rdx)
pand %xmm5, %xmm9
pandn %xmm7, %xmm5
movdqa %xmm5, %xmm7
por %xmm9, %xmm7
por %xmm10, %xmm4
pcmpgtd %xmm1, %xmm0
pand %xmm0, %xmm12
pandn %xmm1, %xmm0
por %xmm12, %xmm0
movdqa %xmm0, (%r14,%rdx)
movdqa %xmm1, (%rbp,%rdx)
addq $0x10, %rdx
movdqa %xmm11, %xmm1
cmpq %rdx, %r11
jne 0x3a4ca1
leaq 0x1(%rsi), %rcx
pshufd $0x90, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,2]
movq 0x8(%rsp), %rdx
movss 0x4(%rdx,%rsi,4), %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
movdqa (%rax), %xmm5
paddd %xmm0, %xmm5
movdqa %xmm4, %xmm1
pcmpgtd %xmm5, %xmm1
pand %xmm1, %xmm4
pandn %xmm5, %xmm1
por %xmm4, %xmm1
movb $0x1, %dl
movdqa %xmm1, %xmm4
movdqa %xmm1, %xmm5
pslldq $0x4, %xmm1             # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
paddd %xmm6, %xmm1
pcmpgtd %xmm1, %xmm4
pand %xmm4, %xmm5
pandn %xmm1, %xmm4
movdqa %xmm4, %xmm1
por %xmm5, %xmm1
testb $0x1, %dl
movl $0x0, %edx
jne 0x3a4da6
pslldq $0x4, %xmm1             # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
paddd 0xe0(%rsp), %xmm1
movdqa %xmm1, %xmm4
pcmpgtd %xmm0, %xmm4
movdqa %xmm1, %xmm5
pand %xmm4, %xmm5
pandn %xmm0, %xmm4
por %xmm5, %xmm4
xorl %edx, %edx
movdqa %xmm13, %xmm11
movdqa %xmm14, %xmm12
movdqa 0x286960(%rip), %xmm13  # 0x62b770
movdqa 0x286967(%rip), %xmm14  # 0x62b780
movdqa %xmm15, %xmm10
movdqa 0x284cca(%rip), %xmm6   # 0x629af0
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %r12, %r8
movdqa (%r14,%rdx), %xmm0
psubd %xmm2, %xmm4
psubd %xmm3, %xmm1
movdqa %xmm4, %xmm5
pcmpgtd %xmm1, %xmm5
movdqa %xmm5, %xmm9
pandn %xmm1, %xmm9
pand %xmm5, %xmm4
movdqa %xmm4, %xmm1
por %xmm9, %xmm1
pand %xmm13, %xmm5
pxor %xmm14, %xmm5
movdqa %xmm0, %xmm4
pcmpgtd %xmm1, %xmm4
movdqa %xmm4, %xmm9
pandn %xmm1, %xmm9
pand %xmm4, %xmm0
por %xmm9, %xmm0
movdqa (%rbp,%rdx), %xmm9
pcmpeqd %xmm0, %xmm9
paddd %xmm10, %xmm4
movdqa %xmm9, %xmm10
pandn %xmm4, %xmm10
pand %xmm6, %xmm9
por %xmm10, %xmm9
movdqa %xmm15, %xmm10
por (%rdx,%r8), %xmm5
por %xmm9, %xmm5
movdqa %xmm5, (%rdx,%r8)
movdqa %xmm0, (%rbp,%rdx)
movdqa %xmm7, %xmm5
pcmpgtd %xmm0, %xmm5
movdqa %xmm8, %xmm9
pcmpgtd %xmm0, %xmm8
pand %xmm8, %xmm9
pandn %xmm0, %xmm8
movdqa %xmm0, %xmm4
pand %xmm5, %xmm0
pandn %xmm7, %xmm5
por %xmm0, %xmm5
movdqa %xmm5, %xmm7
pcmpgtd %xmm1, %xmm7
movdqa %xmm1, %xmm0
pand %xmm7, %xmm0
pandn %xmm5, %xmm7
por %xmm0, %xmm7
por %xmm9, %xmm8
addq $0x10, %rdx
cmpq %rdx, %r11
jne 0x3a4e26
movdqa (%r10), %xmm0
movdqa %xmm0, %xmm1
movdqa 0x50(%rsp), %xmm5
pcmpgtd %xmm5, %xmm1
movdqa %xmm1, %xmm4
pand 0x40(%rsp), %xmm4
pand %xmm1, %xmm0
pandn %xmm5, %xmm1
movmskps %xmm4, %edx
testl %edx, %edx
cmovnel %esi, %edi
por %xmm0, %xmm1
addq %r11, %r12
movq %rcx, %rsi
cmpq 0x80(%rsp), %rcx
movdqa 0xd0(%rsp), %xmm6
jne 0x3a4c3f
cmpl $0x0, 0x140(%rsp)
movl 0x3c(%rsp), %r11d
movq 0xb0(%rsp), %r12
movl 0x18(%rsp), %r13d
movq 0x28(%rsp), %r10
je 0x3a4faa
cmpl $0x2, 0x14(%rsp)
jg 0x3a4fa0
xorl %ecx, %ecx
movl 0x1c(%rsp), %edx
pslldq $0x4, %xmm1             # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
incl %ecx
cmpl %edx, %ecx
jl 0x3a4f95
pshufd $0xff, %xmm1, %xmm0     # xmm0 = xmm1[3,3,3,3]
movd %xmm0, %r13d
cmpl $0x0, 0x130(%rsp)
je 0x3a5029
testl $0x7ffffffc, 0xa0(%rsp) # imm = 0x7FFFFFFC
je 0x3a5029
movl %r10d, %edx
andl $0x1fffffff, %edx       # imm = 0x1FFFFFFF
shll $0x2, %edx
xorl %esi, %esi
movl %r11d, %ecx
movl %esi, %r9d
shrl $0x2, %r9d
movl %esi, %r8d
andl $0x3, %r8d
imull %r10d, %r8d
addl %r9d, %r8d
cmpl %r12d, %r8d
jge 0x3a5020
movl (%rbp,%rsi,4), %r9d
cmpl %r13d, %r9d
jle 0x3a5002
movl %r9d, %r13d
movl 0x4(%rsp), %edi
movl %r8d, %ecx
jmp 0x3a5020
xorl %r13d, %r9d
movl %edi, %r10d
xorl 0x4(%rsp), %r10d
cmpl %ecx, %r8d
cmovgel %ecx, %r8d
orl %r9d, %r10d
movq 0x28(%rsp), %r10
cmovel %r8d, %ecx
incq %rsi
cmpl %esi, %edx
jne 0x3a4fd2
jmp 0x3a502c
movl %r11d, %ecx
movl 0x130(%rsp), %edx
orl %edx, 0x34(%rsp)
jne 0x3a5071
movq 0x20(%rsp), %rcx
shlq $0x4, %rcx
movdqa (%rbp,%rcx), %xmm0
cmpl $0x2, 0x14(%rsp)
jg 0x3a5060
xorl %ecx, %ecx
movl 0x1c(%rsp), %edx
pslldq $0x4, %xmm0             # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
incl %ecx
cmpl %edx, %ecx
jl 0x3a5055
pshufd $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
movd %xmm0, %r13d
movl 0x4(%rsp), %edi
movl %r11d, %ecx
movdqa 0x90(%rsp), %xmm0
pcmpgtd %xmm7, %xmm0
pcmpgtd 0xc0(%rsp), %xmm8
por %xmm0, %xmm8
movmskps %xmm8, %edx
testl %edx, %edx
je 0x3a50a0
orb $0x40, 0xc(%rbx)
xorl %r13d, %r13d
xorl %edi, %edi
xorl %ecx, %ecx
movl %r13d, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edi, 0x8(%rbx)
movq %rax, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x8(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %rbx, %rdx
jmp 0x3a5110
callq 0x1bca49
jmp 0x3a510e
callq 0x1bca23
jmp 0x3a510e
callq 0x1bc9fd
jmp 0x3a510e
callq 0x1bc9d7
jmp 0x3a510e
callq 0x1bc9b1
jmp 0x3a510e
callq 0x1bc98b
jmp 0x3a510e
callq 0x1bc965
jmp 0x3a510e
callq 0x1bc93f
xorl %edx, %edx
movq %rdx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq