// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_sse2_128_16.c
// Function: parasail_nw_table_scan_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 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;
    int16_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = 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 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;
    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;
    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;
    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_NW | 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);
    boundary = parasail_memalign_int16_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_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(&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 < INT16_MIN ? INT16_MIN : tmp;
        }
    }

    {
        __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);
        vHp = _mm_insert_epi16(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_subs_epi16(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);
            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);
        vHt = _mm_insert_epi16(vHt, boundary[j+1], 0);
        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);
        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);
            _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
        } 


#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            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
    }

#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

    /* 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, 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(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
movq %rsi, 0x68(%rsp)
testq %rdi, %rdi
je 0x2ef430
movq 0x30(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x2ef437
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x2ef43e
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x2ef445
cmpq $0x0, 0x68(%rsp)
je 0x2ef44c
movl %edx, %r15d
testl %edx, %edx
jle 0x2ef453
testl %ecx, %ecx
js 0x2ef45a
testl %r8d, %r8d
js 0x2ef461
movl %r8d, 0x38(%rsp)
leal -0x1(%rdi), %eax
addq $0x7, %rdi
movq %rdi, %r14
shrq $0x3, %r14
movl %eax, 0x24(%rsp)
cltd
idivl %r14d
movl %eax, %ebx
movl %edx, %ebp
movl %ecx, %r12d
negl %r12d
movq 0x60(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negl %esi
cmpl %r12d, %eax
movl %ecx, 0x10(%rsp)
cmovgl %ecx, %esi
movl %esi, (%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x8(%rsp)
andl $0x7ffffff8, %edi       # imm = 0x7FFFFFF8
movl %r15d, %esi
callq 0x20959f
testq %rax, %rax
je 0x2ef466
movq %rax, %r13
movl %ebp, 0x54(%rsp)
movl %ebx, 0x20(%rsp)
orl $0x8220401, 0xc(%rax)   # imm = 0x8220401
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, 0x48(%rsp)
leal 0x1(%r15), %esi
movl $0x10, %edi
movq %rsi, 0x40(%rsp)
callq 0x2094cd
movq %rax, %rbx
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %r15, 0x28(%rsp)
movq %rax, %r15
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq 0x48(%rsp), %rcx
movq %r14, %rdi
movq %rcx, %r14
testq %rcx, %rcx
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
testq %r15, %r15
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
movq %rax, 0x58(%rsp)
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x2ef466
movq %r15, 0x70(%rsp)
movq %rbx, 0x30(%rsp)
movq 0x28(%rsp), %rax
decl %eax
movl %eax, 0x1c(%rsp)
movl $0x7, %eax
subl 0x20(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x10(%rsp), %edx
movd %edx, %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]
movl 0x38(%rsp), %eax
movd %eax, %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]
movl (%rsp), %ecx
addl $0xffff8001, %ecx       # imm = 0xFFFF8001
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]
movd 0x8(%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]
movzwl %cx, %ecx
movd %ecx, %xmm4
movl %edi, %ecx
imull %eax, %ecx
negl %ecx
movd %ecx, %xmm5
pshuflw $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
pslldq $0x2, %xmm5             # xmm5 = zero,zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddsw %xmm4, %xmm5
movl %edx, %ecx
movl %eax, %edx
movslq %r12d, %rsi
movq %rdi, (%rsp)
movl %edi, %eax
negq %rcx
movq %rax, %rdi
imulq %rdx, %rdi
xorl %r8d, %r8d
movq $-0x7fff, %r9           # imm = 0x8001
movq $-0x8000, %r10          # imm = 0x8000
movq %rsi, %r11
xorl %ebx, %ebx
cmpq %r9, %r11
movq $-0x8000, %r15          # imm = 0x8000
cmovgeq %r11, %r15
movw %r15w, 0xb0(%rsp,%rbx,2)
leaq (%rcx,%r11), %r15
cmpq %r9, %r15
cmovlq %r10, %r15
movw %r15w, 0xa0(%rsp,%rbx,2)
incq %rbx
subq %rdi, %r11
cmpq $0x8, %rbx
jne 0x2eefef
movq %r8, %r11
shlq $0x4, %r11
movaps 0xb0(%rsp), %xmm6
movaps %xmm6, (%rbp,%r11)
movdqa 0xa0(%rsp), %xmm6
movdqa %xmm6, (%r14,%r11)
incq %r8
subq %rdx, %rsi
cmpq %rax, %r8
jne 0x2eefea
movq 0x30(%rsp), %rbx
movw $0x0, (%rbx)
movl $0x1, %ecx
movl 0x38(%rsp), %esi
movq 0x40(%rsp), %rdi
cmpl $0xffff8001, %r12d      # imm = 0xFFFF8001
movl $0xffff8000, %edx       # imm = 0xFFFF8000
cmovgel %r12d, %edx
movw %dx, (%rbx,%rcx,2)
incq %rcx
subl %esi, %r12d
cmpq %rcx, %rdi
jne 0x2ef06d
pxor %xmm6, %xmm6
psubsw %xmm2, %xmm6
movq (%rsp), %r9
leal -0x1(%r9), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq 0x58(%rsp), %r12
movq %r12, %rdx
addq %rsi, %rdx
movl %r9d, %esi
movq 0x28(%rsp), %rdi
movdqa %xmm6, (%rdx)
psubsw %xmm3, %xmm6
addq $-0x10, %rdx
decl %esi
jg 0x2ef0b6
movl %ecx, %ecx
shlq $0x4, %rcx
movq %rbp, 0x8(%rsp)
addq %rcx, %rbp
movq %rbp, 0x90(%rsp)
movl %edi, %r8d
cmpl $0x1, %r9d
adcl $0x0, %r9d
cmpl $0x2, %edi
movl $0x1, %ecx
cmovgel %edi, %ecx
movq %rcx, 0x88(%rsp)
shlq $0x4, %r9
movq %r9, (%rsp)
movq %rax, 0x40(%rsp)
movq %rax, %rdi
imulq %r8, %rdi
leaq (,%rdi,4), %rax
shlq $0x2, %r8
leaq (,%rdi,8), %r11
leaq (%rax,%rax,2), %rcx
movq %rcx, 0x78(%rsp)
leaq (%rdi,%rdi,8), %rdx
leaq (%rdx,%rdx,2), %r9
addq %rdi, %r9
shlq $0x4, %rdi
movq %rax, 0x80(%rsp)
leaq (%rax,%rax,4), %rsi
leaq (%r11,%r11,2), %rbp
xorl %edx, %edx
xorl %r10d, %r10d
movdqa %xmm0, %xmm6
movdqa %xmm1, %xmm7
movq %r8, 0x38(%rsp)
movq 0x90(%rsp), %rax
movdqa (%rax), %xmm10
pslldq $0x2, %xmm10            # xmm10 = zero,zero,xmm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, (%rbx,%r10,2), %xmm10
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rbx
movq 0x68(%rsp), %rax
movq %r10, 0x10(%rsp)
movzbl (%rax,%r10), %r15d
movslq (%rbx,%r15,4), %rbx
movq 0x70(%rsp), %r15
imulq 0x40(%rsp), %rbx
shlq $0x4, %rbx
addq 0x98(%rsp), %rbx
movdqa %xmm0, %xmm8
psubsw (%r12), %xmm8
movq %r12, %r8
xorl %r12d, %r12d
movdqa %xmm0, %xmm9
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %r14
movq (%rsp), %r10
movdqa (%r14,%r12), %xmm11
movdqa (%rax,%r12), %xmm12
paddsw (%rbx,%r12), %xmm10
paddsw (%r8,%r12), %xmm8
psubsw %xmm3, %xmm12
pmaxsw %xmm8, %xmm9
movdqa %xmm10, %xmm8
movdqa %xmm11, %xmm10
psubsw %xmm2, %xmm11
pmaxsw %xmm12, %xmm11
pmaxsw %xmm11, %xmm8
movdqa %xmm11, (%rax,%r12)
movdqa %xmm8, (%r15,%r12)
addq $0x10, %r12
cmpq %r12, %r10
jne 0x2ef1cd
movq %r11, %rcx
pslldq $0x2, %xmm8             # xmm8 = zero,zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %r10
pinsrw $0x0, 0x2(%r10,%rax,2), %xmm8
incq %rax
movq %rax, 0x10(%rsp)
movdqa (%r8), %xmm10
paddsw %xmm8, %xmm10
pmaxsw %xmm10, %xmm9
movl $0x6, %ebx
movdqa %xmm9, %xmm10
pslldq $0x2, %xmm9             # xmm9 = zero,zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddsw %xmm5, %xmm9
pmaxsw %xmm10, %xmm9
decl %ebx
jne 0x2ef254
pslldq $0x2, %xmm9             # xmm9 = zero,zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddsw %xmm4, %xmm9
pmaxsw %xmm9, %xmm8
movq %rdx, 0x28(%rsp)
movq %rdx, %r12
xorl %ebx, %ebx
movq 0x8(%rsp), %r14
movq (%rsp), %r10
movq 0x80(%rsp), %r11
movq 0x78(%rsp), %rdx
psubsw %xmm3, %xmm9
psubsw %xmm2, %xmm8
pmaxsw %xmm8, %xmm9
movdqa (%r15,%rbx), %xmm8
pmaxsw %xmm9, %xmm8
movdqa %xmm8, (%r14,%rbx)
movq 0x10(%r13), %r15
movq (%r15), %r15
movq %r13, %rax
movd %xmm8, %r13d
movswl %r13w, %r13d
movl %r13d, (%r15,%r12)
pextrw $0x1, %xmm8, %r13d
addq %r12, %r15
movswl %r13w, %r13d
pextrw $0x2, %xmm8, %r8d
movl %r13d, (%r11,%r15)
movswl %r8w, %r8d
pextrw $0x3, %xmm8, %r13d
movl %r8d, (%rcx,%r15)
movswl %r13w, %r8d
pextrw $0x4, %xmm8, %r13d
movl %r8d, (%rdx,%r15)
movswl %r13w, %r8d
pextrw $0x5, %xmm8, %r13d
movl %r8d, (%rdi,%r15)
movswl %r13w, %r8d
pextrw $0x6, %xmm8, %r13d
movl %r8d, (%rsi,%r15)
movswl %r13w, %r8d
pextrw $0x7, %xmm8, %r13d
movl %r8d, (%rbp,%r15)
movswl %r13w, %r8d
movq %rax, %r13
movl %r8d, (%r9,%r15)
movq 0x38(%rsp), %r8
movq 0x70(%rsp), %r15
pminsw %xmm8, %xmm7
pmaxsw %xmm8, %xmm6
addq $0x10, %rbx
addq %r8, %r12
cmpq %rbx, %r10
jne 0x2ef29d
movq 0x28(%rsp), %rdx
addq $0x4, %rdx
movq 0x10(%rsp), %r10
cmpq 0x88(%rsp), %r10
movq 0x30(%rsp), %rbx
movq 0x58(%rsp), %r12
movq %rcx, %r11
jne 0x2ef15c
movl 0x54(%rsp), %eax
shlq $0x4, %rax
movq 0x8(%rsp), %rbx
movdqa (%rbx,%rax), %xmm2
cmpl $0x6, 0x20(%rsp)
jg 0x2ef3c5
movl 0x50(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl 0x24(%rsp), %edx
movl 0x1c(%rsp), %esi
pslldq $0x2, %xmm2             # xmm2 = zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
decl %ecx
jne 0x2ef3ba
jmp 0x2ef3cd
movl 0x24(%rsp), %edx
movl 0x1c(%rsp), %esi
pcmpgtw %xmm7, %xmm0
pcmpgtw %xmm1, %xmm6
por %xmm0, %xmm6
pmovmskb %xmm6, %eax
testl %eax, %eax
je 0x2ef3ee
orb $0x40, 0xc(%r13)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x2ef3f3
pextrw $0x7, %xmm2, %ecx
movswl %cx, %eax
movl %eax, (%r13)
movl %edx, 0x4(%r13)
movl %esi, 0x8(%r13)
movq %r12, %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x30(%rsp), %rdi
callq 0x2094b5
movq 0x48(%rsp), %rdi
callq 0x2094b5
jmp 0x2ef469
callq 0x1abe71
jmp 0x2ef466
callq 0x1abe4b
jmp 0x2ef466
callq 0x1abe25
jmp 0x2ef466
callq 0x1abdff
jmp 0x2ef466
callq 0x1abdd9
jmp 0x2ef466
callq 0x1abdb3
jmp 0x2ef466
callq 0x1abd8d
jmp 0x2ef466
callq 0x1abd67
xorl %r13d, %r13d
movq %r13, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop