// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_striped_sse2_128_8.c
// Function: parasail_nw_table_striped_profile_sse2_128_8
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;
    int 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;
    int8_t* restrict boundary = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    int8_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    parasail_result_t *result = NULL;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile8.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 = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m128i*)profile->profile8.score;
    vGapO = _mm_set1_epi8(open);
    vGapE = _mm_set1_epi8(gap);
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;

    /* 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_NW | PARASAIL_FLAG_STRIPED
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;
#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_int8_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_8_t h;
            __m128i_8_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT8_MIN ? INT8_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT8_MIN ? INT8_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 = -open-gap*(i-1);
            boundary[i] = tmp < INT8_MIN ? INT8_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], 1);

        /* 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_epi8_rpl(vH, boundary[j], 0);

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

            /* Get max from vH, vE and vF. */
            vH = _mm_max_epi8_rpl(vH, vE);
            vH = _mm_max_epi8_rpl(vH, vF);
            /* Save vH values. */
            _mm_store_si128(pvHStore + i, vH);
            vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vF);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

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

            /* Update vF value. */
            vF = _mm_subs_epi8(vF, vGapE);
            vF = _mm_max_epi8_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 = boundary[j+1]-open;
            int8_t tmp2 = tmp < INT8_MIN ? INT8_MIN : tmp;
            vF = _mm_slli_si128(vF, 1);
            vF = _mm_insert_epi8_rpl(vF, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi8_rpl(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
                vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
                arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vH = _mm_subs_epi8(vH, vGapO);
                vF = _mm_subs_epi8(vF, vGapE);
                if (! _mm_movemask_epi8(_mm_cmpgt_epi8(vF, vH))) goto end;
                /*vF = _mm_max_epi8_rpl(vF, vH);*/
            }
        }
end:
        {
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm_load_si128(pvHStore + offset);
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 1);
            }
            result->rowcols->score_row[j] = (int8_t) _mm_extract_epi8_rpl (vH, 15);
        }
#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

    /* 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, 1);
        }
        score = (int8_t) _mm_extract_epi8_rpl (vH, 15);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi8(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi8(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 $0x178, %rsp            # imm = 0x178
movl %ecx, 0xc(%rsp)
movq %rsi, 0x80(%rsp)
testq %rdi, %rdi
je 0x3037e1
movq 0x18(%rdi), %rax
movq %rax, 0x140(%rsp)
testq %rax, %rax
je 0x3037e8
movq 0x10(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x3037ef
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x3037f6
cmpq $0x0, 0x80(%rsp)
je 0x3037fd
movl %r8d, %r15d
movl %edx, %r8d
testl %edx, %edx
jle 0x303804
cmpl $0x0, 0xc(%rsp)
js 0x30380b
testl %r15d, %r15d
js 0x303812
leal -0x1(%rdi), %r14d
addq $0xf, %rdi
movq %rdi, %rbp
shrq $0x4, %rbp
movl %r14d, %eax
cltd
idivl %ebp
movl %eax, %r13d
movl %edx, 0x74(%rsp)
movl 0xc(%rsp), %edx
movl %edx, %ebx
negl %ebx
movq 0x78(%rsp), %rsi
movl 0x20(%rsi), %eax
movl %eax, %ecx
negb %cl
cmpl %ebx, %eax
movzbl %cl, %eax
cmovgl %edx, %eax
movl %eax, 0x4(%rsp)
movb $0x7e, %al
subb 0x1c(%rsi), %al
movb %al, 0x8(%rsp)
andl $0x7ffffff0, %edi       # imm = 0x7FFFFFF0
movl %r8d, %esi
movq %r8, 0x10(%rsp)
callq 0x20959f
testq %rax, %rax
je 0x303817
movq %rax, %r12
movl %r14d, 0x40(%rsp)
movl %r13d, 0x44(%rsp)
orl $0x10120801, 0xc(%rax)  # imm = 0x10120801
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2ea474
movq %rax, %r13
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2ea474
movq %rax, 0x60(%rsp)
movq 0x10(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
callq 0x2094c8
movq %r13, 0x28(%rsp)
testq %r13, %r13
movq 0x60(%rsp), %r13
sete %dl
movq %r14, 0x38(%rsp)
testq %r14, %r14
sete %cl
orb %dl, %cl
testq %r13, %r13
sete %sil
testq %rax, %rax
sete %dl
orb %sil, %dl
orb %cl, %dl
jne 0x303817
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
decl %eax
movl %eax, 0x70(%rsp)
movl $0xf, %eax
subl 0x44(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl 0xc(%rsp), %ecx
movd %ecx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
movd %r15d, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0x4(%rsp), %eax
addb $-0x7f, %al
movzbl %al, %eax
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movzbl 0x8(%rsp), %eax
movd %eax, %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movl %ecx, %eax
movl %r15d, %ecx
movslq %ebx, %rdx
movl %ebp, %esi
negq %rax
movq %rsi, 0x48(%rsp)
imulq %rcx, %rsi
xorl %edi, %edi
movq $-0x80, %r8
movq %rbp, %r14
movq %rdx, %r9
xorl %r10d, %r10d
cmpq $-0x7f, %r9
movq $-0x80, %r11
cmovgeq %r9, %r11
movb %r11b, 0x160(%rsp,%r10)
leaq (%rax,%r9), %r11
cmpq $-0x7f, %r11
cmovlq %r8, %r11
movb %r11b, 0x150(%rsp,%r10)
incq %r10
subq %rsi, %r9
cmpq $0x10, %r10
jne 0x302f7d
movq %rdi, %r9
shlq $0x4, %r9
movaps 0x160(%rsp), %xmm4
movq 0x28(%rsp), %r10
movaps %xmm4, (%r10,%r9)
movaps 0x150(%rsp), %xmm4
movaps %xmm4, (%r13,%r9)
incq %rdi
subq %rcx, %rdx
cmpq 0x48(%rsp), %rdi
jne 0x302f77
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rsi
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
xorl %ecx, %ecx
movq 0x30(%rsp), %rdi
cmpl $-0x7f, %ebx
movl $0xffffff80, %edx       # imm = 0xFFFFFF80
cmovgel %ebx, %edx
movb %dl, 0x1(%rdi,%rcx)
subl %r15d, %ebx
incq %rcx
cmpq %rcx, %rax
jne 0x303007
leal -0x1(%r14), %ecx
movl %esi, %r8d
cmpl $0x1, %r14d
adcl $0x0, %r14d
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
movq %rax, 0x130(%rsp)
movq 0x48(%rsp), %rbx
imulq %r8, %rbx
leaq (,%rbx,4), %rsi
shlq $0x2, %r8
leaq (,%rbx,8), %r9
leaq (%rsi,%rsi,2), %r10
leaq (%rbx,%rbx,8), %rax
leaq (%rax,%rax,2), %r15
addq %rbx, %r15
movq %rbx, %rbp
imulq $0x2c, %rbx, %r11
imulq $0x34, %rbx, %rax
movq %rax, 0xf0(%rsp)
imulq $0x38, %rbx, %rax
movq %rax, 0xe8(%rsp)
imulq $0x3c, %rbx, %rax
movq %rax, 0xe0(%rsp)
shlq $0x4, %rbx
leaq (%rsi,%rsi,4), %rax
movq %rax, 0xd0(%rsp)
leaq (%r9,%r9,2), %rax
movq %rax, 0xc8(%rsp)
shlq $0x5, %rbp
shlq $0x4, %r14
shlq $0x4, %rcx
movq %rcx, 0x138(%rsp)
movdqa 0x2f29ae(%rip), %xmm6   # 0x5f5a80
movdqa %xmm0, %xmm4
movdqa %xmm1, %xmm5
leaq (%rsi,%rsi,8), %rax
movq %rax, 0xc0(%rsp)
leaq (%r9,%r9,4), %rax
movq %rax, 0xb8(%rsp)
movq %rbx, 0xd8(%rsp)
leaq (%rbx,%rbx,2), %rax
movq %rax, 0xb0(%rsp)
xorl %edx, %edx
xorl %ecx, %ecx
movq 0x38(%rsp), %rax
movq %r12, 0x148(%rsp)
movq %r14, 0x128(%rsp)
movq %r8, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %r9, 0x110(%rsp)
movq %r15, 0x108(%rsp)
movq %rbp, 0x100(%rsp)
movq %r11, 0xf8(%rsp)
movq %r10, 0x88(%rsp)
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rbx
movq 0x80(%rsp), %rax
movq %rdx, %r10
movzbl (%rax,%rcx), %edx
movslq (%rbx,%rdx,4), %rax
movq 0x48(%rsp), %rdx
imulq %rax, %rdx
shlq $0x4, %rdx
addq 0x140(%rsp), %rdx
movq %rdx, 0x50(%rsp)
movq 0x138(%rsp), %rax
movq %rdi, 0xa0(%rsp)
movdqa (%rdi,%rax), %xmm7
pslldq $0x1, %xmm7             # xmm7 = zero,xmm7[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq %rcx, 0x90(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax,%rcx), %ecx
movd %ecx, %xmm9
movdqa %xmm6, %xmm8
pandn %xmm9, %xmm8
por %xmm7, %xmm8
movq %r10, 0x98(%rsp)
movq %r10, 0x10(%rsp)
xorl %ecx, %ecx
movdqa %xmm0, %xmm7
movq 0x50(%rsp), %rax
paddsb (%rax,%rcx), %xmm8
movdqa (%r13,%rcx), %xmm9
movdqa %xmm8, %xmm10
pcmpgtb %xmm9, %xmm10
pand %xmm10, %xmm8
pandn %xmm9, %xmm10
por %xmm8, %xmm10
movdqa %xmm10, %xmm8
pcmpgtb %xmm7, %xmm8
pand %xmm8, %xmm10
pandn %xmm7, %xmm8
por %xmm10, %xmm8
movdqa %xmm8, (%rsi,%rcx)
movq 0x10(%r12), %rdx
movq (%rdx), %rdx
movsbl (%rsi,%rcx), %edi
movsbl 0x1(%rsi,%rcx), %r9d
movsbl 0x2(%rsi,%rcx), %r14d
movsbl 0x3(%rsi,%rcx), %r15d
movsbl 0x4(%rsi,%rcx), %r13d
movsbl 0x5(%rsi,%rcx), %ebp
movsbl 0x6(%rsi,%rcx), %eax
movl %eax, 0x8(%rsp)
movsbl 0x7(%rsi,%rcx), %eax
movl %eax, 0x4(%rsp)
movsbl 0x8(%rsi,%rcx), %ebx
movsbl 0x9(%rsi,%rcx), %r8d
movsbl 0xa(%rsi,%rcx), %eax
movl %eax, 0x38(%rsp)
movsbl 0xb(%rsi,%rcx), %r11d
movsbl 0xc(%rsi,%rcx), %eax
movl %eax, 0x24(%rsp)
movsbl 0xd(%rsi,%rcx), %eax
movl %eax, 0x20(%rsp)
movsbl 0xe(%rsi,%rcx), %eax
movl %eax, 0x1c(%rsp)
movsbl 0xf(%rsi,%rcx), %eax
movl %eax, 0x58(%rsp)
movq 0x10(%rsp), %r10
movl %edi, (%rdx,%r10)
leaq (%rdx,%r10), %rdx
movq 0x118(%rsp), %rdi
movl %r9d, (%rdi,%rdx)
movq 0x110(%rsp), %r9
movl %r14d, (%r9,%rdx)
movq 0x128(%rsp), %r14
movq 0x88(%rsp), %rdi
movl %r15d, (%rdi,%rdx)
movq 0x108(%rsp), %r15
movq 0xd8(%rsp), %rdi
movl %r13d, (%rdi,%rdx)
movq 0x60(%rsp), %rax
movq 0xd0(%rsp), %rdi
movl %ebp, (%rdi,%rdx)
movq 0x100(%rsp), %rbp
movq 0xc8(%rsp), %rdi
movl 0x8(%rsp), %r13d
movl %r13d, (%rdi,%rdx)
movq %rax, %r13
movl 0x4(%rsp), %eax
movl %eax, (%r15,%rdx)
movl %ebx, (%rbp,%rdx)
movq 0xc0(%rsp), %rax
movl %r8d, (%rax,%rdx)
movq 0x120(%rsp), %r8
movq 0xb8(%rsp), %rax
movl 0x38(%rsp), %edi
movl %edi, (%rax,%rdx)
movq 0xf8(%rsp), %rax
movl %r11d, (%rax,%rdx)
movq 0xb0(%rsp), %rax
movl 0x24(%rsp), %edi
movl %edi, (%rax,%rdx)
movq 0xf0(%rsp), %rax
movl 0x20(%rsp), %edi
movl %edi, (%rax,%rdx)
movq 0xe8(%rsp), %rax
movl 0x1c(%rsp), %edi
movl %edi, (%rax,%rdx)
movq 0xe0(%rsp), %rax
movl 0x58(%rsp), %edi
movl %edi, (%rax,%rdx)
movdqa %xmm4, %xmm10
pcmpgtb %xmm8, %xmm4
pand %xmm4, %xmm10
pandn %xmm8, %xmm4
por %xmm10, %xmm4
movdqa %xmm5, %xmm10
pcmpgtb %xmm8, %xmm10
movdqa %xmm8, %xmm11
pand %xmm10, %xmm11
pandn %xmm5, %xmm10
por %xmm11, %xmm10
movdqa %xmm10, %xmm11
pcmpgtb %xmm9, %xmm11
movdqa %xmm9, %xmm5
pand %xmm11, %xmm5
pandn %xmm10, %xmm11
por %xmm5, %xmm11
movdqa %xmm11, %xmm5
pcmpgtb %xmm7, %xmm5
movdqa %xmm7, %xmm10
pand %xmm5, %xmm10
pandn %xmm11, %xmm5
por %xmm10, %xmm5
psubsb %xmm2, %xmm8
psubsb %xmm3, %xmm9
movdqa %xmm9, %xmm10
pcmpgtb %xmm8, %xmm10
pand %xmm10, %xmm9
pandn %xmm8, %xmm10
por %xmm9, %xmm10
movdqa %xmm10, (%r13,%rcx)
psubsb %xmm3, %xmm7
movdqa %xmm7, %xmm9
pcmpgtb %xmm8, %xmm7
pand %xmm7, %xmm9
pandn %xmm8, %xmm7
por %xmm9, %xmm7
movq 0xa0(%rsp), %rax
movdqa (%rax,%rcx), %xmm8
addq $0x10, %rcx
addq %r8, %r10
movq %r10, 0x10(%rsp)
cmpq %rcx, %r14
jne 0x3031e7
movq %rsi, 0x28(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0x88(%rsp), %r10
movq 0x90(%rsp), %rcx
pslldq $0x1, %xmm7             # xmm7 = zero,xmm7[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq 0x30(%rsp), %rax
movsbl 0x1(%rax,%rcx), %eax
subl 0xc(%rsp), %eax
cmpl $-0x7f, %eax
movl $0xffffff80, %ecx       # imm = 0xFFFFFF80
cmovll %ecx, %eax
movd %eax, %xmm8
movdqa %xmm6, %xmm9
pandn %xmm8, %xmm9
por %xmm9, %xmm7
movb $0x1, 0x50(%rsp)
movl $0x1, %eax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rdx
xorl %edi, %edi
movq 0x28(%rsp), %rcx
movdqa (%rcx,%rdi), %xmm9
movdqa %xmm9, %xmm8
pcmpgtb %xmm7, %xmm8
pand %xmm8, %xmm9
pandn %xmm7, %xmm8
por %xmm9, %xmm8
movdqa %xmm8, (%rcx,%rdi)
movq 0x10(%r12), %rax
movq (%rax), %rax
movsbl (%rcx,%rdi), %esi
movl %esi, 0x4(%rsp)
movsbl 0x1(%rcx,%rdi), %r8d
movsbl 0x2(%rcx,%rdi), %r9d
movsbl 0x3(%rcx,%rdi), %r11d
movl %r11d, 0x10(%rsp)
movsbl 0x4(%rcx,%rdi), %ebx
movsbl 0x5(%rcx,%rdi), %ebp
movsbl 0x6(%rcx,%rdi), %r14d
movsbl 0x7(%rcx,%rdi), %r15d
movsbl 0x8(%rcx,%rdi), %r13d
movsbl 0x9(%rcx,%rdi), %r11d
movsbl 0xa(%rcx,%rdi), %r12d
movsbl 0xb(%rcx,%rdi), %esi
movl %esi, 0x8(%rsp)
movsbl 0xc(%rcx,%rdi), %esi
movl %esi, 0x38(%rsp)
movsbl 0xd(%rcx,%rdi), %esi
movl %esi, 0x24(%rsp)
movsbl 0xe(%rcx,%rdi), %esi
movl %esi, 0x20(%rsp)
movsbl 0xf(%rcx,%rdi), %ecx
movl %ecx, 0x1c(%rsp)
movl 0x4(%rsp), %ecx
movl %ecx, (%rax,%rdx)
movq 0x118(%rsp), %rsi
leaq (%rax,%rdx), %rax
movl %r8d, (%rsi,%rax)
movq 0x120(%rsp), %r8
movq 0x110(%rsp), %rcx
movl %r9d, (%rcx,%rax)
movl 0x10(%rsp), %ecx
movl %ecx, (%r10,%rax)
movq 0xd8(%rsp), %rcx
movl %ebx, (%rcx,%rax)
movq 0xd0(%rsp), %rcx
movl %ebp, (%rcx,%rax)
movq 0x100(%rsp), %rbp
movq 0xc8(%rsp), %rcx
movl %r14d, (%rcx,%rax)
movq 0x128(%rsp), %r14
movq 0x108(%rsp), %rcx
movl %r15d, (%rcx,%rax)
movl %r13d, (%rbp,%rax)
movq 0xc0(%rsp), %rcx
movl %r11d, (%rcx,%rax)
movq 0xf8(%rsp), %r11
movq 0xb8(%rsp), %rcx
movl %r12d, (%rcx,%rax)
movq 0x148(%rsp), %r12
movl 0x8(%rsp), %ecx
movl %ecx, (%r11,%rax)
movq 0xb0(%rsp), %rcx
movl 0x38(%rsp), %ebx
movl %ebx, (%rcx,%rax)
movq 0xf0(%rsp), %rcx
movl 0x24(%rsp), %ebx
movl %ebx, (%rcx,%rax)
movq 0xe8(%rsp), %rcx
movl 0x20(%rsp), %ebx
movl %ebx, (%rcx,%rax)
movq 0xe0(%rsp), %rcx
movl 0x1c(%rsp), %ebx
movl %ebx, (%rcx,%rax)
movdqa %xmm5, %xmm9
pcmpgtb %xmm8, %xmm9
movdqa %xmm8, %xmm10
pand %xmm9, %xmm10
pandn %xmm5, %xmm9
movdqa %xmm9, %xmm5
por %xmm10, %xmm5
movdqa %xmm4, %xmm9
pcmpgtb %xmm8, %xmm4
pand %xmm4, %xmm9
pandn %xmm8, %xmm4
por %xmm9, %xmm4
psubsb %xmm2, %xmm8
psubsb %xmm3, %xmm7
movdqa %xmm7, %xmm9
pcmpgtb %xmm8, %xmm9
pmovmskb %xmm9, %eax
testl %eax, %eax
je 0x3036e9
movq 0x58(%rsp), %rax
cmpq 0x48(%rsp), %rax
setb 0x50(%rsp)
addq $0x10, %rdi
addq %r8, %rdx
incq %rax
movq %rax, 0x58(%rsp)
cmpq %rdi, %r14
jne 0x3034e2
testb $0x1, 0x50(%rsp)
movq 0x90(%rsp), %rcx
jne 0x303714
movq 0xa8(%rsp), %rdx
leal 0x1(%rdx), %eax
cmpl $0xf, %edx
movq %rax, 0xa8(%rsp)
jb 0x303497
incq %rcx
movq 0x98(%rsp), %rdx
addq $0x4, %rdx
movq 0xa0(%rsp), %rbx
movq %rbx, %rax
cmpq 0x130(%rsp), %rcx
movq 0x60(%rsp), %r13
jne 0x303157
movl 0x74(%rsp), %eax
shlq $0x4, %rax
movq 0x28(%rsp), %rcx
movdqa (%rcx,%rax), %xmm2
cmpl $0xe, 0x44(%rsp)
movl 0x70(%rsp), %edx
jg 0x30377c
movl 0x6c(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x40(%rsp), %ecx
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %eax
jne 0x303771
jmp 0x303780
movl 0x40(%rsp), %ecx
pcmpgtb %xmm5, %xmm0
pcmpgtb %xmm1, %xmm4
por %xmm0, %xmm4
pmovmskb %xmm4, %eax
testl %eax, %eax
je 0x3037a2
orb $0x40, 0xc(%r12)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x3037aa
pextrw $0x7, %xmm2, %eax
shrl $0x8, %eax
movsbl %al, %eax
movl %eax, (%r12)
movl %ecx, 0x4(%r12)
movl %edx, 0x8(%r12)
movq 0x30(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
jmp 0x30381a
callq 0x1aec4f
jmp 0x303817
callq 0x1aec29
jmp 0x303817
callq 0x1aec03
jmp 0x303817
callq 0x1aebdd
jmp 0x303817
callq 0x1aebb7
jmp 0x303817
callq 0x1aeb91
jmp 0x303817
callq 0x1aeb6b
jmp 0x303817
callq 0x1aeb45
xorl %r12d, %r12d
movq %r12, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop