// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_striped_sse2_128_16.c
// Function: parasail_nw_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;
    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;
    int16_t* restrict boundary = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    int16_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->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;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__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;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm_set1_epi16(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_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);
    pvE      = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int16_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_16_t h;
            __m128i_16_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT16_MIN ? INT16_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT16_MIN ? INT16_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 < INT16_MIN ? INT16_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], 2);

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

        /* 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);
            vSaturationCheckMax = _mm_max_epi16(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vF);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

            /* 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) {
            int64_t tmp = boundary[j+1]-open;
            int16_t tmp2 = tmp < INT16_MIN ? INT16_MIN : tmp;
            vF = _mm_slli_si128(vF, 2);
            vF = _mm_insert_epi16(vF, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi16(vH,vF);
                _mm_store_si128(pvHStore + 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
                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);
        }
#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, 2);
        }
        score = (int16_t) _mm_extract_epi16 (vH, 7);
    }

    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(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, 0x68(%rsp)
testq %rdi, %rdi
je 0x30182c
movq 0x30(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x301833
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x30183a
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x301841
cmpq $0x0, 0x68(%rsp)
je 0x301848
movl %r8d, %r15d
movl %edx, %r8d
testl %edx, %edx
jle 0x30184f
cmpl $0x0, 0xc(%rsp)
js 0x301856
testl %r15d, %r15d
js 0x30185d
leal -0x1(%rdi), %ebp
addq $0x7, %rdi
movq %rdi, %r13
shrq $0x3, %r13
movl %ebp, %eax
cltd
idivl %r13d
movl %eax, %r12d
movl %edx, 0x5c(%rsp)
movl 0xc(%rsp), %ecx
movl %ecx, %r14d
negl %r14d
movq 0x60(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %ebx
negl %ebx
cmpl %r14d, %eax
cmovgl %ecx, %ebx
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x18(%rsp)
andl $0x7ffffff8, %edi       # imm = 0x7FFFFFF8
movl %r8d, %esi
movq %r8, 0x20(%rsp)
callq 0x20959f
testq %rax, %rax
je 0x301862
movl %ebp, 0x30(%rsp)
movl %r12d, 0x34(%rsp)
movq %rax, 0x50(%rsp)
orl $0x8220801, 0xc(%rax)   # imm = 0x8220801
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %r13, 0x40(%rsp)
movq %rax, %r13
movq 0x20(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
callq 0x2094cd
testq %r12, %r12
sete %dl
movq %rbp, 0x10(%rsp)
testq %rbp, %rbp
sete %cl
orb %dl, %cl
movq %r13, 0x38(%rsp)
testq %r13, %r13
sete %sil
movq %rax, 0x48(%rsp)
testq %rax, %rax
sete %dl
orb %sil, %dl
orb %cl, %dl
jne 0x301862
movq 0x20(%rsp), %rax
decl %eax
movl %eax, 0x2c(%rsp)
movl $0x7, %eax
subl 0x34(%rsp), %eax
movl %eax, 0x58(%rsp)
movl 0xc(%rsp), %eax
movd %eax, %xmm0
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
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
addl $0xffff8001, %ebx       # imm = 0xFFFF8001
movd %ebx, %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]
movd 0x18(%rsp), %xmm1
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 %eax, %eax
movl %r15d, %ecx
movslq %r14d, %rdx
movl 0x40(%rsp), %edi
negq %rax
movq %rdi, 0x18(%rsp)
imulq %rcx, %rdi
xorl %r8d, %r8d
movq $-0x7fff, %r9           # imm = 0x8001
movq $-0x8000, %r10          # imm = 0x8000
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rbp
movq %rdx, %r11
xorl %ebx, %ebx
cmpq %r9, %r11
movq $-0x8000, %r13          # imm = 0x8000
cmovgeq %r11, %r13
movw %r13w, 0xb0(%rsp,%rbx,2)
leaq (%rax,%r11), %r13
cmpq %r9, %r13
cmovlq %r10, %r13
movw %r13w, 0xa0(%rsp,%rbx,2)
incq %rbx
subq %rdi, %r11
cmpq $0x8, %rbx
jne 0x3013c2
movq %r8, %r11
shlq $0x4, %r11
movaps 0xb0(%rsp), %xmm4
movaps %xmm4, (%r12,%r11)
movaps 0xa0(%rsp), %xmm4
movq 0x38(%rsp), %rbx
movaps %xmm4, (%rbx,%r11)
incq %r8
subq %rcx, %rdx
cmpq 0x18(%rsp), %r8
jne 0x3013bd
movw $0x0, (%rbp)
movq 0x20(%rsp), %rdi
cmpl $0x2, %edi
movl $0x1, %eax
cmovgel %edi, %eax
xorl %ecx, %ecx
cmpl $0xffff8001, %r14d      # imm = 0xFFFF8001
movl $0xffff8000, %edx       # imm = 0xFFFF8000
cmovgel %r14d, %edx
movw %dx, 0x2(%rbp,%rcx,2)
subl %r15d, %r14d
incq %rcx
cmpq %rcx, %rax
jne 0x301444
movq 0x40(%rsp), %r8
leal -0x1(%r8), %ebx
movl %edi, %eax
cmpl $0x1, %r8d
adcl $0x0, %r8d
cmpl $0x2, %edi
movl $0x1, %ecx
cmovgel %edi, %ecx
movq %rcx, 0x88(%rsp)
movq 0x18(%rsp), %rdi
imulq %rax, %rdi
leaq (,%rdi,4), %r10
shlq $0x2, %rax
movq %rax, 0x20(%rsp)
leaq (,%rdi,8), %r11
leaq (%r10,%r10,2), %rcx
leaq (%rdi,%rdi,8), %rax
leaq (%rax,%rax,2), %rdx
addq %rdi, %rdx
shlq $0x4, %rdi
leaq (%r10,%r10,4), %r9
leaq (%r11,%r11,2), %r14
shlq $0x4, %r8
xorl %r13d, %r13d
shlq $0x4, %rbx
movq %rbx, 0x90(%rsp)
xorl %eax, %eax
movdqa %xmm0, %xmm4
movdqa %xmm1, %xmm5
movq 0x10(%rsp), %rbx
movq %r8, 0x40(%rsp)
movq %r12, %rbp
movq %rbx, %r12
movq %rax, %r15
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rbx
movzbl (%rbx,%r15), %ebx
movslq (%rax,%rbx,4), %rax
movq 0x18(%rsp), %rbx
imulq %rax, %rbx
shlq $0x4, %rbx
movq 0x90(%rsp), %rax
movq %rbp, 0x80(%rsp)
movdqa (%rbp,%rax), %xmm9
pslldq $0x2, %xmm9             # xmm9 = zero,zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movq %r15, 0x70(%rsp)
movq 0x48(%rsp), %rax
pinsrw $0x0, (%rax,%r15,2), %xmm9
addq 0x98(%rsp), %rbx
movq %rbx, 0x10(%rsp)
movq %r13, 0x78(%rsp)
movq %r13, %rax
xorl %r13d, %r13d
movdqa %xmm0, %xmm6
movq 0x38(%rsp), %r15
movq 0x10(%rsp), %rbx
paddsw (%rbx,%r13), %xmm9
movdqa (%r15,%r13), %xmm8
movdqa %xmm8, %xmm7
pmaxsw %xmm6, %xmm7
pmaxsw %xmm9, %xmm7
movdqa %xmm7, (%r12,%r13)
movq 0x10(%rsi), %rbx
movq (%rbx), %rbx
movd %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%rbx,%rax)
addq %rax, %rbx
pextrw $0x1, %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%r10,%rbx)
pextrw $0x2, %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%r11,%rbx)
pextrw $0x3, %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%rcx,%rbx)
pextrw $0x4, %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%rdi,%rbx)
pextrw $0x5, %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%r9,%rbx)
pextrw $0x6, %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%r14,%rbx)
pextrw $0x7, %xmm7, %ebp
movswl %bp, %ebp
movl %ebp, (%rdx,%rbx)
pmaxsw %xmm7, %xmm4
pminsw %xmm8, %xmm5
pminsw %xmm6, %xmm5
pminsw %xmm7, %xmm5
psubsw %xmm2, %xmm7
psubsw %xmm3, %xmm8
pmaxsw %xmm7, %xmm8
movdqa %xmm8, (%r15,%r13)
psubsw %xmm3, %xmm6
pmaxsw %xmm7, %xmm6
movq 0x80(%rsp), %rbx
movaps (%rbx,%r13), %xmm9
addq $0x10, %r13
addq 0x20(%rsp), %rax
cmpq %r13, 0x40(%rsp)
jne 0x30156a
movq $0x0, 0x10(%rsp)
pslldq $0x2, %xmm6             # xmm6 = zero,zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movq 0x48(%rsp), %rax
movq 0x70(%rsp), %rbx
movswl 0x2(%rax,%rbx,2), %eax
subl 0xc(%rsp), %eax
cmpl $0xffff8001, %eax       # imm = 0xFFFF8001
movl $0xffff8000, %ebx       # imm = 0xFFFF8000
cmovll %ebx, %eax
pinsrw $0x0, %eax, %xmm6
movb $0x1, %al
movl $0x1, %r13d
movq 0x78(%rsp), %rbx
xorl %ebp, %ebp
movdqa (%r12,%rbp), %xmm7
pmaxsw %xmm6, %xmm7
movdqa %xmm7, (%r12,%rbp)
pminsw %xmm7, %xmm5
pmaxsw %xmm7, %xmm4
movq 0x10(%rsi), %r15
movq (%r15), %r15
movd %xmm7, %esi
movswl %si, %esi
movl %esi, (%r15,%rbx)
addq %rbx, %r15
pextrw $0x1, %xmm7, %esi
movswl %si, %esi
movl %esi, (%r10,%r15)
pextrw $0x2, %xmm7, %esi
movswl %si, %esi
movl %esi, (%r11,%r15)
pextrw $0x3, %xmm7, %esi
movswl %si, %esi
movl %esi, (%rcx,%r15)
pextrw $0x4, %xmm7, %esi
movswl %si, %esi
movl %esi, (%rdi,%r15)
pextrw $0x5, %xmm7, %esi
movswl %si, %esi
movl %esi, (%r9,%r15)
pextrw $0x6, %xmm7, %esi
movswl %si, %esi
movl %esi, (%r14,%r15)
pextrw $0x7, %xmm7, %esi
movswl %si, %esi
movl %esi, (%rdx,%r15)
movq 0x20(%rsp), %r15
psubsw %xmm2, %xmm7
psubsw %xmm3, %xmm6
movdqa %xmm6, %xmm8
pcmpgtw %xmm7, %xmm8
pmovmskb %xmm8, %esi
testl %esi, %esi
movq 0x50(%rsp), %rsi
je 0x301745
cmpq 0x18(%rsp), %r13
setb %al
addq $0x10, %rbp
addq %r15, %rbx
incq %r13
cmpq %rbp, %r8
jne 0x301684
testb $0x1, %al
jne 0x30175f
movq 0x10(%rsp), %rbx
leal 0x1(%rbx), %eax
cmpl $0x7, %ebx
movq %rax, 0x10(%rsp)
jb 0x30164b
movq 0x70(%rsp), %rax
incq %rax
movq 0x78(%rsp), %r13
addq $0x4, %r13
movq 0x80(%rsp), %r15
movq %r15, %rbx
cmpq 0x88(%rsp), %rax
movq 0x48(%rsp), %rbp
jne 0x3014ee
movl 0x5c(%rsp), %eax
shlq $0x4, %rax
movdqa (%r12,%rax), %xmm2
cmpl $0x6, 0x34(%rsp)
jg 0x3017ca
movl 0x58(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x30(%rsp), %ecx
movq 0x38(%rsp), %rbx
movl 0x2c(%rsp), %edx
pslldq $0x2, %xmm2             # xmm2 = zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
decl %eax
jne 0x3017bf
jmp 0x3017d7
movl 0x30(%rsp), %ecx
movq 0x38(%rsp), %rbx
movl 0x2c(%rsp), %edx
pcmpgtw %xmm5, %xmm0
pcmpgtw %xmm1, %xmm4
por %xmm0, %xmm4
pmovmskb %xmm4, %eax
testl %eax, %eax
je 0x3017f7
orb $0x40, 0xc(%rsi)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x3017fc
pextrw $0x7, %xmm2, %eax
cwtl
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movl %edx, 0x8(%rsi)
movq %rbp, %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq 0x50(%rsp), %rax
jmp 0x301864
callq 0x1ae5a1
jmp 0x301862
callq 0x1ae57b
jmp 0x301862
callq 0x1ae555
jmp 0x301862
callq 0x1ae52f
jmp 0x301862
callq 0x1ae509
jmp 0x301862
callq 0x1ae4e3
jmp 0x301862
callq 0x1ae4bd
jmp 0x301862
callq 0x1ae497
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop