// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_scan_sse41_128_8.c
// Function: parasail_nw_trace_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;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTDiag;
    __m128i vTDiagE;
    __m128i vTInsE;
    __m128i vTDiagF;
    __m128i vTDelF;

    /* 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;
    vTIns  = _mm_set1_epi8(PARASAIL_INS);
    vTDel  = _mm_set1_epi8(PARASAIL_DEL);
    vTDiag = _mm_set1_epi8(PARASAIL_DIAG);
    vTDiagE = _mm_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi8(PARASAIL_INS_E);
    vTDiagF = _mm_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi8(PARASAIL_DEL_F);
    vNegInfFront = _mm_insert_epi8(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_adds_epi8(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi8(-segLen*gap), 1));

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 16, sizeof(__m128i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;

    /* 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 vE_ext;
        __m128i vE_opn;
        __m128i vHt;
        __m128i vF;
        __m128i vF_ext;
        __m128i vF_opn;
        __m128i vH;
        __m128i vHp;
        __m128i *pvW;
        __m128i vW;
        __m128i case1;
        __m128i case2;
        __m128i vGapper;
        __m128i vT;
        __m128i vET;
        __m128i vFT;

        /* 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);
            vGapper = _mm_load_si128(pvGapper+i);
            vE_opn = _mm_subs_epi8(vH, vGapO);
            vE_ext = _mm_subs_epi8(vE, vGapE);
            case1 = _mm_cmpgt_epi8(vE_opn, vE_ext);
            vET = _mm_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm_max_epi8(vE_opn, vE_ext);
            vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vE);
            vGapper = _mm_adds_epi8(vHt, vGapper);
            vF = _mm_max_epi8(vF, vGapper);
            vHp = _mm_adds_epi8(vHp, vW);
            vHt = _mm_max_epi8(vE, vHp);
            _mm_store_si128(pvE+i, vE);
            _mm_store_si128(pvHt+i, vHt);
            _mm_store_si128(pvH+i, vHp);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm_slli_si128(vHt, 1);
        vHt = _mm_insert_epi8(vHt, boundary[j+1], 0);
        vGapper = _mm_load_si128(pvGapper);
        vGapper = _mm_adds_epi8(vHt, vGapper);
        vF = _mm_max_epi8(vF, vGapper);
        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(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm_load_si128(pvH+i);
            vHt = _mm_load_si128(pvHt+i);
            vF_opn = _mm_subs_epi8(vH, vGapO);
            vF_ext = _mm_subs_epi8(vF, vGapE);
            vF = _mm_max_epi8(vF_opn, vF_ext);
            case1 = _mm_cmpgt_epi8(vF_opn, vF_ext);
            vFT = _mm_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm_max_epi8(vHt, vF);
            case1 = _mm_cmpeq_epi8(vH, vHp);
            case2 = _mm_cmpeq_epi8(vH, vF);
            vT = _mm_blendv_epi8(
                    _mm_blendv_epi8(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm_or_si128(vT, vET);
            vT = _mm_or_si128(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm_max_epi8(vSaturationCheckMax, vH);
        }
    }

    /* 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 $0xc8, %rsp
testq %rdi, %rdi
je 0x470713
movq 0x18(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x47071a
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x470721
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x470728
testq %rsi, %rsi
je 0x47072f
movl %edx, %r9d
testl %edx, %edx
jle 0x470736
testl %ecx, %ecx
js 0x47073d
testl %r8d, %r8d
js 0x470744
movl %r8d, 0x24(%rsp)
movq %rsi, 0x90(%rsp)
leal -0x1(%r12), %ebp
addq $0xf, %r12
shrq $0x4, %r12
movl %ebp, %eax
cltd
idivl %r12d
movl %eax, %r14d
movl %edx, %r15d
movl %ecx, %r13d
negl %r13d
movq 0x58(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negb %sil
cmpl %r13d, %eax
movzbl %sil, %eax
movl %ecx, 0x8(%rsp)
cmovgl %ecx, %eax
movl %eax, 0x40(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movb %al, 0x70(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %r9d, %esi
movq %r9, 0x28(%rsp)
callq 0x2097d1
testq %rax, %rax
je 0x470749
movq %rax, %rbx
movl %r15d, 0x3c(%rsp)
movl %r14d, 0x20(%rsp)
movl %ebp, 0x38(%rsp)
orl $0x10180401, 0xc(%rax)  # imm = 0x10180401
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r15
movq 0x28(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
movq %rsi, 0x88(%rsp)
callq 0x2094c8
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
testq %r15, %r15
sete %cl
cmpq $0x0, 0x10(%rsp)
sete %dl
orb %cl, %dl
testq %rbp, %rbp
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x470749
movq 0x28(%rsp), %rcx
decl %ecx
movl %ecx, 0x1c(%rsp)
movl $0xf, %ecx
subl 0x20(%rsp), %ecx
movl %ecx, 0x34(%rsp)
movl 0x8(%rsp), %esi
movd %esi, %xmm4
pxor %xmm0, %xmm0
pshufb %xmm0, %xmm4
movl 0x24(%rsp), %edx
movd %edx, %xmm5
pshufb %xmm0, %xmm5
movl 0x40(%rsp), %ecx
addb $-0x7f, %cl
movzbl %cl, %ecx
movd %ecx, %xmm2
movdqa %xmm2, %xmm1
pshufb %xmm0, %xmm1
movdqa %xmm1, 0x40(%rsp)
movzbl 0x70(%rsp), %ecx
movd %ecx, %xmm9
pshufb %xmm0, %xmm9
movl %r12d, %ecx
imull %edx, %ecx
negb %cl
movzbl %cl, %ecx
movd %ecx, %xmm7
pshufb 0x185b96(%rip), %xmm7   # 0x5f5eb0
movdqa %xmm2, 0x70(%rsp)
paddsb %xmm2, %xmm7
movl %esi, %edi
movl %edx, %esi
movslq %r13d, %rdx
movl %r12d, %ecx
negq %rdi
movq %rcx, 0x8(%rsp)
movq %rsi, 0x60(%rsp)
imulq %rsi, %rcx
xorl %r10d, %r10d
movq $-0x80, %r11
movq %rdx, %r9
xorl %esi, %esi
cmpq $-0x7f, %r9
movq $-0x80, %r8
cmovgeq %r9, %r8
movb %r8b, 0xb0(%rsp,%rsi)
leaq (%rdi,%r9), %r8
cmpq $-0x7f, %r8
cmovlq %r11, %r8
movb %r8b, 0xa0(%rsp,%rsi)
incq %rsi
subq %rcx, %r9
cmpq $0x10, %rsi
jne 0x47034e
movq %r10, %rsi
shlq $0x4, %rsi
movaps 0xb0(%rsp), %xmm0
movaps %xmm0, (%r14,%rsi)
movdqa 0xa0(%rsp), %xmm0
movdqa %xmm0, (%r15,%rsi)
incq %r10
subq 0x60(%rsp), %rdx
cmpq 0x8(%rsp), %r10
jne 0x470349
movq 0x10(%rsp), %rsi
movb $0x0, (%rsi)
movl $0x1, %ecx
movl 0x24(%rsp), %edi
movq 0x88(%rsp), %r8
cmpl $-0x7f, %r13d
movl $0xffffff80, %edx       # imm = 0xFFFFFF80
cmovgel %r13d, %edx
movb %dl, (%rsi,%rcx)
incq %rcx
subl %edi, %r13d
cmpq %rcx, %r8
jne 0x4703d0
pxor %xmm0, %xmm0
psubsb %xmm4, %xmm0
leal -0x1(%r12), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r12d, %esi
movq 0x28(%rsp), %r9
movdqa %xmm0, (%rdx)
psubsb %xmm5, %xmm0
addq $-0x10, %rdx
decl %esi
jg 0x47040d
movl %ecx, %ecx
shlq $0x4, %rcx
movq %r14, %rdi
addq %rcx, %rdi
cmpl $0x1, %r12d
adcl $0x0, %r12d
cmpl $0x2, %r9d
movl $0x1, %r8d
cmovgel %r9d, %r8d
movq 0x8(%rsp), %r9
shlq $0x4, %r9
shlq $0x4, %r12
xorl %r10d, %r10d
movdqa 0x125d38(%rip), %xmm13  # 0x596190
movdqa 0x125d1f(%rip), %xmm10  # 0x596180
movdqa 0x125d06(%rip), %xmm15  # 0x596170
xorl %r11d, %r11d
movdqa 0x40(%rsp), %xmm8
movdqa %xmm9, 0x60(%rsp)
movq 0x90(%rsp), %rsi
movdqa (%rdi), %xmm3
pslldq $0x1, %xmm3             # xmm3 = zero,xmm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq 0x10(%rsp), %rcx
pinsrb $0x0, (%rcx,%r11), %xmm3
movq 0x58(%rsp), %rcx
movq 0x10(%rcx), %rcx
movzbl (%rsi,%r11), %edx
movslq (%rcx,%rdx,4), %r13
imulq 0x8(%rsp), %r13
shlq $0x4, %r13
addq 0x98(%rsp), %r13
movdqa 0x40(%rsp), %xmm2
movdqa %xmm2, %xmm1
psubsb (%rax), %xmm1
xorl %ecx, %ecx
movdqa %xmm10, %xmm12
movdqa (%r14,%rcx), %xmm10
movdqa (%r15,%rcx), %xmm11
movdqa %xmm10, %xmm6
psubsb %xmm4, %xmm6
psubsb %xmm5, %xmm11
movdqa %xmm6, %xmm0
pcmpgtb %xmm11, %xmm0
movdqa %xmm13, %xmm14
pblendvb %xmm0, %xmm12, %xmm13
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r10, %rdx
paddsb (%rax,%rcx), %xmm1
paddsb (%r13,%rcx), %xmm3
pmaxsb %xmm1, %xmm2
movdqa %xmm13, (%rcx,%rdx)
movdqa %xmm14, %xmm13
pmaxsb %xmm6, %xmm11
pminsb %xmm11, %xmm9
movdqa %xmm11, (%r15,%rcx)
movdqa %xmm11, %xmm1
pmaxsb %xmm3, %xmm1
movdqa %xmm1, (%rbp,%rcx)
movdqa %xmm3, (%r14,%rcx)
addq $0x10, %rcx
movdqa %xmm10, %xmm3
cmpq %rcx, %r12
jne 0x4704d2
pslldq $0x1, %xmm1             # xmm1 = zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq 0x10(%rsp), %rcx
pinsrb $0x0, 0x1(%rcx,%r11), %xmm1
incq %r11
movdqa (%rax), %xmm0
paddsb %xmm1, %xmm0
pmaxsb %xmm0, %xmm2
movl $0xe, %ecx
movdqa %xmm2, %xmm0
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm7, %xmm2
pmaxsb %xmm0, %xmm2
decl %ecx
jne 0x470588
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb 0x70(%rsp), %xmm2
pmaxsb %xmm2, %xmm1
xorl %r13d, %r13d
movdqa %xmm12, %xmm10
movdqa 0x125bf1(%rip), %xmm11  # 0x5961b0
movdqa 0x125bd8(%rip), %xmm12  # 0x5961a0
movdqa 0x125b7f(%rip), %xmm14  # 0x596150
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa (%rbp,%r13), %xmm6
psubsb %xmm4, %xmm1
psubsb %xmm5, %xmm2
movdqa %xmm1, %xmm3
pmaxsb %xmm2, %xmm3
pcmpgtb %xmm2, %xmm1
movdqa %xmm11, %xmm2
movdqa %xmm1, %xmm0
pblendvb %xmm0, %xmm12, %xmm2
movdqa %xmm6, %xmm1
pmaxsb %xmm3, %xmm1
movdqa (%r14,%r13), %xmm0
pcmpeqb %xmm1, %xmm0
pcmpgtb %xmm3, %xmm6
paddb %xmm14, %xmm6
pblendvb %xmm0, %xmm15, %xmm6
addq %r10, %rcx
por (%r13,%rcx), %xmm2
por %xmm6, %xmm2
movdqa %xmm2, (%r13,%rcx)
movdqa %xmm1, (%r14,%r13)
pminsb %xmm3, %xmm9
pminsb %xmm1, %xmm9
pmaxsb %xmm1, %xmm8
addq $0x10, %r13
movdqa %xmm3, %xmm2
cmpq %r13, %r12
jne 0x4705d1
addq %r9, %r10
cmpq %r8, %r11
jne 0x470483
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
movdqa (%r14,%rcx), %xmm0
cmpl $0xe, 0x20(%rsp)
jg 0x4706a2
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x1c(%rsp), %esi
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %ecx
jne 0x470697
jmp 0x4706a6
movl 0x1c(%rsp), %esi
movdqa 0x40(%rsp), %xmm1
pcmpgtb %xmm9, %xmm1
pcmpgtb 0x60(%rsp), %xmm8
por %xmm1, %xmm8
pmovmskb %xmm8, %ecx
testl %ecx, %ecx
je 0x4706d2
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x4706dc
pextrb $0xf, %xmm0, %ecx
movl 0x38(%rsp), %edx
movsbl %cl, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq 0x10(%rsp), %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x47074b
callq 0x1dafe3
jmp 0x470749
callq 0x1dafbd
jmp 0x470749
callq 0x1daf97
jmp 0x470749
callq 0x1daf71
jmp 0x470749
callq 0x1daf4b
jmp 0x470749
callq 0x1daf25
jmp 0x470749
callq 0x1daeff
jmp 0x470749
callq 0x1daed9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq