// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_striped_sse2_128_16.c
// Function: parasail_sw_table_striped_profile_sse2_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 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;
#ifdef PARASAIL_ROWCOL
    int32_t offset = 0;
    int32_t position = 0;
#endif
    __m128i* restrict vProfile = NULL;
    __m128i* restrict pvHStore = NULL;
    __m128i* restrict pvHLoad = NULL;
    __m128i* restrict pvHMax = NULL;
    __m128i* restrict pvE = NULL;
    __m128i vGapO;
    __m128i vGapE;
    __m128i vZero;
    int16_t bias = 0;
    int16_t score = 0;
    __m128i vBias;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    int16_t maxp = 0;
    __m128i insert_mask;
    /*int16_t stop = 0;*/
    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;
    k = 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
    vProfile = (__m128i*)profile->profile16.score;
    vGapO = _mm_set1_epi16(open);
    vGapE = _mm_set1_epi16(gap);
    vZero = _mm_set1_epi16(0);
    bias = INT16_MIN;
    score = bias;
    vBias = _mm_set1_epi16(bias);
    vMaxH = vBias;
    vMaxHUnit = vBias;
    maxp = INT16_MAX - (int16_t)(matrix->max+1);
    insert_mask = _mm_cmpgt_epi16(
            _mm_set_epi16(0,0,0,0,0,0,0,1),
            vZero);
    /*stop = profile->stop == INT32_MAX ?  INT16_MAX : (int16_t)profile->stop-bias;*/

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

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvHMax) return NULL;
    if (!pvE) return NULL;

    /* initialize H and E */
    parasail_memset___m128i(pvHStore, vBias, segLen);
    parasail_memset___m128i(pvE, vBias, segLen);

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        __m128i vF;
        __m128i vH;
        const __m128i* vP = NULL;
        __m128i* pv = NULL;

        /* Initialize F value to 0.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        vF = vBias;

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

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

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }
        else {
            /* Swap the 2 H buffers. */
            pv = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }

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

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

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

            /* Update vF value. */
            vF = _mm_subs_epi16(vF, vGapE);
            vF = _mm_max_epi16(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) {
            vF = _mm_slli_si128(vF, 2);
            vF = _mm_blendv_epi8_rpl(vF, vBias, insert_mask);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi16(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
                arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len, bias);
#endif
                vMaxH = _mm_max_epi16(vH, vMaxH);
                vH = _mm_subs_epi16(vH, vGapO);
                vF = _mm_subs_epi16(vF, vGapE);
                if (! _mm_movemask_epi8(_mm_cmpgt_epi16(vF, vH))) goto end;
                /*vF = _mm_max_epi16(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, 2);
            }
            result->rowcols->score_row[j] = (int16_t) _mm_extract_epi16 (vH, 7) - bias;
        }
#endif

        {
            __m128i vCompare = _mm_cmpgt_epi16(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi16_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm_set1_epi16(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

#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, bias);
    }
#endif

    if (score == INT16_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = INT16_MAX;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            __m128i *pv = pvHMax;
            pvHMax = pvHStore;
            pvHStore = pv;
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            __m128i *pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pv;
        }
        /* Trace the alignment ending position on read. */
        {
            int16_t *t = (int16_t*)pvHMax;
            int32_t column_len = segLen * segWidth;
            end_query = s1Len - 1;
            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;
                    }
                }
            }
        }
    }

    result->score = score - bias;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(pvE);
    parasail_free(pvHMax);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, 0x58(%rsp)
testq %rdi, %rdi
je 0x302c31
movq 0x30(%rdi), %rax
movq %rax, 0xc8(%rsp)
testq %rax, %rax
je 0x302c38
movq 0x10(%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x302c3f
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x302c46
cmpq $0x0, 0x58(%rsp)
je 0x302c4d
movl %edx, %r13d
testl %edx, %edx
jle 0x302c54
testl %ecx, %ecx
js 0x302c5b
movl %r8d, %r14d
testl %r8d, %r8d
js 0x302c62
movl %ecx, 0x20(%rsp)
leaq 0x7(%r12), %rbp
movq 0x50(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x18(%rsp)
movl %ebp, %ebx
andl $0x7ffffff8, %ebx       # imm = 0x7FFFFFF8
movl %ebx, %edi
movl %r13d, %esi
callq 0x20959f
testq %rax, %rax
je 0x302c67
movq %rax, %r15
movl %r14d, 0x8(%rsp)
movl %ebx, 0x48(%rsp)
movq %r13, 0x28(%rsp)
shrq $0x3, %rbp
orl $0x8220804, 0xc(%rax)   # imm = 0x8220804
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, %rbx
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2ea474
testq %r13, %r13
sete %dl
testq %r14, %r14
sete %cl
orb %dl, %cl
movq %rbx, 0x38(%rsp)
testq %rbx, %rbx
sete %sil
testq %rax, %rax
sete %dl
orb %sil, %dl
orb %cl, %dl
jne 0x302c67
movq %r13, %rdi
movq %r14, %r13
movq %r12, 0x88(%rsp)
movd 0x20(%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, 0xe0(%rsp)
movd 0x8(%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)
movaps 0x2f3735(%rip), %xmm0   # 0x5f5e20
movq %rbp, %rsi
movq %rax, %r14
movq %rdi, %rbx
callq 0x2ea47d
movq %r14, 0x30(%rsp)
movq %r14, %rdi
movaps 0x2f3718(%rip), %xmm0   # 0x5f5e20
movq %rbp, %rsi
callq 0x2ea47d
movq %rbx, %r11
movdqa 0x2f3704(%rip), %xmm9   # 0x5f5e20
movdqa 0xd0(%rsp), %xmm8
movdqa 0xe0(%rsp), %xmm7
xorl %edi, %edi
leal -0x1(%rbp), %r9d
movl 0x28(%rsp), %ecx
movl $0x7ffe, %eax           # imm = 0x7FFE
subl 0x18(%rsp), %eax
cwtl
movl %eax, 0x4c(%rsp)
movq %rbp, 0x80(%rsp)
movl %ebp, %esi
movq %rsi, %rdx
imulq %rcx, %rdx
leaq (,%rdx,4), %r10
movq %rcx, 0x90(%rsp)
leaq (,%rcx,4), %rax
movq %rax, 0x18(%rsp)
leaq (,%rdx,8), %r8
leaq (%r10,%r10,2), %rax
movq %rax, 0xa8(%rsp)
leaq (%rdx,%rdx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rdx, %rax
movq %rax, 0xa0(%rsp)
shlq $0x4, %rdx
movq %rdx, 0x98(%rsp)
movq %r10, 0x70(%rsp)
leaq (%r10,%r10,4), %rbp
movq %r8, 0xb0(%rsp)
leaq (%r8,%r8,2), %rcx
movq %rcx, 0x20(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rsi, %rdx
shlq $0x4, %rdx
movw $0x8000, %r8w           # imm = 0x8000
movl %r8d, 0x4(%rsp)
shlq $0x4, %r9
movq %r9, 0xc0(%rsp)
movd 0x2f3651(%rip), %xmm0   # 0x5f5e40
movl $0x8000, %r12d          # imm = 0x8000
movdqa %xmm9, %xmm2
movdqa %xmm9, %xmm1
xorl %r9d, %r9d
xorl %esi, %esi
movq %r13, %rcx
movq 0xa8(%rsp), %rax
movq 0x50(%rsp), %r8
movq 0x10(%r8), %rbx
movq 0x58(%rsp), %r8
movzbl (%r8,%rsi), %r14d
movslq (%rbx,%r14,4), %rbx
movq 0xb8(%rsp), %r8
imulq %rbx, %r8
shlq $0x4, %r8
addq 0xc8(%rsp), %r8
movq %r8, 0x10(%rsp)
movq %rsi, 0x68(%rsp)
leal -0x2(%rsi), %ebx
movq %rdi, 0x60(%rsp)
cmpl %ebx, %edi
movq %rcx, %rsi
movq 0x38(%rsp), %rdi
cmoveq %rdi, %rsi
movq %rsi, 0x78(%rsp)
cmoveq %rcx, %rdi
movq %rdi, 0x38(%rsp)
movq 0xc0(%rsp), %rdi
movq %r11, 0x8(%rsp)
movdqa (%r11,%rdi), %xmm6
pslldq $0x2, %xmm6             # xmm6 = zero,zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
por %xmm0, %xmm6
movq %r9, 0x40(%rsp)
movq %r9, %r14
xorl %ebx, %ebx
movdqa %xmm9, %xmm3
movq 0x70(%rsp), %r11
movq 0x30(%rsp), %r10
movq 0xb0(%rsp), %rsi
movq 0xa0(%rsp), %rcx
movq 0x98(%rsp), %r13
movq 0x10(%rsp), %rdi
paddsw (%rdi,%rbx), %xmm6
movdqa (%r10,%rbx), %xmm5
movdqa %xmm5, %xmm4
pmaxsw %xmm3, %xmm4
pmaxsw %xmm6, %xmm4
movq 0x78(%rsp), %rdi
movdqa %xmm4, (%rdi,%rbx)
movq %r15, %r9
movq 0x10(%r15), %r15
movq (%r15), %r15
movd %xmm4, %r8d
movswl %r8w, %r8d
addl %r12d, %r8d
movl %r8d, (%r15,%r14)
addq %r14, %r15
pextrw $0x1, %xmm4, %r8d
movswl %r8w, %r8d
addl %r12d, %r8d
pextrw $0x2, %xmm4, %edi
movl %r8d, (%r11,%r15)
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%rsi,%r15)
pextrw $0x3, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%rax,%r15)
pextrw $0x4, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%r13,%r15)
pextrw $0x5, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
pextrw $0x6, %xmm4, %r8d
movl %edi, (%rbp,%r15)
movswl %r8w, %edi
addl %r12d, %edi
movq 0x20(%rsp), %r8
movl %edi, (%r8,%r15)
pextrw $0x7, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%rcx,%r15)
movq %r9, %r15
pmaxsw %xmm4, %xmm1
psubsw %xmm7, %xmm4
psubsw %xmm8, %xmm5
pmaxsw %xmm4, %xmm5
movdqa %xmm5, (%r10,%rbx)
psubsw %xmm8, %xmm3
pmaxsw %xmm4, %xmm3
movq 0x8(%rsp), %rdi
movaps (%rdi,%rbx), %xmm6
addq $0x10, %rbx
addq 0x18(%rsp), %r14
cmpq %rbx, %rdx
jne 0x3028b9
movq %rdx, %r10
movl $0x0, 0x10(%rsp)
movq 0x78(%rsp), %r11
movq %rcx, %rdx
pslldq $0x2, %xmm3             # xmm3 = zero,zero,xmm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
por %xmm0, %xmm3
movq 0x40(%rsp), %rbx
xorl %r14d, %r14d
movdqa (%r11,%r14), %xmm4
pmaxsw %xmm3, %xmm4
movdqa %xmm4, (%r11,%r14)
movq 0x10(%r15), %rdi
movq (%rdi), %r15
movd %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%r15,%rbx)
addq %rbx, %r15
pextrw $0x1, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
pextrw $0x2, %xmm4, %r8d
movq 0x70(%rsp), %rcx
movl %edi, (%rcx,%r15)
movswl %r8w, %edi
addl %r12d, %edi
movl %edi, (%rsi,%r15)
pextrw $0x3, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%rax,%r15)
pextrw $0x4, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%r13,%r15)
pextrw $0x5, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
pextrw $0x6, %xmm4, %r8d
movl %edi, (%rbp,%r15)
movswl %r8w, %edi
addl %r12d, %edi
movq 0x20(%rsp), %rcx
movl %edi, (%rcx,%r15)
pextrw $0x7, %xmm4, %edi
movswl %di, %edi
addl %r12d, %edi
movl %edi, (%rdx,%r15)
movq %r9, %r15
pmaxsw %xmm4, %xmm1
psubsw %xmm7, %xmm4
psubsw %xmm8, %xmm3
movdqa %xmm3, %xmm5
pcmpgtw %xmm4, %xmm5
pmovmskb %xmm5, %edi
testl %edi, %edi
je 0x302ab8
addq $0x10, %r14
addq 0x18(%rsp), %rbx
cmpq %r14, %r10
jne 0x3029d2
movl 0x10(%rsp), %ecx
incl %ecx
movl %ecx, 0x10(%rsp)
cmpl $0x8, %ecx
jne 0x3029c1
movdqa %xmm1, %xmm3
pcmpgtw %xmm2, %xmm3
pmovmskb %xmm3, %edi
movb $0x1, %bl
testl %edi, %edi
je 0x302b22
movdqa %xmm1, %xmm3
psrldq $0x8, %xmm3             # xmm3 = xmm3[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pmaxsw %xmm1, %xmm3
movdqa %xmm3, %xmm4
psrldq $0x4, %xmm4             # xmm4 = xmm4[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
pmaxsw %xmm3, %xmm4
movdqa %xmm4, %xmm3
psrldq $0x2, %xmm3             # xmm3 = xmm3[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
pmaxsw %xmm4, %xmm3
movd %xmm3, %edi
movl %edi, 0x4(%rsp)
movswl %di, %edi
cmpl %edi, 0x4c(%rsp)
movq 0x8(%rsp), %r13
movq %r10, %rdx
movq 0x68(%rsp), %rsi
movq 0x40(%rsp), %r9
jge 0x302b3b
orb $0x40, 0xc(%r15)
xorl %ebx, %ebx
movq 0x60(%rsp), %rdi
jmp 0x302b47
movq 0x60(%rsp), %rdi
movq 0x8(%rsp), %r13
movq %r10, %rdx
movq 0x68(%rsp), %rsi
movq 0x40(%rsp), %r9
jmp 0x302b47
pshuflw $0x0, %xmm3, %xmm2      # xmm2 = xmm3[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
movl %esi, %edi
testb %bl, %bl
je 0x302b65
incq %rsi
addq $0x4, %r9
movq %r13, %rcx
cmpq 0x90(%rsp), %rsi
jne 0x30280f
jmp 0x302b6c
movl %esi, %eax
movq %rax, 0x28(%rsp)
movq %r11, %r14
movq %rdi, %r12
movzwl 0x4(%rsp), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
movq 0x88(%rsp), %rbx
movq 0x38(%rsp), %rbp
jne 0x302b90
orb $0x40, 0xc(%r15)
movq %r15, %rdi
callq 0x20a805
testl %eax, %eax
je 0x302bb0
xorl %r12d, %r12d
movl $0xffff, %eax           # imm = 0xFFFF
xorl %ebx, %ebx
movq 0x30(%rsp), %rdi
jmp 0x302c90
movq 0x28(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movq %r12, %rdx
cmpl %ecx, %edx
movq %r13, %rcx
cmoveq %rbp, %rcx
movq %rbp, %r10
cmoveq %r13, %rbp
cmpl %eax, %edx
cmovneq %r14, %r10
cmoveq %r13, %rcx
movq %rcx, %r13
cmoveq %r14, %rbp
decl %ebx
cmpl $0x0, 0x48(%rsp)
movq 0x30(%rsp), %rdi
je 0x302c7f
movq 0x80(%rsp), %r8
movl %r8d, %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
shll $0x3, %eax
xorl %ecx, %ecx
movl 0x4(%rsp), %r9d
cmpw %r9w, (%rbp,%rcx,2)
jne 0x302c28
movl %ecx, %edx
shrl $0x3, %edx
movl %ecx, %esi
andl $0x7, %esi
imull %r8d, %esi
addl %edx, %esi
cmpl %ebx, %esi
cmovll %esi, %ebx
incq %rcx
cmpl %ecx, %eax
jne 0x302c0b
jmp 0x302c84
callq 0x1aea15
jmp 0x302c67
callq 0x1ae9ef
jmp 0x302c67
callq 0x1ae9c9
jmp 0x302c67
callq 0x1ae9a3
jmp 0x302c67
callq 0x1ae97d
jmp 0x302c67
callq 0x1ae957
jmp 0x302c67
callq 0x1ae931
jmp 0x302c67
callq 0x1ae90b
xorl %r15d, %r15d
movq %r15, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %r9d
movswl %r9w, %eax
addl $0x8000, %eax           # imm = 0x8000
movq %r10, %r14
movl %eax, (%r15)
movl %ebx, 0x4(%r15)
movl %r12d, 0x8(%r15)
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x302c6a
nop