// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_sse41_128_8.c
// Function: parasail_nw_table_scan_profile_sse41_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;
    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;
    int8_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    __m128i vZero;
    int8_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    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;
    pvP = (__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;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm_insert_epi8(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_adds_epi8(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi8(-segLen*gap), 1));

    /* 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_SCAN
        | 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 */
    pvE = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int8_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_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(&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 < INT8_MIN ? INT8_MIN : tmp;
        }
    }

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

    /* 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, 1);
        vHp = _mm_insert_epi8(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_subs_epi8(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_epi8(
                    _mm_subs_epi8(vE, vGapE),
                    _mm_subs_epi8(vH, vGapO));
            vHp = _mm_adds_epi8(vHp, vW);
            vF = _mm_max_epi8(vF, _mm_adds_epi8(vHt, pvGapper[i]));
            vHt = _mm_max_epi8(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, 1);
        vHt = _mm_insert_epi8(vHt, boundary[j+1], 0);
        vF = _mm_max_epi8(vF, _mm_adds_epi8(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 1);
            vFt = _mm_adds_epi8(vFt, vSegLenXgap);
            vF = _mm_max_epi8(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 1);
        vF = _mm_adds_epi8(vF, vNegInfFront);
        vH = _mm_max_epi8(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm_load_si128(pvHt+i);
            vF = _mm_max_epi8(
                    _mm_subs_epi8(vF, vGapE),
                    _mm_subs_epi8(vH, vGapO));
            vH = _mm_max_epi8(vHt, vF);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm_max_epi8(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
        } 


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

    /* 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, 1);
        }
        score = (int8_t) _mm_extract_epi8 (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(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 $0x138, %rsp            # imm = 0x138
movq %rsi, 0x68(%rsp)
testq %rdi, %rdi
je 0x3e1199
movq 0x18(%rdi), %rax
movq %rax, 0xe8(%rsp)
testq %rax, %rax
je 0x3e11a0
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x3e11a7
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x3e11ae
cmpq $0x0, 0x68(%rsp)
je 0x3e11b5
movl %edx, %r9d
testl %edx, %edx
jle 0x3e11bc
movl %ecx, %r13d
testl %ecx, %ecx
js 0x3e11c3
testl %r8d, %r8d
js 0x3e11ca
movl %r8d, 0x18(%rsp)
leal -0x1(%rdi), %ebp
addq $0xf, %rdi
movq %rdi, %r14
shrq $0x4, %r14
movl %ebp, %eax
cltd
idivl %r14d
movl %eax, %r15d
movl %edx, %r12d
movl %r13d, %ebx
negl %ebx
movq 0x60(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %ecx
negb %cl
cmpl %ebx, %eax
movzbl %cl, %eax
cmovgl %r13d, %eax
movl %eax, 0x38(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movb %al, 0x40(%rsp)
andl $0x7ffffff0, %edi       # imm = 0x7FFFFFF0
movl %r9d, %esi
movq %r9, (%rsp)
callq 0x20959f
testq %rax, %rax
je 0x3e11cf
movl %r13d, 0x30(%rsp)
movl %r12d, 0x5c(%rsp)
movl %r15d, 0xc(%rsp)
movl %ebp, 0x58(%rsp)
movq %rax, 0x20(%rsp)
orl $0x10120401, 0xc(%rax)  # imm = 0x10120401
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %r13
movq (%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
callq 0x2094c8
movq %rax, %r15
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %r12
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
testq %r13, %r13
sete %dl
movq %r15, 0x28(%rsp)
testq %r15, %r15
sete %cl
orb %dl, %cl
testq %r12, %r12
sete %sil
testq %rbp, %rbp
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
jne 0x3e11cf
movq %rax, 0x10(%rsp)
movq %r12, 0x48(%rsp)
movq (%rsp), %rax
decl %eax
movl %eax, 0x8(%rsp)
movl $0xf, %eax
subl 0xc(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x30(%rsp), %edx
movd %edx, %xmm2
pxor %xmm5, %xmm5
pshufb %xmm5, %xmm2
movl 0x18(%rsp), %ecx
movd %ecx, %xmm3
pshufb %xmm5, %xmm3
movl 0x38(%rsp), %eax
addb $-0x7f, %al
movzbl %al, %eax
movd %eax, %xmm4
movdqa %xmm4, %xmm0
pshufb %xmm5, %xmm0
movzbl 0x40(%rsp), %eax
movd %eax, %xmm1
pshufb %xmm5, %xmm1
movl %r14d, %eax
imull %ecx, %eax
negb %al
movzbl %al, %eax
movd %eax, %xmm5
pshufb 0x2152fb(%rip), %xmm5   # 0x5f5eb0
paddsb %xmm4, %xmm5
movl %edx, %eax
movl %ecx, %ecx
movslq %ebx, %rdx
movl %r14d, %r15d
negq %rax
movq %r15, %rsi
imulq %rcx, %rsi
xorl %edi, %edi
movq $-0x80, %r8
movq 0x28(%rsp), %r12
movq %rdx, %r9
xorl %r10d, %r10d
cmpq $-0x7f, %r9
movq $-0x80, %r11
cmovgeq %r9, %r11
movb %r11b, 0x120(%rsp,%r10)
leaq (%rax,%r9), %r11
cmpq $-0x7f, %r11
cmovlq %r8, %r11
movb %r11b, 0x110(%rsp,%r10)
incq %r10
subq %rsi, %r9
cmpq $0x10, %r10
jne 0x3e0be1
movq %rdi, %r9
shlq $0x4, %r9
movaps 0x120(%rsp), %xmm6
movaps %xmm6, (%rbp,%r9)
movdqa 0x110(%rsp), %xmm6
movdqa %xmm6, (%r13,%r9)
incq %rdi
subq %rcx, %rdx
cmpq %r15, %rdi
jne 0x3e0bdb
movb $0x0, (%r12)
movq (%rsp), %rsi
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
xorl %ecx, %ecx
movl 0x18(%rsp), %edi
cmpl $-0x7f, %ebx
movl $0xffffff80, %edx       # imm = 0xFFFFFF80
cmovgel %ebx, %edx
movb %dl, 0x1(%r12,%rcx)
subl %edi, %ebx
incq %rcx
cmpq %rcx, %rax
jne 0x3e0c62
leal -0x1(%r14), %eax
pxor %xmm6, %xmm6
psubsb %xmm2, %xmm6
movq %rax, %rdx
shlq $0x4, %rdx
movq 0x10(%rsp), %rcx
addq %rdx, %rcx
movl %r14d, %edx
movq 0x48(%rsp), %r8
movdqa %xmm6, (%rcx)
psubsb %xmm3, %xmm6
addq $-0x10, %rcx
decl %edx
jg 0x3e0c9f
movl %eax, %eax
shlq $0x4, %rax
movq %rbp, %rcx
addq %rax, %rcx
movq %rcx, 0xd0(%rsp)
cmpl $0x1, %r14d
adcl $0x0, %r14d
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
movq %rax, 0xc8(%rsp)
movl %esi, %esi
shlq $0x4, %r14
movq %r15, 0xd8(%rsp)
movq %r15, %r9
imulq %rsi, %r9
leaq (,%r9,4), %rcx
shlq $0x2, %rsi
leaq (,%r9,8), %r10
leaq (%rcx,%rcx,2), %rax
movq %rax, 0xc0(%rsp)
leaq (%r9,%r9,8), %rax
leaq (%rax,%rax,2), %r15
addq %r9, %r15
movq %r9, %r11
imulq $0x2c, %r9, %rdx
movq %rdx, 0xb8(%rsp)
imulq $0x34, %r9, %rbx
imulq $0x38, %r9, %rax
imulq $0x3c, %r9, %rdx
movq %rdx, 0xb0(%rsp)
shlq $0x4, %r9
leaq (%rcx,%rcx,4), %rdx
movq %rdx, 0xa0(%rsp)
leaq (%r10,%r10,2), %rdx
movq %rdx, 0x98(%rsp)
shlq $0x5, %r11
movdqa %xmm0, %xmm6
movdqa %xmm1, %xmm7
movq %rcx, 0x18(%rsp)
leaq (%rcx,%rcx,8), %rcx
movq %rcx, 0x90(%rsp)
leaq (%r10,%r10,4), %rcx
movq %rcx, 0x88(%rsp)
movq %r9, 0xa8(%rsp)
leaq (%r9,%r9,2), %rcx
movq %rcx, 0x80(%rsp)
movq $0x0, 0x70(%rsp)
xorl %r9d, %r9d
movq %r13, 0xe0(%rsp)
movq %rsi, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movq %rbx, 0x30(%rsp)
movq %rbp, 0x78(%rsp)
movq %r10, 0x108(%rsp)
movq %r14, (%rsp)
movq %r15, 0x100(%rsp)
movq %r11, 0xf8(%rsp)
movq 0xc0(%rsp), %r11
movq 0xb8(%rsp), %r15
movq 0xa8(%rsp), %r10
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rbx
movq 0x60(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x68(%rsp), %rsi
movzbl (%rsi,%r9), %edi
movslq (%rdx,%rdi,4), %rdi
movq 0xd8(%rsp), %rdx
imulq %rdi, %rdx
shlq $0x4, %rdx
addq 0xe8(%rsp), %rdx
movdqa %xmm0, %xmm8
movq 0x10(%rsp), %rsi
psubsb (%rsi), %xmm8
movq 0xd0(%rsp), %rdi
movdqa (%rdi), %xmm10
pslldq $0x1, %xmm10            # xmm10 = zero,xmm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq %r9, %rcx
pinsrb $0x0, (%r12,%r9), %xmm10
xorl %edi, %edi
movdqa %xmm0, %xmm9
movdqa (%rbp,%rdi), %xmm11
movdqa (%r13,%rdi), %xmm12
paddsb (%rdx,%rdi), %xmm10
paddsb (%rsi,%rdi), %xmm8
psubsb %xmm3, %xmm12
pmaxsb %xmm8, %xmm9
movdqa %xmm10, %xmm8
movdqa %xmm11, %xmm10
psubsb %xmm2, %xmm11
pmaxsb %xmm12, %xmm11
pmaxsb %xmm11, %xmm8
movdqa %xmm11, (%r13,%rdi)
movdqa %xmm8, (%r8,%rdi)
addq $0x10, %rdi
cmpq %rdi, %r14
jne 0x3e0e69
pslldq $0x1, %xmm8             # xmm8 = zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq %rcx, %rdx
movq 0x28(%rsp), %rcx
pinsrb $0x0, 0x1(%rcx,%rdx), %xmm8
incq %rdx
movq %rdx, 0xf0(%rsp)
movdqa (%rsi), %xmm10
paddsb %xmm8, %xmm10
pmaxsb %xmm10, %xmm9
movl $0xe, %edx
movdqa %xmm9, %xmm10
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm5, %xmm9
pmaxsb %xmm10, %xmm9
decl %edx
jne 0x3e0ef6
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm4, %xmm9
pmaxsb %xmm9, %xmm8
movq 0x70(%rsp), %rdx
xorl %r13d, %r13d
movq 0xb0(%rsp), %r14
movq 0xa0(%rsp), %r12
movq 0x98(%rsp), %rcx
movq 0x90(%rsp), %r9
psubsb %xmm3, %xmm9
psubsb %xmm2, %xmm8
pmaxsb %xmm8, %xmm9
movdqa (%r8,%r13), %xmm8
pmaxsb %xmm9, %xmm8
movq 0x78(%rsp), %rsi
movdqa %xmm8, (%rsi,%r13)
movq 0x20(%rsp), %rsi
movq 0x10(%rsi), %rdi
movq (%rdi), %rdi
movd %xmm8, %r8d
movsbl %r8b, %r8d
movl %r8d, (%rdi,%rdx)
pextrb $0x1, %xmm8, %r8d
addq %rdx, %rdi
movsbl %r8b, %r8d
pextrb $0x2, %xmm8, %esi
movq 0x18(%rsp), %rbp
movl %r8d, (%rbp,%rdi)
movsbl %sil, %esi
pextrb $0x3, %xmm8, %r8d
movq 0x108(%rsp), %rbp
movl %esi, (%rbp,%rdi)
movsbl %r8b, %esi
pextrb $0x4, %xmm8, %r8d
movl %esi, (%r11,%rdi)
movsbl %r8b, %esi
pextrb $0x5, %xmm8, %r8d
movl %esi, (%r10,%rdi)
movsbl %r8b, %esi
pextrb $0x6, %xmm8, %r8d
movl %esi, (%r12,%rdi)
movsbl %r8b, %esi
pextrb $0x7, %xmm8, %r8d
movl %esi, (%rcx,%rdi)
movsbl %r8b, %esi
pextrb $0x8, %xmm8, %r8d
movq 0x100(%rsp), %rbp
movl %esi, (%rbp,%rdi)
movsbl %r8b, %esi
pextrb $0x9, %xmm8, %r8d
movq 0xf8(%rsp), %rbp
movl %esi, (%rbp,%rdi)
movsbl %r8b, %esi
pextrb $0xa, %xmm8, %r8d
movl %esi, (%r9,%rdi)
movsbl %r8b, %esi
pextrb $0xb, %xmm8, %r8d
movl %esi, (%rax,%rdi)
movsbl %r8b, %esi
pextrb $0xc, %xmm8, %r8d
movl %esi, (%r15,%rdi)
movsbl %r8b, %esi
pextrb $0xd, %xmm8, %r8d
movl %esi, (%rbx,%rdi)
movsbl %r8b, %esi
pextrb $0xe, %xmm8, %r8d
movq 0x30(%rsp), %rbp
movl %esi, (%rbp,%rdi)
movsbl %r8b, %esi
pextrb $0xf, %xmm8, %r8d
movq 0x38(%rsp), %rbp
movl %esi, (%rbp,%rdi)
movsbl %r8b, %esi
movq 0x48(%rsp), %r8
movl %esi, (%r14,%rdi)
movq 0x40(%rsp), %rsi
pminsb %xmm8, %xmm7
pmaxsb %xmm8, %xmm6
addq $0x10, %r13
addq %rsi, %rdx
cmpq %r13, (%rsp)
jne 0x3e0f49
addq $0x4, 0x70(%rsp)
movq 0xf0(%rsp), %r9
cmpq 0xc8(%rsp), %r9
movq 0xe0(%rsp), %r13
movq 0x28(%rsp), %r12
movq 0x78(%rsp), %rbp
movq (%rsp), %r14
jne 0x3e0e06
movl 0x5c(%rsp), %eax
shlq $0x4, %rax
movdqa (%rbp,%rax), %xmm2
cmpl $0xe, 0xc(%rsp)
jg 0x3e1128
movl 0x54(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %eax
jne 0x3e111d
jmp 0x3e1136
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
pcmpgtb %xmm7, %xmm0
pcmpgtb %xmm1, %xmm6
por %xmm0, %xmm6
pmovmskb %xmm6, %eax
testl %eax, %eax
je 0x3e1156
orb $0x40, 0xc(%rcx)
xorl %eax, %eax
xorl %esi, %esi
xorl %edx, %edx
jmp 0x3e1160
pextrb $0xf, %xmm2, %eax
movl 0x58(%rsp), %edx
movsbl %al, %eax
movl %eax, (%rcx)
movl %edx, 0x4(%rcx)
movl %esi, 0x8(%rcx)
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq 0x48(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq 0x20(%rsp), %rax
jmp 0x3e11d1
callq 0x1c9f8b
jmp 0x3e11cf
callq 0x1c9f65
jmp 0x3e11cf
callq 0x1c9f3f
jmp 0x3e11cf
callq 0x1c9f19
jmp 0x3e11cf
callq 0x1c9ef3
jmp 0x3e11cf
callq 0x1c9ecd
jmp 0x3e11cf
callq 0x1c9ea7
jmp 0x3e11cf
callq 0x1c9e81
xorl %eax, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop