// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_striped_avx2_256_64.c
// Function: parasail_nw_rowcol_striped_profile_avx2_256_64
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;
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = NULL;
    int64_t* restrict boundary = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    int64_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    parasail_result_t *result = NULL;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile64.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 = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m256i*)profile->profile64.score;
    vGapO = _mm256_set1_epi64x_rpl(open);
    vGapE = _mm256_set1_epi64x_rpl(gap);
    NEG_LIMIT = (-open < matrix->min ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi64x_rpl(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_64 | PARASAIL_FLAG_LANES_4;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad  = parasail_memalign___m256i(32, segLen);
    pvE      = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int64_t(32, 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;
            __m256i_64_t h;
            __m256i_64_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT64_MIN ? INT64_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT64_MIN ? INT64_MIN : tmp;
            }
            _mm256_store_si256(&pvHStore[index], h.m);
            _mm256_store_si256(&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 < INT64_MIN ? INT64_MIN : tmp;
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        __m256i vF = vNegLimit;

        /* load final segment of pvHStore and shift left by 2 bytes */
        __m256i vH = _mm256_slli_si256_rpl(pvHStore[segLen - 1], 8);

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

        /* Swap the 2 H buffers. */
        __m256i* pv = pvHLoad;
        pvHLoad = pvHStore;
        pvHStore = pv;

        /* insert upper boundary condition */
        vH = _mm256_insert_epi64_rpl(vH, boundary[j], 0);

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

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

            /* Update vE value. */
            vH = _mm256_sub_epi64(vH, vGapO);
            vE = _mm256_sub_epi64(vE, vGapE);
            vE = _mm256_max_epi64_rpl(vE, vH);
            _mm256_store_si256(pvE + i, vE);

            /* Update vF value. */
            vF = _mm256_sub_epi64(vF, vGapE);
            vF = _mm256_max_epi64_rpl(vF, vH);

            /* Load the next vH. */
            vH = _mm256_load_si256(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;
            int64_t tmp2 = tmp < INT64_MIN ? INT64_MIN : tmp;
            vF = _mm256_slli_si256_rpl(vF, 8);
            vF = _mm256_insert_epi64_rpl(vF, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi64_rpl(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
                vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vH = _mm256_sub_epi64(vH, vGapO);
                vF = _mm256_sub_epi64(vF, vGapE);
                if (! _mm256_movemask_epi8(_mm256_cmpgt_epi64(vF, vH))) goto end;
                /*vF = _mm256_max_epi64_rpl(vF, vH);*/
            }
        }
end:
        {
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm256_load_si256(pvHStore + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
        }
#endif
    }

#ifdef PARASAIL_ROWCOL
    for (i=0; i<segLen; ++i) {
        __m256i vH = _mm256_load_si256(pvHStore+i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    /* extract last value from the last column */
    {
        __m256i vH = _mm256_load_si256(pvHStore + offset);
        for (k=0; k<position; ++k) {
            vH = _mm256_slli_si256_rpl (vH, 8);
        }
        score = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi64(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 $0x48, %rsp
movq %rsi, 0x28(%rsp)
testq %rdi, %rdi
je 0x566ca3
movq 0x60(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x566caa
movq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x566cb1
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x566cb8
cmpq $0x0, 0x28(%rsp)
je 0x566cbf
movl %edx, %ebp
testl %edx, %edx
jle 0x566cc6
movl %ecx, %r12d
testl %ecx, %ecx
js 0x566ccd
testl %r8d, %r8d
js 0x566cd4
movl %r8d, 0x1c(%rsp)
leal -0x1(%rdi), %r14d
addq $0x3, %rdi
movq %rdi, %r13
shrq $0x2, %r13
movl %r14d, %eax
xorl %edx, %edx
divl %r13d
movl %eax, 0x4(%rsp)
movl %edx, %r15d
movl %r12d, %ecx
negl %r12d
movq 0x20(%rsp), %rdx
movslq 0x20(%rdx), %rax
movq %rcx, 0x30(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
subq %rax, %rbx
cmpl %r12d, %eax
cmovgq %rcx, %rbx
movslq 0x1c(%rdx), %rax
movq %rax, 0x38(%rsp)
andl $0x7ffffffc, %edi       # imm = 0x7FFFFFFC
movl %ebp, %esi
callq 0x20ac53
testq %rax, %rax
je 0x566cd9
movl %r12d, 0x10(%rsp)
movl %r15d, 0x14(%rsp)
movl %r14d, 0x18(%rsp)
movq %rax, 0x8(%rsp)
orl $0x4840801, 0xc(%rax)   # imm = 0x4840801
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r14
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r15
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r12
leal 0x1(%rbp), %esi
movl $0x20, %edi
callq 0x20a636
testq %r14, %r14
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
testq %r12, %r12
sete %cl
testq %rax, %rax
sete %sil
orb %cl, %sil
orb %dl, %sil
jne 0x566cd9
leal -0x1(%rbp), %ecx
movl $0x3, %edx
subl 0x4(%rsp), %edx
vmovq 0x30(%rsp), %xmm0
vpbroadcastq %xmm0, %ymm2
movl 0x1c(%rsp), %esi
vmovq %rsi, %xmm0
vpbroadcastq %xmm0, %ymm3
incq %rbx
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
subq 0x38(%rsp), %rdi
addq $-0x2, %rdi
vmovq %rbx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovq %rdi, %xmm1
vpbroadcastq %xmm1, %ymm1
movslq 0x10(%rsp), %rdi
vmovd %r13d, %xmm4
vpbroadcastd %xmm4, %ymm6
vmovq %rsi, %xmm4
vpbroadcastq %xmm4, %ymm4
vmovq %rdi, %xmm5
vpbroadcastq %xmm5, %ymm5
vpmuldq 0xc7230(%rip), %ymm6, %ymm6 # 0x62db40
xorl %esi, %esi
movq %r14, %rdi
movq %r12, %r8
vmovq %rsi, %xmm7
vpbroadcastq %xmm7, %ymm7
vpaddq %ymm7, %ymm6, %ymm7
vpmuludq %ymm4, %ymm7, %ymm8
vpsrlq $0x20, %ymm7, %ymm7
vpmuludq %ymm4, %ymm7, %ymm7
vpsllq $0x20, %ymm7, %ymm7
vpaddq %ymm7, %ymm8, %ymm7
vpsubq %ymm7, %ymm5, %ymm7
vpsubq %ymm2, %ymm7, %ymm8
vmovdqa %ymm7, (%rdi)
vmovdqa %ymm8, (%r8)
incq %rsi
addq $0x20, %r8
addq $0x20, %rdi
cmpq %rsi, %r13
jne 0x566918
movq $0x0, (%rax)
movl %ebp, %esi
addl $0x3, %ebp
andl $-0x4, %ebp
leaq -0x1(%rsi), %rdi
vmovq %rdi, %xmm6
vpbroadcastq %xmm6, %ymm9
vpmovsxbq 0xc54d9(%rip), %ymm6 # 0x62be5c
xorl %edi, %edi
vpmovsxbq 0xc53fa(%rip), %ymm7 # 0x62bd88
vpbroadcastq 0xc71e9(%rip), %ymm8 # 0x62db80
vpxor %ymm8, %ymm9, %ymm9
vpcmpeqd %ymm10, %ymm10, %ymm10
vpbroadcastq 0xc71de(%rip), %ymm11 # 0x62db88
vmovq %rdi, %xmm12
vpbroadcastq %xmm12, %ymm12
vpor %ymm7, %ymm12, %ymm12
vpxor %ymm8, %ymm12, %ymm12
vpcmpgtq %ymm9, %ymm12, %ymm12
vpxor %ymm10, %ymm12, %ymm12
vpaddq %ymm6, %ymm10, %ymm13
vpmuludq %ymm4, %ymm13, %ymm14
vpsrlq $0x20, %ymm13, %ymm13
vpmuludq %ymm4, %ymm13, %ymm13
vpsllq $0x20, %ymm13, %ymm13
vpaddq %ymm13, %ymm14, %ymm13
vpsubq %ymm13, %ymm5, %ymm13
vpmaskmovq %ymm13, %ymm12, 0x8(%rax,%rdi,8)
addq $0x4, %rdi
vpaddq %ymm6, %ymm11, %ymm6
cmpq %rdi, %rbp
jne 0x5669aa
leal -0x1(%r13), %r8d
movl 0x14(%rsp), %edi
movl %r13d, %r9d
movq %r9, %r10
shlq $0x5, %r10
xorl %r11d, %r11d
shlq $0x5, %r8
movq %rdi, %r13
shlq $0x5, %r13
vmovdqa %ymm0, %ymm4
vmovdqa %ymm1, %ymm5
movq %r14, %rbp
movq %r15, %r14
vmovdqa (%rbp,%r8), %ymm6
vinserti128 $0x1, %xmm6, %ymm0, %ymm7
vpalignr $0x8, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[8,9,10,11,12,13,14,15],ymm6[0,1,2,3,4,5,6,7],ymm7[24,25,26,27,28,29,30,31],ymm6[16,17,18,19,20,21,22,23]
movq 0x20(%rsp), %rbx
movq 0x10(%rbx), %rbx
movq 0x28(%rsp), %r15
movzbl (%r15,%r11), %r15d
movslq (%rbx,%r15,4), %r15
movq %r9, %rbx
imulq %r15, %rbx
shlq $0x5, %rbx
addq 0x40(%rsp), %rbx
vmovq (%rax,%r11,8), %xmm7
vpblendd $0x3, %ymm7, %ymm6, %ymm7 # ymm7 = ymm7[0,1],ymm6[2,3,4,5,6,7]
xorl %r15d, %r15d
vmovdqa %ymm0, %ymm6
vpaddq (%rbx,%r15), %ymm7, %ymm7
vmovdqa (%r12,%r15), %ymm8
vpcmpgtq %ymm8, %ymm7, %ymm9
vblendvpd %ymm9, %ymm7, %ymm8, %ymm7
vpcmpgtq %ymm6, %ymm7, %ymm9
vblendvpd %ymm9, %ymm7, %ymm6, %ymm7
vmovapd %ymm7, (%r14,%r15)
vpcmpgtq %ymm7, %ymm4, %ymm9
vblendvpd %ymm9, %ymm4, %ymm7, %ymm4
vpcmpgtq %ymm5, %ymm7, %ymm9
vblendvpd %ymm9, %ymm5, %ymm7, %ymm5
vpcmpgtq %ymm5, %ymm8, %ymm9
vblendvpd %ymm9, %ymm5, %ymm8, %ymm5
vpcmpgtq %ymm5, %ymm6, %ymm9
vblendvpd %ymm9, %ymm5, %ymm6, %ymm5
vpsubq %ymm2, %ymm7, %ymm7
vpsubq %ymm3, %ymm8, %ymm8
vpcmpgtq %ymm7, %ymm8, %ymm9
vblendvpd %ymm9, %ymm8, %ymm7, %ymm8
vmovapd %ymm8, (%r12,%r15)
vpsubq %ymm3, %ymm6, %ymm6
vpcmpgtq %ymm7, %ymm6, %ymm8
vblendvpd %ymm8, %ymm6, %ymm7, %ymm6
vmovdqa (%rbp,%r15), %ymm7
addq $0x20, %r15
cmpq %r15, %r10
jne 0x566a78
xorl %ebx, %ebx
movq 0x8(%rax,%r11,8), %r15
subq 0x30(%rsp), %r15
vpermpd $0x90, %ymm6, %ymm6     # ymm6 = ymm6[0,0,1,2]
vmovq %r15, %xmm7
vblendpd $0x1, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[0],ymm6[1,2,3]
xorl %r15d, %r15d
vmovdqa (%r14,%r15), %ymm7
vpcmpgtq %ymm6, %ymm7, %ymm8
vblendvpd %ymm8, %ymm7, %ymm6, %ymm7
vmovapd %ymm7, (%r14,%r15)
vpcmpgtq %ymm5, %ymm7, %ymm8
vblendvpd %ymm8, %ymm5, %ymm7, %ymm5
vpcmpgtq %ymm7, %ymm4, %ymm8
vblendvpd %ymm8, %ymm4, %ymm7, %ymm4
vpsubq %ymm2, %ymm7, %ymm7
vpsubq %ymm3, %ymm6, %ymm6
vpcmpgtq %ymm7, %ymm6, %ymm7
vtestpd %ymm7, %ymm7
je 0x566b79
addq $0x20, %r15
cmpq %r15, %r10
jne 0x566b28
incl %ebx
cmpl $0x4, %ebx
jne 0x566b0a
vmovdqa (%r14,%r13), %ymm6
cmpl $0x2, 0x4(%rsp)
jg 0x566ba1
xorl %ebx, %ebx
movq 0x8(%rsp), %r15
vperm2i128 $0x8, %ymm6, %ymm6, %ymm7 # ymm7 = zero,zero,ymm6[0,1]
vpalignr $0x8, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[8,9,10,11,12,13,14,15],ymm6[0,1,2,3,4,5,6,7],ymm7[24,25,26,27,28,29,30,31],ymm6[16,17,18,19,20,21,22,23]
incl %ebx
cmpl %edx, %ebx
jl 0x566b8d
jmp 0x566ba6
movq 0x8(%rsp), %r15
vextracti128 $0x1, %ymm6, %xmm6
movq 0x10(%r15), %rbx
movq (%rbx), %rbx
vpextrd $0x2, %xmm6, (%rbx,%r11,4)
incq %r11
movq %rbp, %r15
cmpq %rsi, %r11
jne 0x566a25
leaq (,%r9,4), %rsi
leaq (%rsi,%rsi,2), %r8
leaq (,%r9,8), %r9
xorl %r10d, %r10d
movq 0x8(%rsp), %rbx
movq 0x10(%rbx), %r11
movq 0x8(%r11), %r11
vmovdqa (%r14,%r10,8), %xmm2
vmovdqa 0x10(%r14,%r10,8), %xmm3
vmovd %xmm2, (%r11,%r10)
addq %r10, %r11
vpextrd $0x2, %xmm2, (%rsi,%r11)
vmovd %xmm3, (%r9,%r11)
vpextrd $0x2, %xmm3, (%r8,%r11)
addq $0x4, %r10
cmpq %r10, %rsi
jne 0x566be5
shlq $0x5, %rdi
vmovdqa (%r14,%rdi), %ymm2
cmpl $0x2, 0x4(%rsp)
movl 0x18(%rsp), %edi
jg 0x566c49
xorl %esi, %esi
vperm2i128 $0x8, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0x8, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm3[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
incl %esi
cmpl %edx, %esi
jl 0x566c37
vpcmpgtq %ymm5, %ymm0, %ymm0
vpcmpgtq %ymm1, %ymm4, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestpd %ymm0, %ymm0
je 0x566c6a
orb $0x40, 0xc(%rbx)
xorl %edx, %edx
xorl %ecx, %ecx
xorl %edi, %edi
jmp 0x566c76
vextracti128 $0x1, %ymm2, %xmm0
vpextrq $0x1, %xmm0, %rdx
movl %edx, (%rbx)
movl %edi, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
jmp 0x566cdb
callq 0x1f179d
jmp 0x566cd9
callq 0x1f1777
jmp 0x566cd9
callq 0x1f1751
jmp 0x566cd9
callq 0x1f172b
jmp 0x566cd9
callq 0x1f1705
jmp 0x566cd9
callq 0x1f16df
jmp 0x566cd9
callq 0x1f16b9
jmp 0x566cd9
callq 0x1f1693
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)