// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_striped_sse2_128_32.c
// Function: parasail_sg_flags_table_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,
        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 vProfile = NULL;
    __m128i* restrict pvHStore = NULL;
    __m128i* restrict pvHLoad = NULL;
    __m128i* restrict pvE = 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;
    __m128i vMaxH;
    __m128i vPosMask;
    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;
    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;
    vMaxH = vNegLimit;
    vPosMask = _mm_cmpeq_epi32(_mm_set1_epi32(position),
            _mm_set_epi32(0,1,2,3));

    /* 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_STRIPED
        | 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 */
    pvHStore = parasail_memalign___m128i(16, segLen);
    pvHLoad =  parasail_memalign___m128i(16, segLen);
    pvE      = 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 (!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 = 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(&pvHStore[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;
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        __m128i vF = vNegLimit;

        /* load final segment of pvHStore and shift left by 2 bytes */
        __m128i vH = _mm_slli_si128(pvHStore[segLen - 1], 4);

        /* Correct part of the vProfile */
        const __m128i* vP = vProfile + matrix->mapper[(unsigned char)s2[j]] * segLen;

        /* Swap the 2 H buffers. */
        __m128i* pv = pvHLoad;
        pvHLoad = pvHStore;
        pvHStore = pv;

        /* insert upper boundary condition */
        vH = _mm_insert_epi32_rpl(vH, boundary[j], 0);

        /* inner loop to process the query sequence */
        for (i=0; i<segLen; ++i) {
            vH = _mm_add_epi32(vH, _mm_load_si128(vP + i));
            vE = _mm_load_si128(pvE + i);

            /* Get max from vH, vE and vF. */
            vH = _mm_max_epi32_rpl(vH, 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);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

            /* Update vE value. */
            vH = _mm_sub_epi32(vH, vGapO);
            vE = _mm_sub_epi32(vE, vGapE);
            vE = _mm_max_epi32_rpl(vE, vH);
            _mm_store_si128(pvE + i, vE);

            /* Update vF value. */
            vF = _mm_sub_epi32(vF, vGapE);
            vF = _mm_max_epi32_rpl(vF, vH);

            /* 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 */
        for (k=0; k<segWidth; ++k) {
            int64_t tmp = s2_beg ? -open : (boundary[j+1]-open);
            int32_t tmp2 = tmp < INT32_MIN ? INT32_MIN : tmp;
            vF = _mm_slli_si128(vF, 4);
            vF = _mm_insert_epi32_rpl(vF, 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);
#ifdef PARASAIL_TABLE
                arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vH = _mm_sub_epi32(vH, vGapO);
                vF = _mm_sub_epi32(vF, vGapE);
                if (! _mm_movemask_epi8(_mm_cmpgt_epi32(vF, vH))) goto end;
                /*vF = _mm_max_epi32_rpl(vF, vH);*/
            }
        }
end:
        {
            /* extract vector containing last value from the column */
            __m128i vCompare;
            vH = _mm_load_si128(pvHStore + 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(pvHStore + 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*)pvHStore;
        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(pvHStore + 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(boundary);
    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 $0xc8, %rsp
movl %ecx, 0xc(%rsp)
movq %rsi, 0x70(%rsp)
testq %rdi, %rdi
je 0x300767
movq 0x48(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x30076e
movq 0x10(%rdi), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x300775
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jle 0x30077c
cmpq $0x0, 0x70(%rsp)
je 0x300783
movl %r8d, %r15d
movl %edx, %r8d
testl %edx, %edx
jle 0x30078a
cmpl $0x0, 0xc(%rsp)
js 0x300791
testl %r15d, %r15d
js 0x300798
movl %r9d, %ebp
leal -0x1(%rcx), %eax
movq %rcx, 0x88(%rsp)
leaq 0x3(%rcx), %r14
movq %r14, %r13
shrq $0x2, %r13
movl %eax, 0x10(%rsp)
cltd
idivl %r13d
movl %eax, 0x18(%rsp)
movl %edx, 0x4(%rsp)
movl 0xc(%rsp), %ecx
movl %ecx, %esi
negl %esi
movq 0x68(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %r12d      # imm = 0x80000000
orl %r12d, %ecx
subl %eax, %r12d
movl %esi, 0x1c(%rsp)
cmpl %esi, %eax
cmovgl %ecx, %r12d
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x48(%rsp)
andl $0x7ffffffc, %r14d      # imm = 0x7FFFFFFC
movl %r14d, %edi
movl %r8d, %esi
movq %r8, 0x20(%rsp)
callq 0x20959f
testq %rax, %rax
je 0x30079d
movq %rax, %rbx
movq %r14, 0x80(%rsp)
movl %r12d, 0x14(%rsp)
xorl %eax, %eax
testl %ebp, %ebp
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x100(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x108(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
cmpl $0x0, 0x110(%rsp)
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%rbx), %eax
orl $0x4420802, %eax        # imm = 0x4420802
movl %eax, 0xc(%rbx)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %r13, %r14
movq %rax, %r13
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %r12
movl $0x10, %edi
movq %r14, 0x38(%rsp)
movq %r14, %rsi
callq 0x2ea474
movq %rax, %r14
movq 0x20(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
movq %rsi, 0x40(%rsp)
callq 0x2094d5
movq %r13, 0x58(%rsp)
testq %r13, %r13
sete %dl
movq %r12, 0x50(%rsp)
testq %r12, %r12
sete %cl
orb %dl, %cl
movq %r14, 0x60(%rsp)
testq %r14, %r14
sete %sil
testq %rax, %rax
sete %dl
orb %sil, %dl
xorl %r14d, %r14d
orb %cl, %dl
jne 0x30079d
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
decl %eax
movl %eax, 0x8(%rsp)
movl $0x3, %ecx
subl 0x18(%rsp), %ecx
movl 0xc(%rsp), %eax
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm4      # xmm4 = xmm0[0,0,0,0]
movd %r15d, %xmm0
pshufd $0x0, %xmm0, %xmm5      # xmm5 = xmm0[0,0,0,0]
movl 0x14(%rsp), %r12d
incl %r12d
movd %r12d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movd 0x48(%rsp), %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movl %ecx, 0x2c(%rsp)
movd %ecx, %xmm2
pshufd $0x0, %xmm2, %xmm6      # xmm6 = xmm2[0,0,0,0]
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %eax, %esi
movl %r15d, %edx
imull %eax, %edx
movq $-0x80000000, %rdi      # imm = 0x80000000
movl 0x1c(%rsp), %r8d
movq 0x60(%rsp), %r13
movq 0x58(%rsp), %rax
movl %r8d, %r9d
xorl %r10d, %r10d
testl %ebp, %ebp
movl $0x0, %r11d
cmovel %r9d, %r11d
movslq %r11d, %r11
movl %r11d, 0xb0(%rsp,%r10,4)
subq %rcx, %r11
cmpq $-0x7fffffff, %r11      # imm = 0x80000001
cmovlq %rdi, %r11
movl %r11d, 0xa0(%rsp,%r10,4)
incq %r10
subl %edx, %r9d
cmpq $0x4, %r10
jne 0x3001fa
movq %r14, %r9
shlq $0x4, %r9
movaps 0xb0(%rsp), %xmm2
movaps %xmm2, (%rax,%r9)
movdqa 0xa0(%rsp), %xmm2
movdqa %xmm2, (%r13,%r9)
incq %r14
subl %r15d, %r8d
cmpq %rsi, %r14
jne 0x3001f4
movl %r12d, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl $0x0, (%rdi)
movl $0x1, %eax
movl 0x1c(%rsp), %ecx
movl 0x108(%rsp), %r8d
movq 0x40(%rsp), %r9
testl %r8d, %r8d
movl $0x0, %edx
cmovel %ecx, %edx
movl %edx, (%rdi,%rax,4)
incq %rax
subl %r15d, %ecx
cmpq %rax, %r9
jne 0x300288
movq 0x38(%rsp), %r11
leal -0x1(%r11), %edi
movq 0x20(%rsp), %rdx
movl %edx, %r10d
movl 0x4(%rsp), %eax
cmpl $0x1, %r11d
adcl $0x0, %r11d
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq %rcx, 0x40(%rsp)
movq %rsi, %r8
imulq %r10, %r8
leaq (,%r8,4), %rdx
shlq $0x2, %r10
shlq $0x3, %r8
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %r11
xorl %ebp, %ebp
pcmpeqd 0x2f56a9(%rip), %xmm6   # 0x5f59a0
shlq $0x4, %rdi
movq %rdi, 0x48(%rsp)
movq %rax, 0x78(%rsp)
shlq $0x4, %rax
movq %rax, 0x90(%rsp)
xorl %r9d, %r9d
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movdqa %xmm0, %xmm7
movdqa %xmm0, %xmm2
movdqa %xmm1, %xmm3
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r12
movq %r14, %r15
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x70(%rsp), %rdi
movzbl (%rdi,%r9), %edi
movslq (%rax,%rdi,4), %rax
movq %rsi, %rdi
imulq %rax, %rdi
shlq $0x4, %rdi
addq 0x98(%rsp), %rdi
movq 0x48(%rsp), %rax
pshufd $0x90, (%r12,%rax), %xmm9 # xmm9 = mem[0,0,1,2]
movq 0x30(%rsp), %rax
movq %r9, 0x20(%rsp)
movss (%rax,%r9,4), %xmm8
movss %xmm8, %xmm9            # xmm9 = xmm8[0],xmm9[1,2,3]
movq %rbp, %r9
xorl %r14d, %r14d
movdqa %xmm0, %xmm8
paddd (%rdi,%r14), %xmm9
movdqa (%r13,%r14), %xmm10
movdqa %xmm9, %xmm11
pcmpgtd %xmm10, %xmm11
pand %xmm11, %xmm9
pandn %xmm10, %xmm11
por %xmm9, %xmm11
movdqa %xmm11, %xmm9
pcmpgtd %xmm8, %xmm9
pand %xmm9, %xmm11
pandn %xmm8, %xmm9
por %xmm11, %xmm9
movdqa %xmm9, (%r15,%r14)
movdqa %xmm2, %xmm11
pcmpgtd %xmm9, %xmm2
pand %xmm2, %xmm11
pandn %xmm9, %xmm2
por %xmm11, %xmm2
movdqa %xmm3, %xmm11
pcmpgtd %xmm9, %xmm11
movdqa %xmm9, %xmm12
pand %xmm11, %xmm12
pandn %xmm3, %xmm11
por %xmm12, %xmm11
movdqa %xmm11, %xmm12
pcmpgtd %xmm10, %xmm12
movdqa %xmm10, %xmm3
pand %xmm12, %xmm3
pandn %xmm11, %xmm12
por %xmm3, %xmm12
movdqa %xmm12, %xmm3
pcmpgtd %xmm8, %xmm3
movdqa %xmm8, %xmm11
pand %xmm3, %xmm11
pandn %xmm12, %xmm3
por %xmm11, %xmm3
movq 0x10(%rbx), %rax
movq (%rax), %rax
movd %xmm9, (%rax,%r9)
addq %r9, %rax
pshufd $0x55, %xmm9, %xmm11    # xmm11 = xmm9[1,1,1,1]
movd %xmm11, (%rdx,%rax)
pshufd $0xee, %xmm9, %xmm11    # xmm11 = xmm9[2,3,2,3]
movd %xmm11, (%r8,%rax)
pshufd $0xff, %xmm9, %xmm11    # xmm11 = xmm9[3,3,3,3]
movd %xmm11, (%rcx,%rax)
psubd %xmm4, %xmm9
psubd %xmm5, %xmm10
movdqa %xmm10, %xmm11
pcmpgtd %xmm9, %xmm11
pand %xmm11, %xmm10
pandn %xmm9, %xmm11
por %xmm10, %xmm11
movdqa %xmm11, (%r13,%r14)
psubd %xmm5, %xmm8
movdqa %xmm8, %xmm10
pcmpgtd %xmm9, %xmm8
pand %xmm8, %xmm10
pandn %xmm9, %xmm8
por %xmm10, %xmm8
movdqa (%r12,%r14), %xmm9
addq $0x10, %r14
addq %r10, %r9
cmpq %r14, %r11
jne 0x30038b
movq %r12, 0x50(%rsp)
xorl %edi, %edi
movl 0x1c(%rsp), %eax
cmpl $0x0, 0x108(%rsp)
jne 0x3004fd
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %r9
movl 0x4(%rax,%r9,4), %eax
subl 0xc(%rsp), %eax
pshufd $0x90, %xmm8, %xmm8     # xmm8 = xmm8[0,0,1,2]
movd %eax, %xmm9
movss %xmm9, %xmm8            # xmm8 = xmm9[0],xmm8[1,2,3]
movb $0x1, %r9b
movl $0x1, %r14d
movq %rbp, %r12
xorl %eax, %eax
movdqa (%r15,%rax), %xmm10
movdqa %xmm10, %xmm9
pcmpgtd %xmm8, %xmm9
pand %xmm9, %xmm10
pandn %xmm8, %xmm9
por %xmm10, %xmm9
movdqa %xmm9, (%r15,%rax)
movdqa %xmm3, %xmm10
pcmpgtd %xmm9, %xmm10
movdqa %xmm9, %xmm11
pand %xmm10, %xmm11
pandn %xmm3, %xmm10
movdqa %xmm10, %xmm3
por %xmm11, %xmm3
movdqa %xmm2, %xmm10
pcmpgtd %xmm9, %xmm2
pand %xmm2, %xmm10
pandn %xmm9, %xmm2
por %xmm10, %xmm2
movq 0x10(%rbx), %r13
movq (%r13), %r13
movd %xmm9, (%r13,%r12)
addq %r12, %r13
pshufd $0x55, %xmm9, %xmm10    # xmm10 = xmm9[1,1,1,1]
movd %xmm10, (%rdx,%r13)
pshufd $0xee, %xmm9, %xmm10    # xmm10 = xmm9[2,3,2,3]
movd %xmm10, (%r8,%r13)
pshufd $0xff, %xmm9, %xmm10    # xmm10 = xmm9[3,3,3,3]
movd %xmm10, (%rcx,%r13)
psubd %xmm4, %xmm9
psubd %xmm5, %xmm8
movdqa %xmm8, %xmm10
pcmpgtd %xmm9, %xmm10
movmskps %xmm10, %r13d
testl %r13d, %r13d
je 0x3005e9
cmpq %rsi, %r14
setb %r9b
addq $0x10, %rax
addq %r10, %r12
incq %r14
cmpq %rax, %r11
jne 0x30051b
testb $0x1, %r9b
jne 0x3005fd
leal 0x1(%rdi), %eax
cmpl $0x3, %edi
movl %eax, %edi
jb 0x3004dc
movq 0x90(%rsp), %rax
movdqa (%r15,%rax), %xmm8
movdqa %xmm8, %xmm9
pcmpgtd %xmm7, %xmm9
movdqa %xmm9, %xmm10
pand %xmm6, %xmm10
pand %xmm9, %xmm8
pandn %xmm7, %xmm9
movdqa %xmm9, %xmm7
por %xmm8, %xmm7
movmskps %xmm10, %eax
testl %eax, %eax
movl 0x4(%rsp), %eax
movq 0x20(%rsp), %r9
cmovnel %r9d, %eax
movl %eax, 0x4(%rsp)
incq %r9
addq $0x4, %rbp
movq %r15, %r12
cmpq 0x40(%rsp), %r9
movq 0x50(%rsp), %r14
movq 0x60(%rsp), %r13
jne 0x300332
movl 0x110(%rsp), %ebp
testl %ebp, %ebp
movl 0x10(%rsp), %esi
movq 0x88(%rsp), %r10
movl 0x14(%rsp), %r11d
movq 0x38(%rsp), %r12
movl 0x4(%rsp), %r9d
je 0x3006b8
cmpl $0x2, 0x18(%rsp)
jg 0x3006ae
movl 0x2c(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
pslldq $0x4, %xmm7             # xmm7 = zero,zero,zero,zero,xmm7[0,1,2,3,4,5,6,7,8,9,10,11]
decl %eax
jne 0x3006a5
pshufd $0xff, %xmm7, %xmm4     # xmm4 = xmm7[3,3,3,3]
movd %xmm4, %r11d
cmpl $0x0, 0x100(%rsp)
je 0x300724
cmpl $0x0, 0x80(%rsp)
je 0x300724
movl %r12d, %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
shll $0x2, %eax
xorl %edx, %edx
movl %esi, %ecx
movl %edx, %edi
shrl $0x2, %edi
movl %edx, %esi
andl $0x3, %esi
imull %r12d, %esi
addl %edi, %esi
cmpl %r10d, %esi
jge 0x30071b
movl (%r15,%rdx,4), %edi
cmpl %r11d, %edi
jle 0x300705
movl %edi, %r11d
movl 0x8(%rsp), %r9d
movl %esi, %ecx
jmp 0x30071b
xorl %r11d, %edi
movl %r9d, %r8d
xorl 0x8(%rsp), %r8d
cmpl %ecx, %esi
cmovgel %ecx, %esi
orl %edi, %r8d
cmovel %esi, %ecx
incq %rdx
cmpl %edx, %eax
jne 0x3006db
jmp 0x300726
movl %esi, %ecx
orl 0x100(%rsp), %ebp
jne 0x3007c7
movq 0x78(%rsp), %rax
shlq $0x4, %rax
movdqa (%r15,%rax), %xmm4
cmpl $0x2, 0x18(%rsp)
jg 0x3007b4
movl 0x2c(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x10(%rsp), %ecx
pslldq $0x4, %xmm4             # xmm4 = zero,zero,zero,zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11]
decl %eax
jne 0x30075c
jmp 0x3007b8
callq 0x1ae12d
jmp 0x30079d
callq 0x1ae107
jmp 0x30079d
callq 0x1ae0e1
jmp 0x30079d
callq 0x1ae0bb
jmp 0x30079d
callq 0x1ae095
jmp 0x30079d
callq 0x1ae06f
jmp 0x30079d
callq 0x1ae049
jmp 0x30079d
callq 0x1ae023
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x10(%rsp), %ecx
pshufd $0xff, %xmm4, %xmm4     # xmm4 = xmm4[3,3,3,3]
movd %xmm4, %r11d
movl 0x8(%rsp), %r9d
pcmpgtd %xmm3, %xmm0
pcmpgtd %xmm1, %xmm2
por %xmm0, %xmm2
movmskps %xmm2, %eax
testl %eax, %eax
je 0x3007e6
orb $0x40, 0xc(%rbx)
xorl %r11d, %r11d
xorl %r9d, %r9d
xorl %ecx, %ecx
movl %r11d, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r9d, 0x8(%rbx)
movq 0x30(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x30079f