// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_scan_sse2_128_32.c
// Function: parasail_sg_flags_rowcol_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    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;

    /* 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));

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(segLen*segWidth, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(segLen*segWidth, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SG | PARASAIL_FLAG_SCAN
        | 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;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* 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 vHt;
        __m128i vF;
        __m128i vH;
        __m128i vHp;
        __m128i *pvW;
        __m128i vW;

        /* 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);
            vE = _mm_max_epi32_rpl(
                    _mm_sub_epi32(vE, vGapE),
                    _mm_sub_epi32(vH, vGapO));
            vHp = _mm_add_epi32(vHp, vW);
            vF = _mm_max_epi32_rpl(vF, _mm_add_epi32(vHt, pvGapper[i]));
            vHt = _mm_max_epi32_rpl(vE, vHp);
            _mm_store_si128(pvE+i, vE);
            _mm_store_si128(pvHt+i, vHt);
            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);
        vF = _mm_max_epi32_rpl(vF, _mm_add_epi32(vHt, pvGapper[0]));
        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(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm_load_si128(pvHt+i);
            vF = _mm_max_epi32_rpl(
                    _mm_sub_epi32(vF, vGapE),
                    _mm_sub_epi32(vH, vGapO));
            vH = _mm_max_epi32_rpl(vHt, vF);
            _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);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
        } 

        /* 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;
            }
#ifdef PARASAIL_ROWCOL
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 4);
            }
            result->rowcols->score_row[j] = (int32_t) _mm_extract_epi32_rpl (vH, 3);
#endif
        }
    }

#ifdef PARASAIL_ROWCOL
    for (i=0; i<segLen; ++i) {
        __m128i vH = _mm_load_si128(pvH + i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    /* 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 $0xe8, %rsp
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x3509dc
movq 0x48(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x3509e3
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x3509ea
movl %r8d, 0x2c(%rsp)
movl 0x8(%rdi), %ebx
testl %ebx, %ebx
jle 0x3509f1
cmpq $0x0, 0x78(%rsp)
je 0x3509f8
movl %edx, %r10d
testl %edx, %edx
jle 0x3509ff
testl %ecx, %ecx
js 0x350a06
cmpl $0x0, 0x2c(%rsp)
js 0x350a0d
movl %r9d, 0x28(%rsp)
leal -0x1(%rbx), %eax
leaq 0x3(%rbx), %r14
movq %r14, %r13
shrq $0x2, %r13
movl %eax, 0x14(%rsp)
xorl %edx, %edx
divl %r13d
movl %eax, 0x10(%rsp)
movl %edx, %r15d
movl %ecx, %r12d
negl %r12d
movq 0x70(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %ebp       # imm = 0x80000000
movl %ecx, 0x40(%rsp)
orl %ebp, %ecx
subl %eax, %ebp
cmpl %r12d, %eax
cmovgl %ecx, %ebp
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x80(%rsp)
andl $0x7ffffffc, %r14d      # imm = 0x7FFFFFFC
movl %r14d, %edi
movl %r10d, %esi
movq %r10, 0x58(%rsp)
callq 0x20ac53
testq %rax, %rax
je 0x350a12
movl %r15d, 0x38(%rsp)
movq %r14, 0x90(%rsp)
movl %ebp, 0xc(%rsp)
movq %rbx, 0x60(%rsp)
movl 0x130(%rsp), %r8d
xorl %edi, %edi
cmpl $0x0, 0x28(%rsp)
setne %dil
xorl %ecx, %ecx
cmpl $0x0, 0x120(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x128(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %r8d, 0x3c(%rsp)
testl %r8d, %r8d
setne %sil
shll $0xf, %esi
leal (%rcx,%rdi,8), %ecx
orl %edx, %ecx
orl %esi, %ecx
orl 0xc(%rax), %ecx
orl $0x4440402, %ecx        # imm = 0x4440402
movq %rax, 0x68(%rsp)
movl %ecx, 0xc(%rax)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r15
movq 0x58(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
movq %rsi, 0x20(%rsp)
callq 0x20a62d
movq %rax, %rbx
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r13, %rsi
callq 0x2f600c
movq %rax, %r14
movl $0x10, %edi
movq %r13, 0x30(%rsp)
movq %r13, %rsi
callq 0x2f600c
movq %r15, %xmm0
movq %rbx, 0x18(%rsp)
movq %rbx, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %rbp, %xmm1
movq %r14, %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 %r13d, %r13d
testl %ecx, %ecx
jne 0x350a8c
testq %rax, %rax
je 0x350a8c
movq 0x58(%rsp), %r10
leal -0x1(%r10), %ecx
movl $0x3, %edx
subl 0x10(%rsp), %edx
movd 0x40(%rsp), %xmm4
pshufd $0x0, %xmm4, %xmm2      # xmm2 = xmm4[0,0,0,0]
movl 0x2c(%rsp), %ebx
movd %ebx, %xmm0
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0xc(%rsp), %esi
incl %esi
movl %esi, 0xc(%rsp)
movd %esi, %xmm5
pshufd $0x0, %xmm5, %xmm0      # xmm0 = xmm5[0,0,0,0]
movdqa %xmm0, 0xc0(%rsp)
movd 0x80(%rsp), %xmm1
pshufd $0x0, %xmm1, %xmm0      # xmm0 = xmm1[0,0,0,0]
movdqa %xmm0, 0xb0(%rsp)
movd %edx, %xmm1
pshufd $0x0, %xmm1, %xmm0      # xmm0 = xmm1[0,0,0,0]
movdqa %xmm0, 0x40(%rsp)
movq 0x30(%rsp), %r13
movl %r13d, %esi
imull %ebx, %esi
negl %esi
movd %esi, %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 %xmm5, 0xa0(%rsp)
paddd %xmm5, %xmm6
movd %r12d, %xmm1
pshufd $0x0, %xmm1, %xmm0      # xmm0 = xmm1[0,0,0,0]
movdqa %xmm0, 0x80(%rsp)
pshufd $0x44, %xmm4, %xmm8     # xmm8 = xmm4[0,1,0,1]
movd %r13d, %xmm4
pshufd $0x44, %xmm4, %xmm9     # xmm9 = xmm4[0,1,0,1]
movdqa 0x2d8b6d(%rip), %xmm10  # 0x628e80
pmuludq %xmm9, %xmm10
pmuludq 0x2d8b6f(%rip), %xmm9   # 0x628e90
xorl %esi, %esi
pshufd $0xf5, %xmm3, %xmm0     # xmm0 = xmm3[1,1,3,3]
movdqa %xmm0, 0xd0(%rsp)
movdqa 0x2d9656(%rip), %xmm12  # 0x629990
movdqa 0x2d96ed(%rip), %xmm13  # 0x629a30
pshufd $0xf5, %xmm13, %xmm14   # xmm14 = xmm13[1,1,3,3]
movdqa 0x2d96ee(%rip), %xmm15  # 0x629a40
movq %r14, %rdi
movq %r15, %r8
movl 0x28(%rsp), %r9d
pxor %xmm5, %xmm5
testl %r9d, %r9d
je 0x35036c
pxor %xmm1, %xmm1
jmp 0x3503b8
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
movdqa %xmm10, %xmm7
paddq %xmm4, %xmm7
paddq %xmm9, %xmm4
movdqa %xmm4, %xmm0
punpcklqdq %xmm7, %xmm0    # xmm0 = xmm0[0],xmm7[0]
punpckhqdq %xmm7, %xmm4    # xmm4 = xmm4[1],xmm7[1]
pmuludq 0xd0(%rsp), %xmm4
pshufd $0xe8, %xmm4, %xmm4     # xmm4 = xmm4[0,2,2,3]
pmuludq %xmm3, %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movdqa 0x80(%rsp), %xmm1
psubd %xmm0, %xmm1
pxor %xmm0, %xmm0
pcmpgtd %xmm1, %xmm0
movdqa %xmm1, %xmm7
punpckldq %xmm0, %xmm7    # xmm7 = xmm7[0],xmm0[0],xmm7[1],xmm0[1]
pshufd $0xee, %xmm1, %xmm4     # xmm4 = xmm1[2,3,2,3]
pcmpgtd %xmm4, %xmm5
punpckldq %xmm5, %xmm4    # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
psubq %xmm8, %xmm4
psubq %xmm8, %xmm7
movdqa %xmm7, %xmm0
pxor %xmm12, %xmm0
pshufd $0xf5, %xmm0, %xmm5     # xmm5 = xmm0[1,1,3,3]
pcmpeqd %xmm14, %xmm5
pcmpgtd %xmm13, %xmm0
pshufd $0xa0, %xmm0, %xmm11    # xmm11 = xmm0[0,0,2,2]
pand %xmm5, %xmm11
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
por %xmm11, %xmm0
pand %xmm0, %xmm7
pandn %xmm15, %xmm0
por %xmm7, %xmm0
movdqa %xmm4, %xmm5
pxor %xmm12, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pcmpeqd %xmm14, %xmm7
pcmpgtd %xmm13, %xmm5
pshufd $0xa0, %xmm5, %xmm11    # xmm11 = xmm5[0,0,2,2]
pand %xmm7, %xmm11
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
por %xmm11, %xmm5
pand %xmm5, %xmm4
pandn %xmm15, %xmm5
por %xmm4, %xmm5
shufps $0x88, %xmm5, %xmm0     # xmm0 = xmm0[0,2],xmm5[0,2]
movdqa %xmm1, (%rdi)
movaps %xmm0, (%r8)
incq %rsi
addq $0x10, %r8
addq $0x10, %rdi
cmpq %rsi, %r13
jne 0x35035d
movq 0x18(%rsp), %rsi
movl $0x0, (%rsi)
movl %r10d, %r8d
movq 0x20(%rsp), %rsi
andl $-0x2, %esi
movq %rsi, 0x20(%rsp)
leaq -0x1(%r8), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm7     # xmm7 = xmm0[0,1,0,1]
movl %ebx, %esi
negl %esi
addl %ebx, %ebx
xorl %edi, %edi
movdqa 0x2d89e3(%rip), %xmm8   # 0x628e90
movdqa 0x2d89ea(%rip), %xmm9   # 0x628ea0
pcmpeqd %xmm10, %xmm10
xorl %r9d, %r9d
movdqa 0xc0(%rsp), %xmm13
movdqa 0xb0(%rsp), %xmm14
movdqa 0xa0(%rsp), %xmm15
movq %r9, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
por %xmm8, %xmm0
movdqa %xmm7, %xmm1
pxor %xmm9, %xmm1
pxor %xmm9, %xmm0
movdqa %xmm0, %xmm4
pcmpgtd %xmm1, %xmm4
pcmpeqd %xmm1, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pand %xmm4, %xmm0
pshufd $0xf5, %xmm4, %xmm1     # xmm1 = xmm4[1,1,3,3]
por %xmm0, %xmm1
movd %xmm1, %r10d
notl %r10d
testb $0x1, %r10b
je 0x350541
cmpl $0x0, 0x128(%rsp)
movl $0x0, %r10d
cmovel %r12d, %r10d
movq 0x18(%rsp), %r11
movl %r10d, 0x4(%r11,%r9,4)
pxor %xmm10, %xmm1
pextrw $0x4, %xmm1, %r10d
testb $0x1, %r10b
je 0x35056c
leal (%rsi,%r12), %r10d
cmpl $0x0, 0x128(%rsp)
cmovnel %edi, %r10d
movq 0x18(%rsp), %r11
movl %r10d, 0x8(%r11,%r9,4)
addq $0x2, %r9
subl %ebx, %r12d
cmpq %r9, 0x20(%rsp)
jne 0x3504dc
pxor %xmm1, %xmm1
psubd %xmm2, %xmm1
leal -0x1(%r13), %r9d
shlq $0x4, %r9
movq %rax, %rsi
addq %r9, %rsi
movl %r13d, %edi
movdqa %xmm14, %xmm7
movdqa %xmm1, (%rsi)
psubd %xmm3, %xmm1
movdqa %xmm7, %xmm0
pcmpgtd %xmm1, %xmm0
movdqa %xmm1, %xmm4
pand %xmm0, %xmm4
pandn %xmm7, %xmm0
movdqa %xmm0, %xmm7
por %xmm4, %xmm7
addq $-0x10, %rsi
decl %edi
jg 0x35059c
addq %r14, %r9
movl 0x38(%rsp), %r10d
movq %r10, 0x20(%rsp)
shlq $0x4, %r10
addq %r14, %r10
movq %r13, %r11
shlq $0x4, %r11
movq %r13, %rsi
xorl %r13d, %r13d
movdqa 0x40(%rsp), %xmm0
pcmpeqd 0x2d9479(%rip), %xmm0   # 0x629a70
movdqa %xmm0, 0x40(%rsp)
movl %esi, %ebx
movl %ecx, %esi
movdqa %xmm13, %xmm9
movdqa %xmm13, %xmm8
movq %r13, %r12
pshufd $0x90, (%r9), %xmm10    # xmm10 = mem[0,0,1,2]
movq 0x18(%rsp), %rdi
movss (%rdi,%r13,4), %xmm0
movss %xmm0, %xmm10           # xmm10 = xmm0[0],xmm10[1,2,3]
movq 0x70(%rsp), %rdi
movq 0x10(%rdi), %rdi
movq 0x78(%rsp), %r13
movzbl (%r13,%r12), %r13d
movslq (%rdi,%r13,4), %r13
imulq %rbx, %r13
shlq $0x4, %r13
addq 0x98(%rsp), %r13
movdqa %xmm13, %xmm12
psubd (%rax), %xmm12
xorl %edi, %edi
movdqa %xmm13, %xmm11
movdqa (%r14,%rdi), %xmm1
movdqa (%r15,%rdi), %xmm0
psubd %xmm3, %xmm0
movdqa %xmm1, %xmm4
psubd %xmm2, %xmm4
movdqa %xmm0, %xmm5
pcmpgtd %xmm4, %xmm5
pand %xmm5, %xmm0
pandn %xmm4, %xmm5
por %xmm0, %xmm5
paddd (%r13,%rdi), %xmm10
paddd (%rax,%rdi), %xmm12
movdqa %xmm11, %xmm0
pcmpgtd %xmm12, %xmm11
pand %xmm11, %xmm0
pandn %xmm12, %xmm11
por %xmm0, %xmm11
movdqa %xmm5, %xmm12
pcmpgtd %xmm10, %xmm12
movdqa %xmm5, (%r15,%rdi)
pand %xmm12, %xmm5
pandn %xmm10, %xmm12
por %xmm5, %xmm12
movdqa %xmm12, (%rbp,%rdi)
addq $0x10, %rdi
movdqa %xmm1, %xmm10
cmpq %rdi, %r11
jne 0x35065d
leaq 0x1(%r12), %r13
pshufd $0x90, %xmm12, %xmm1    # xmm1 = xmm12[0,0,1,2]
movq 0x18(%rsp), %rdi
movss 0x4(%rdi,%r12,4), %xmm0
movss %xmm0, %xmm1            # xmm1 = xmm0[0],xmm1[1,2,3]
movdqa (%rax), %xmm0
paddd %xmm1, %xmm0
movdqa %xmm11, %xmm10
pcmpgtd %xmm0, %xmm10
pand %xmm10, %xmm11
pandn %xmm0, %xmm10
por %xmm11, %xmm10
movb $0x1, %dil
movdqa %xmm10, %xmm0
movdqa %xmm10, %xmm4
pslldq $0x4, %xmm10            # xmm10 = zero,zero,zero,zero,xmm10[0,1,2,3,4,5,6,7,8,9,10,11]
paddd %xmm6, %xmm10
pcmpgtd %xmm10, %xmm0
pand %xmm0, %xmm4
pandn %xmm10, %xmm0
movdqa %xmm0, %xmm10
por %xmm4, %xmm10
testb $0x1, %dil
movl $0x0, %edi
jne 0x350726
pslldq $0x4, %xmm10            # xmm10 = zero,zero,zero,zero,xmm10[0,1,2,3,4,5,6,7,8,9,10,11]
paddd %xmm15, %xmm10
movdqa %xmm1, %xmm11
pcmpgtd %xmm10, %xmm11
pand %xmm11, %xmm1
pandn %xmm10, %xmm11
por %xmm1, %xmm11
xorl %edi, %edi
movdqa (%rbp,%rdi), %xmm0
psubd %xmm3, %xmm10
psubd %xmm2, %xmm11
movdqa %xmm10, %xmm1
pcmpgtd %xmm11, %xmm1
pand %xmm1, %xmm10
pandn %xmm11, %xmm1
por %xmm1, %xmm10
movdqa %xmm0, %xmm11
pcmpgtd %xmm10, %xmm11
pand %xmm11, %xmm0
pandn %xmm10, %xmm11
por %xmm0, %xmm11
movdqa %xmm11, (%r14,%rdi)
movdqa %xmm7, %xmm0
pcmpgtd %xmm11, %xmm0
movdqa %xmm11, %xmm1
pand %xmm0, %xmm1
pandn %xmm7, %xmm0
por %xmm1, %xmm0
movdqa %xmm0, %xmm7
pcmpgtd %xmm10, %xmm7
movdqa %xmm10, %xmm1
pand %xmm7, %xmm1
pandn %xmm0, %xmm7
por %xmm1, %xmm7
movdqa %xmm8, %xmm0
pcmpgtd %xmm11, %xmm8
pand %xmm8, %xmm0
pandn %xmm11, %xmm8
por %xmm0, %xmm8
addq $0x10, %rdi
cmpq %rdi, %r11
jne 0x350784
movdqa (%r10), %xmm1
movdqa %xmm1, %xmm4
pcmpgtd %xmm9, %xmm4
movdqa %xmm4, %xmm0
pand 0x40(%rsp), %xmm0
movmskps %xmm0, %edi
testl %edi, %edi
cmovnel %r12d, %esi
movdqa %xmm1, %xmm5
cmpl $0x2, 0x10(%rsp)
jg 0x350863
xorl %edi, %edi
movdqa %xmm1, %xmm5
pslldq $0x4, %xmm5             # xmm5 = zero,zero,zero,zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11]
incl %edi
cmpl %edx, %edi
jl 0x350858
pand %xmm4, %xmm1
pandn %xmm9, %xmm4
movdqa %xmm4, %xmm9
por %xmm1, %xmm9
pshufd $0xff, %xmm5, %xmm0     # xmm0 = xmm5[3,3,3,3]
movq 0x68(%rsp), %rdi
movq 0x10(%rdi), %rdi
movq (%rdi), %rdi
movd %xmm0, (%rdi,%r12,4)
cmpq %r8, %r13
jne 0x35060b
movq 0x30(%rsp), %r9
leaq (,%r9,4), %rdi
leaq (%rdi,%rdi,2), %r8
shlq $0x3, %r9
xorl %r10d, %r10d
movq 0x68(%rsp), %r13
movdqa (%r14,%r10,4), %xmm0
movq 0x10(%r13), %r11
movq 0x8(%r11), %r11
movd %xmm0, (%r11,%r10)
addq %r10, %r11
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movd %xmm1, (%rdi,%r11)
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
movd %xmm1, (%r9,%r11)
pshufd $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
movd %xmm0, (%r8,%r11)
addq $0x4, %r10
cmpq %r10, %rdi
jne 0x3508b3
cmpl $0x0, 0x130(%rsp)
movl 0x14(%rsp), %r8d
movq 0x60(%rsp), %rbx
je 0x350929
cmpl $0x2, 0x10(%rsp)
jg 0x35091d
xorl %edi, %edi
pslldq $0x4, %xmm9             # xmm9 = zero,zero,zero,zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11]
incl %edi
cmpl %edx, %edi
jl 0x350911
pshufd $0xff, %xmm9, %xmm0     # xmm0 = xmm9[3,3,3,3]
movd %xmm0, 0xc(%rsp)
cmpl $0x0, 0x120(%rsp)
je 0x3509a5
cmpl $0x0, 0x90(%rsp)
je 0x3509a5
movq 0x30(%rsp), %r9
andl $0x1fffffff, %r9d       # imm = 0x1FFFFFFF
shll $0x2, %r9d
xorl %r10d, %r10d
movl %r10d, %r11d
shrl $0x2, %r11d
movl %r10d, %edi
andl $0x3, %edi
imull 0x30(%rsp), %edi
addl %r11d, %edi
cmpl %ebx, %edi
jge 0x35099d
movl (%r14,%r10,4), %r11d
movl 0xc(%rsp), %r12d
cmpl %r12d, %r11d
jle 0x350983
movl %r11d, 0xc(%rsp)
movl %ecx, %esi
movl %edi, %r8d
jmp 0x35099d
xorl %r12d, %r11d
movl %esi, %ebx
xorl %ecx, %ebx
cmpl %r8d, %edi
cmovgel %r8d, %edi
orl %r11d, %ebx
movq 0x60(%rsp), %rbx
cmovel %edi, %r8d
incq %r10
cmpl %r10d, %r9d
jne 0x350950
movl 0x120(%rsp), %edi
orl %edi, 0x3c(%rsp)
jne 0x350a29
movq 0x20(%rsp), %rsi
shlq $0x4, %rsi
movdqa (%r14,%rsi), %xmm1
cmpl $0x2, 0x10(%rsp)
jg 0x350a17
xorl %esi, %esi
movl 0x14(%rsp), %r8d
pslldq $0x4, %xmm1             # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
incl %esi
cmpl %edx, %esi
jl 0x3509cf
jmp 0x350a1c
callq 0x1b421d
jmp 0x350a12
callq 0x1b41f7
jmp 0x350a12
callq 0x1b41d1
jmp 0x350a12
callq 0x1b41ab
jmp 0x350a12
callq 0x1b4185
jmp 0x350a12
callq 0x1b415f
jmp 0x350a12
callq 0x1b4139
jmp 0x350a12
callq 0x1b4113
xorl %r13d, %r13d
jmp 0x350a8c
movl 0x14(%rsp), %r8d
pshufd $0xff, %xmm1, %xmm0     # xmm0 = xmm1[3,3,3,3]
movd %xmm0, 0xc(%rsp)
movl %ecx, %esi
pcmpgtd %xmm7, %xmm13
pcmpgtd %xmm14, %xmm8
por %xmm13, %xmm8
movmskps %xmm8, %ecx
testl %ecx, %ecx
je 0x350a52
orb $0x40, 0xc(%r13)
movl $0x0, 0xc(%rsp)
xorl %esi, %esi
xorl %r8d, %r8d
movl 0xc(%rsp), %ecx
movl %ecx, (%r13)
movl %r8d, 0x4(%r13)
movl %esi, 0x8(%r13)
movq %rax, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq 0x18(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %r13, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq