// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_scan_sse41_128_16.c
// Function: parasail_sw_rowcol_scan_profile_sse41_128_16
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 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;
#ifdef PARASAIL_ROWCOL
    int32_t offset = 0;
    int32_t position = 0;
#endif
    __m128i* restrict pvP = NULL;
    __m128i* restrict pvE = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvHMax = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    __m128i vZero;
    int16_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    parasail_result_t *result = NULL;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile16.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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
#ifdef PARASAIL_ROWCOL
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
#endif
    pvP = (__m128i*)profile->profile16.score;
    vGapO = _mm_set1_epi16(open);
    vGapE = _mm_set1_epi16(gap);
    NEG_LIMIT = (-open < matrix->min ? INT16_MIN + open : INT16_MIN - matrix->min) + 1;
    POS_LIMIT = INT16_MAX - matrix->max - 1;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm_set1_epi16(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vMaxHUnit = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm_insert_epi16(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_adds_epi16(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi16(-segLen*gap), 2));

    /* 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_SW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_BITS_16 | PARASAIL_FLAG_LANES_8;
#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);
    pvHt= parasail_memalign___m128i(16, segLen);
    pvH = parasail_memalign___m128i(16, segLen);
    pvHMax = parasail_memalign___m128i(16, segLen);
    pvGapper = parasail_memalign___m128i(16, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvHMax) return NULL;
    if (!pvGapper) return NULL;

    parasail_memset___m128i(pvH, vZero, segLen);
    parasail_memset___m128i(pvE, vNegLimit, segLen);
    {
        __m128i vGapper = _mm_subs_epi16(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_subs_epi16(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, 2);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = vZero;
        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_epi16(
                    _mm_subs_epi16(vE, vGapE),
                    _mm_subs_epi16(vH, vGapO));
            vHp = _mm_adds_epi16(vHp, vW);
            vF = _mm_max_epi16(vF, _mm_adds_epi16(vHt, pvGapper[i]));
            vHt = _mm_max_epi16(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, 2);
        vF = _mm_max_epi16(vF, _mm_adds_epi16(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 2);
            vFt = _mm_adds_epi16(vFt, vSegLenXgap);
            vF = _mm_max_epi16(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 2);
        vF = _mm_adds_epi16(vF, vNegInfFront);
        vH = _mm_max_epi16(vHt, vF);
        vH = _mm_max_epi16(vH, vZero);
        for (i=0; i<segLen; ++i) {
            vHt = _mm_load_si128(pvHt+i);
            vF = _mm_max_epi16(
                    _mm_subs_epi16(vF, vGapE),
                    _mm_subs_epi16(vH, vGapO));
            vH = _mm_max_epi16(vHt, vF);
            vH = _mm_max_epi16(vH, vZero);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm_max_epi16(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
            vMaxH = _mm_max_epi16(vH, vMaxH);
        } 

        {
            __m128i vCompare = _mm_cmpgt_epi16(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi16_rpl(vMaxH);
                vMaxHUnit = _mm_set1_epi16(score);
                end_ref = j;
                (void)memcpy(pvHMax, pvH, sizeof(__m128i)*segLen);
            }
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            int32_t k = 0;
            __m128i vH = _mm_load_si128(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 2);
            }
            result->rowcols->score_row[j] = (int16_t) _mm_extract_epi16 (vH, 7);
        }
#endif
    }

    /* Trace the alignment ending position on read. */
    {
        int16_t *t = (int16_t*)pvHMax;
        int32_t column_len = segLen * segWidth;
        end_query = s1Len;
        for (i = 0; i<column_len; ++i, ++t) {
            if (*t == score) {
                int32_t temp = i / segWidth + i % segWidth * segLen;
                if (temp < end_query) {
                    end_query = temp;
                }
            }
        }
    }

#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

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi16(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi16(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(pvHMax);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
je 0x428ada
movq 0x30(%rdi), %rax
movq %rax, 0xc8(%rsp)
testq %rax, %rax
je 0x428ae1
movq 0x10(%rdi), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x428ae8
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x428aef
cmpq $0x0, 0x10(%rsp)
je 0x428af6
movl %edx, %ebp
testl %edx, %edx
jle 0x428afd
movl %ecx, %r13d
testl %ecx, %ecx
js 0x428b04
movl %r8d, %r12d
testl %r8d, %r8d
js 0x428b0b
leaq 0x7(%rax), %rbx
movq %rbx, %r15
shrq $0x3, %r15
movq %rax, 0x8(%rsp)
decl %eax
cltd
idivl %r15d
movl %eax, 0x4(%rsp)
movl %edx, %r14d
movl %r13d, %eax
negl %eax
movq 0x68(%rsp), %rsi
movl 0x20(%rsi), %ecx
movl %ecx, %edx
negl %edx
cmpl %eax, %ecx
cmovgl %r13d, %edx
movl %edx, (%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rsi), %ax
movl %eax, 0x50(%rsp)
andl $0x7ffffff8, %ebx       # imm = 0x7FFFFFF8
movl %ebx, %edi
movl %ebp, %esi
callq 0x209630
testq %rax, %rax
je 0x428b10
movl %r13d, 0x80(%rsp)
movl %r12d, 0x90(%rsp)
movl %r14d, 0x28(%rsp)
movl %ebp, 0x40(%rsp)
movq %rbx, 0xa0(%rsp)
movq %rax, 0x20(%rsp)
orl $0x8240404, 0xc(%rax)   # imm = 0x8240404
movl $0x10, %edi
movq %r15, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r15, %rsi
callq 0x2ea474
movq %rax, %r12
movl $0x10, %edi
movq %r15, %rsi
callq 0x2ea474
movq %rax, %r13
movl $0x10, %edi
movq %r15, %rsi
callq 0x2ea474
movq %rax, %rbx
movl $0x10, %edi
movq %r15, %rsi
callq 0x2ea474
movq %rax, %rbp
testq %r14, %r14
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
testq %r13, %r13
sete %al
movq %rbx, 0x30(%rsp)
testq %rbx, %rbx
sete %dl
orb %al, %dl
orb %cl, %dl
testq %rbp, %rbp
sete %al
orb %dl, %al
jne 0x428b10
movl $0x7, %ebx
subl 0x4(%rsp), %ebx
movd 0x80(%rsp), %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x100(%rsp)
movl 0x90(%rsp), %ecx
movd %ecx, %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xf0(%rsp)
movl (%rsp), %eax
addl $0xffff8001, %eax       # imm = 0xFFFF8001
movd %eax, %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x70(%rsp)
movd 0x50(%rsp), %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xd0(%rsp)
movl %eax, (%rsp)
movzwl %ax, %eax
movd %eax, %xmm0
imull %r15d, %ecx
negl %ecx
movd %ecx, %xmm1
pshufb 0x1cf4fe(%rip), %xmm1   # 0x5f7ad0
movdqa %xmm0, 0x110(%rsp)
paddsw %xmm0, %xmm1
movdqa %xmm1, 0xe0(%rsp)
pxor %xmm0, %xmm0
movq %r13, %rdi
movq %r15, %rsi
callq 0x2ea47d
movq %r14, %rdi
movdqa 0x70(%rsp), %xmm0
movq %r15, %rsi
callq 0x2ea47d
pxor %xmm0, %xmm0
movdqa 0xf0(%rsp), %xmm8
movdqa 0x100(%rsp), %xmm7
psubsw %xmm7, %xmm0
leal -0x1(%r15), %eax
movq %rax, %rcx
shlq $0x4, %rcx
addq %rbp, %rcx
movq %r15, 0x18(%rsp)
movl %r15d, %edx
movdqa %xmm0, (%rcx)
psubsw %xmm8, %xmm0
addq $-0x10, %rcx
decl %edx
jg 0x428639
movl %eax, %eax
shlq $0x4, %rax
addq %r13, %rax
movq %rax, 0xc0(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
shlq $0x4, %rcx
movq %rcx, 0xa8(%rsp)
movl 0x28(%rsp), %ecx
shlq $0x4, %rcx
addq %r13, %rcx
movq %rcx, 0xb8(%rsp)
cmpl $0x2, %ebx
movl $0x1, %ecx
cmovgel %ebx, %ecx
movl %ecx, 0x3c(%rsp)
movl 0x40(%rsp), %ecx
movq %rcx, 0xb0(%rsp)
movl %eax, %r9d
movq %r9, %r15
shlq $0x4, %r15
xorl %edi, %edi
pxor %xmm10, %xmm10
xorl %esi, %esi
movdqa 0x70(%rsp), %xmm0
movdqa %xmm0, %xmm12
movdqa %xmm0, %xmm11
movdqa %xmm0, %xmm5
movdqa 0xd0(%rsp), %xmm6
movdqa 0xe0(%rsp), %xmm9
movq 0xc0(%rsp), %rax
movdqa (%rax), %xmm2
pslldq $0x2, %xmm2             # xmm2 = zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movzbl (%rax,%rdi), %edx
movslq (%rcx,%rdx,4), %rdx
movq %r9, %rcx
imulq %rdx, %rcx
shlq $0x4, %rcx
addq 0xc8(%rsp), %rcx
xorl %edx, %edx
movdqa 0x70(%rsp), %xmm0
pxor %xmm1, %xmm1
movdqa (%r13,%rdx), %xmm3
movdqa (%r14,%rdx), %xmm4
paddsw (%rcx,%rdx), %xmm2
paddsw (%rbp,%rdx), %xmm1
psubsw %xmm8, %xmm4
pmaxsw %xmm1, %xmm0
movdqa %xmm2, %xmm1
movdqa %xmm3, %xmm2
psubsw %xmm7, %xmm3
pmaxsw %xmm4, %xmm3
pmaxsw %xmm3, %xmm1
movdqa %xmm3, (%r14,%rdx)
movdqa %xmm1, (%r12,%rdx)
addq $0x10, %rdx
cmpq %rdx, %r15
jne 0x42871d
pslldq $0x2, %xmm1             # xmm1 = zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movdqa (%rbp), %xmm2
paddsw %xmm1, %xmm2
pmaxsw %xmm2, %xmm0
movl $0x6, %ecx
movdqa %xmm0, %xmm2
pslldq $0x2, %xmm0             # xmm0 = zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddsw %xmm9, %xmm0
pmaxsw %xmm2, %xmm0
decl %ecx
jne 0x42877e
pslldq $0x2, %xmm0             # xmm0 = zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddsw 0x110(%rsp), %xmm0
pmaxsw %xmm10, %xmm1
pmaxsw %xmm0, %xmm1
xorl %ecx, %ecx
psubsw %xmm8, %xmm0
psubsw %xmm7, %xmm1
pmaxsw %xmm1, %xmm0
movdqa (%r12,%rcx), %xmm1
pmaxsw %xmm0, %xmm1
pmaxsw %xmm10, %xmm1
movdqa %xmm1, (%r13,%rcx)
pminsw %xmm1, %xmm6
pmaxsw %xmm1, %xmm5
pmaxsw %xmm1, %xmm11
addq $0x10, %rcx
cmpq %rcx, %r15
jne 0x4287ad
movdqa %xmm11, %xmm0
pcmpgtw %xmm12, %xmm0
pmovmskb %xmm0, %ecx
testl %ecx, %ecx
je 0x4288d6
movdqa %xmm11, %xmm0
psrldq $0x8, %xmm0             # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pmaxsw %xmm11, %xmm0
movdqa %xmm0, %xmm1
psrldq $0x4, %xmm1             # xmm1 = xmm1[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
pmaxsw %xmm0, %xmm1
movdqa %xmm11, %xmm0
pxor 0x1cdaab(%rip), %xmm0   # 0x5f62d0
phminposuw %xmm0, %xmm0
movd %xmm0, %eax
xorl $0x7fff, %eax           # imm = 0x7FFF
movl %eax, (%rsp)
pshuflw $0x0, %xmm1, %xmm0      # xmm0 = xmm1[0,0,0,0,4,5,6,7]
psrlq $0x10, %xmm1
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pmaxsw %xmm0, %xmm1
pshufd $0x0, %xmm1, %xmm0      # xmm0 = xmm1[0,0,0,0]
movdqa %xmm0, 0x80(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %r13, %rsi
movq 0xa8(%rsp), %rdx
movq %r9, %rbx
movdqa %xmm5, 0x50(%rsp)
movdqa %xmm6, 0x40(%rsp)
movdqa %xmm11, 0x90(%rsp)
callq 0x19e0c0
movdqa 0x80(%rsp), %xmm12
movdqa 0x90(%rsp), %xmm11
pxor %xmm10, %xmm10
movq 0x28(%rsp), %rdi
movdqa 0xe0(%rsp), %xmm9
movdqa 0xf0(%rsp), %xmm8
movdqa 0x100(%rsp), %xmm7
movdqa 0x40(%rsp), %xmm6
movdqa 0x50(%rsp), %xmm5
movq %rbx, %r9
movl %edi, %esi
movq 0xb8(%rsp), %rax
movdqa (%rax), %xmm0
cmpl $0x6, 0x4(%rsp)
jg 0x4288f6
movl 0x3c(%rsp), %ecx
pslldq $0x2, %xmm0             # xmm0 = zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
decl %ecx
jne 0x4288ed
pextrw $0x7, %xmm0, %ecx
movswl %cx, %ecx
movq 0x20(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %rdx
movl %ecx, (%rdx,%rdi,4)
incq %rdi
cmpq 0xb0(%rsp), %rdi
jne 0x4286d7
cmpl $0x0, 0xa0(%rsp)
je 0x428975
movl %esi, 0x40(%rsp)
movq 0x18(%rsp), %rbx
movl %ebx, %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
shll $0x3, %ecx
xorl %edx, %edx
movq 0x20(%rsp), %r11
movq 0x8(%rsp), %r8
movl (%rsp), %eax
movq 0x30(%rsp), %rsi
cmpw %ax, (%rsi,%rdx,2)
jne 0x42896c
movl %edx, %esi
shrl $0x3, %esi
movl %edx, %edi
andl $0x7, %edi
imull %ebx, %edi
addl %esi, %edi
cmpl %r8d, %edi
cmovll %edi, %r8d
incq %rdx
cmpl %edx, %ecx
jne 0x42894b
jmp 0x428988
movl %esi, 0x40(%rsp)
movq 0x20(%rsp), %r11
movq 0x8(%rsp), %r8
movq 0x18(%rsp), %rbx
movq %r8, 0x8(%rsp)
leal (,%rbx,4), %eax
cmpl $0x1, %ebx
adcl $0x0, %ebx
leaq (%r9,%r9,8), %rdx
leaq (%rdx,%rdx,2), %rcx
addq %r9, %rcx
movq %rcx, 0x50(%rsp)
leaq (,%r9,8), %rsi
leaq (%rsi,%rsi,2), %rcx
movq %rcx, 0x10(%rsp)
leaq (%rax,%rax,4), %r8
shlq $0x4, %r9
movq %rax, %rdi
leaq (%rax,%rax,2), %rcx
shll $0x2, %ebx
xorl %r10d, %r10d
movdqa (%r13,%r10,4), %xmm0
movq %r11, %r15
movq 0x10(%r11), %r11
movq 0x8(%r11), %r11
movq %rbx, %rax
movd %xmm0, %ebx
movswl %bx, %ebx
movl %ebx, (%r11,%r10)
addq %r10, %r11
pextrw $0x1, %xmm0, %ebx
movswl %bx, %ebx
movl %ebx, (%rdi,%r11)
pextrw $0x2, %xmm0, %ebx
movswl %bx, %ebx
movl %ebx, (%rsi,%r11)
pextrw $0x3, %xmm0, %ebx
movswl %bx, %ebx
movl %ebx, (%rcx,%r11)
pextrw $0x4, %xmm0, %ebx
movswl %bx, %ebx
movl %ebx, (%r9,%r11)
pextrw $0x5, %xmm0, %ebx
movswl %bx, %ebx
movl %ebx, (%r8,%r11)
pextrw $0x6, %xmm0, %ebx
movswl %bx, %ebx
movq 0x10(%rsp), %rdx
movl %ebx, (%rdx,%r11)
pextrw $0x7, %xmm0, %ebx
movswl %bx, %ebx
movq 0x50(%rsp), %rdx
movl %ebx, (%rdx,%r11)
movq %r15, %r11
movq %rax, %rbx
addq $0x4, %r10
cmpq %r10, %rax
jne 0x4289d0
movdqa 0x70(%rsp), %xmm0
pcmpgtw %xmm6, %xmm0
pcmpgtw 0xd0(%rsp), %xmm5
por %xmm0, %xmm5
pmovmskb %xmm5, %ecx
testl %ecx, %ecx
movq 0x8(%rsp), %rdx
movl 0x40(%rsp), %eax
je 0x428a9c
orb $0x40, 0xc(%r11)
movl $0x0, (%rsp)
xorl %eax, %eax
xorl %edx, %edx
movswl (%rsp), %ecx
movl %ecx, (%r11)
movl %edx, 0x4(%r11)
movl %eax, 0x8(%r11)
movq %rbp, %rdi
callq 0x2094b5
movq 0x30(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r15, %rax
jmp 0x428b12
callq 0x1d257d
jmp 0x428b10
callq 0x1d2557
jmp 0x428b10
callq 0x1d2531
jmp 0x428b10
callq 0x1d250b
jmp 0x428b10
callq 0x1d24e5
jmp 0x428b10
callq 0x1d24bf
jmp 0x428b10
callq 0x1d2499
jmp 0x428b10
callq 0x1d2473
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq