// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_sse41_128_64.c
// Function: parasail_nw_rowcol_scan_profile_sse41_128_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;
    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;
    int64_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    __m128i vZero;
    int64_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->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 = 2; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m128i*)profile->profile64.score;
    vGapO = _mm_set1_epi64x_rpl(open);
    vGapE = _mm_set1_epi64x_rpl(gap);
    NEG_LIMIT = (-open < matrix->min ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm_insert_epi64_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_add_epi64(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi64x_rpl(-segLen*gap), 8));

    /* 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_64 | PARASAIL_FLAG_LANES_2;
#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_int64_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_64_t h;
            __m128i_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;
            }
            _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 < INT64_MIN ? INT64_MIN : tmp;
        }
    }

    {
        __m128i vGapper = _mm_sub_epi64(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_sub_epi64(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, 8);
        vHp = _mm_insert_epi64_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_sub_epi64(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_epi64_rpl(
                    _mm_sub_epi64(vE, vGapE),
                    _mm_sub_epi64(vH, vGapO));
            vHp = _mm_add_epi64(vHp, vW);
            vF = _mm_max_epi64_rpl(vF, _mm_add_epi64(vHt, pvGapper[i]));
            vHt = _mm_max_epi64_rpl(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, 8);
        vHt = _mm_insert_epi64_rpl(vHt, boundary[j+1], 0);
        vF = _mm_max_epi64_rpl(vF, _mm_add_epi64(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 8);
            vFt = _mm_add_epi64(vFt, vSegLenXgap);
            vF = _mm_max_epi64_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 8);
        vF = _mm_add_epi64(vF, vNegInfFront);
        vH = _mm_max_epi64_rpl(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm_load_si128(pvHt+i);
            vF = _mm_max_epi64_rpl(
                    _mm_sub_epi64(vF, vGapE),
                    _mm_sub_epi64(vH, vGapO));
            vH = _mm_max_epi64_rpl(vHt, vF);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm_max_epi64_rpl(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, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm_extract_epi64_rpl (vH, 1);
        }
#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, 8);
        }
        score = (int64_t) _mm_extract_epi64_rpl (vH, 1);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi64_rpl(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 $0xa8, %rsp
movq %rsi, 0x60(%rsp)
testq %rdi, %rdi
je 0x4241e8
movq 0x60(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x4241ef
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x4241f6
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x4241fd
cmpq $0x0, 0x60(%rsp)
je 0x424204
movl %edx, %r12d
testl %edx, %edx
jle 0x42420b
movl %ecx, %r13d
testl %ecx, %ecx
js 0x424212
testl %r8d, %r8d
js 0x424219
movl %r8d, 0x28(%rsp)
leal -0x1(%rdi), %eax
incq %rdi
movq %rdi, %rcx
shrq %rcx
movl %eax, 0x44(%rsp)
cltd
movq %rcx, 0x8(%rsp)
idivl %ecx
movl %eax, %ebp
movl %edx, %r14d
movl %r13d, %r15d
negl %r13d
movq 0x58(%rsp), %rsi
movslq 0x20(%rsi), %rax
movq %r15, %rcx
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
subq %rax, %rbx
cmpl %r13d, %eax
cmovgq %rcx, %rbx
movslq 0x1c(%rsi), %rax
movq %rax, 0x38(%rsp)
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
movl %r12d, %esi
callq 0x209630
testq %rax, %rax
je 0x42421e
movl %r13d, 0x20(%rsp)
movl %r14d, 0x30(%rsp)
movq %rbx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
orl $0x2840401, 0xc(%rax)   # imm = 0x2840401
movl $0x10, %edi
movq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r14
leal 0x1(%r12), %ebx
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2094de
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %r12, 0x18(%rsp)
movq %rax, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r13
movl $0x10, %edi
movq 0x8(%rsp), %rsi
callq 0x2ea474
testq %r14, %r14
sete %cl
cmpq $0x0, 0x10(%rsp)
sete %dl
orb %cl, %dl
testq %r12, %r12
sete %cl
testq %r13, %r13
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x42421e
movq 0x18(%rsp), %rcx
decl %ecx
movl %ecx, 0x40(%rsp)
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movl 0x28(%rsp), %esi
movd %esi, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movq 0x48(%rsp), %rcx
incq %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
subq 0x38(%rsp), %rdx
addq $-0x2, %rdx
movq %rcx, %xmm2
pshufd $0x44, %xmm2, %xmm3     # xmm3 = xmm2[0,1,0,1]
movq %rdx, 0x70(%rsp)
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
movl %esi, %ecx
movslq 0x20(%rsp), %rsi
movl 0x8(%rsp), %r9d
negq %r15
movq %r9, %rdi
imulq %rcx, %rdi
xorl %r8d, %r8d
movq 0x10(%rsp), %rdx
movq %r9, 0x28(%rsp)
movq %rsi, %r9
xorl %r10d, %r10d
movq %r9, 0x90(%rsp,%r10,8)
leaq (%r15,%r9), %r11
movq %r11, 0x80(%rsp,%r10,8)
incq %r10
subq %rdi, %r9
cmpq $0x1, %r10
je 0x423d61
movq %r8, %r9
shlq $0x4, %r9
movaps 0x90(%rsp), %xmm5
movaps %xmm5, (%r13,%r9)
movdqa 0x80(%rsp), %xmm5
movdqa %xmm5, (%r14,%r9)
incq %r8
subq %rcx, %rsi
movq 0x28(%rsp), %r9
cmpq %r9, %r8
jne 0x423d5b
movq $0x0, (%rdx)
movslq 0x20(%rsp), %rsi
movl $0x1, %edi
movq %rsi, (%rdx,%rdi,8)
incq %rdi
subq %rcx, %rsi
cmpq %rdi, %rbx
jne 0x423dc6
pxor %xmm5, %xmm5
psubq %xmm0, %xmm5
movq 0x8(%rsp), %rdx
leal -0x1(%rdx), %ecx
movq %rcx, %rdi
shlq $0x4, %rdi
movq %rax, %rsi
addq %rdi, %rsi
movl %edx, %edi
movdqa %xmm5, (%rsi)
psubq %xmm1, %xmm5
addq $-0x10, %rsi
decl %edi
jg 0x423df4
movl %ecx, %ecx
shlq $0x4, %rcx
addq %r13, %rcx
movq %rcx, 0x38(%rsp)
movl 0x30(%rsp), %ecx
movq %rcx, 0x68(%rsp)
shlq $0x4, %rcx
addq %r13, %rcx
movq %rcx, 0x20(%rsp)
cmpl $0x1, %edx
movl %edx, %r9d
adcl $0x0, %r9d
movq 0x18(%rsp), %rcx
cmpl $0x2, %ecx
movl $0x1, %esi
cmovgel %ecx, %esi
movq %rsi, 0x18(%rsp)
shlq $0x4, %r9
xorl %r15d, %r15d
movslq %edx, %rcx
movq %rcx, 0x30(%rsp)
movdqa %xmm3, %xmm5
movq %r15, %rbx
movq 0x38(%rsp), %rcx
pshufd $0x44, (%rcx), %xmm6    # xmm6 = mem[0,1,0,1]
movq 0x10(%rsp), %rcx
pinsrq $0x0, (%rcx,%r15,8), %xmm6
movq 0x58(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x60(%rsp), %rdx
movzbl (%rdx,%r15), %esi
movslq (%rcx,%rsi,4), %rcx
imulq 0x30(%rsp), %rcx
shlq $0x4, %rcx
addq 0x78(%rsp), %rcx
movdqa %xmm3, %xmm8
psubq (%rax), %xmm8
xorl %r10d, %r10d
movdqa %xmm3, %xmm9
movdqa (%r13,%r10), %xmm7
movdqa (%r14,%r10), %xmm10
psubq %xmm1, %xmm10
movdqa %xmm7, %xmm11
psubq %xmm0, %xmm11
movq %xmm10, %rdi
movq %xmm11, %rsi
cmpq %rsi, %rdi
cmovgq %rdi, %rsi
pextrq $0x1, %xmm10, %rdi
pextrq $0x1, %xmm11, %r11
cmpq %r11, %rdi
cmovgq %rdi, %r11
paddq (%rcx,%r10), %xmm6
paddq (%rax,%r10), %xmm8
movq %xmm9, %r15
movq %xmm8, %rdi
cmpq %rdi, %r15
cmovgq %r15, %rdi
pextrq $0x1, %xmm9, %r15
pextrq $0x1, %xmm8, %r8
cmpq %r8, %r15
cmovgq %r15, %r8
movq %xmm6, %r15
pextrq $0x1, %xmm6, %rdx
movdqa %xmm7, %xmm6
movq %r8, %xmm7
movq %r11, %xmm8
movq %rsi, %xmm10
punpcklqdq %xmm8, %xmm10   # xmm10 = xmm10[0],xmm8[0]
cmpq %r15, %rsi
cmovleq %r15, %rsi
movq %rdi, %xmm9
cmpq %rdx, %r11
cmovleq %rdx, %r11
punpcklqdq %xmm7, %xmm9    # xmm9 = xmm9[0],xmm7[0]
movq %r11, %xmm7
movq %rsi, %xmm8
punpcklqdq %xmm7, %xmm8    # xmm8 = xmm8[0],xmm7[0]
movdqa %xmm10, (%r14,%r10)
movdqa %xmm8, (%r12,%r10)
addq $0x10, %r10
cmpq %r10, %r9
jne 0x423eab
movq 0x10(%rsp), %rcx
movq 0x8(%rcx,%rbx,8), %rcx
movq (%rax), %rdx
addq %rcx, %rdx
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
movq %rdx, %xmm6
pslldq $0x8, %xmm6             # xmm6 = zero,zero,zero,zero,zero,zero,zero,zero,xmm6[0,1,2,3,4,5,6,7]
paddq %xmm2, %xmm6
movq %xmm6, %rdx
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
pextrq $0x1, %xmm6, %rcx
leaq 0x1(%rbx), %r15
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
movq %rcx, %xmm8
movq %rdx, %xmm7
punpcklqdq %xmm8, %xmm7    # xmm7 = xmm7[0],xmm8[0]
xorl %edi, %edi
psubq %xmm1, %xmm6
psubq %xmm0, %xmm7
movq %xmm6, %rcx
movq %xmm7, %rsi
cmpq %rsi, %rcx
cmovgq %rcx, %rsi
pextrq $0x1, %xmm6, %rdx
pextrq $0x1, %xmm7, %rcx
cmpq %rcx, %rdx
cmovgq %rdx, %rcx
movq %rcx, %xmm7
movq %rsi, %xmm6
punpcklqdq %xmm7, %xmm6    # xmm6 = xmm6[0],xmm7[0]
movq (%r12,%rdi), %rdx
movq 0x8(%r12,%rdi), %r8
cmpq %rsi, %rdx
cmovgq %rdx, %rsi
cmpq %rcx, %r8
cmovgq %r8, %rcx
movq %rcx, %xmm8
movq %rsi, %xmm7
punpcklqdq %xmm8, %xmm7    # xmm7 = xmm7[0],xmm8[0]
movdqa %xmm7, (%r13,%rdi)
movq %xmm4, %r10
cmpq %rsi, %r10
cmovgeq %rsi, %r10
pextrq $0x1, %xmm4, %r11
cmpq %rcx, %r11
cmovgeq %rcx, %r11
movq %r11, %xmm8
movq %r10, %xmm4
punpcklqdq %xmm8, %xmm4    # xmm4 = xmm4[0],xmm8[0]
movq %xmm5, %rdx
cmpq %rsi, %rdx
cmovgq %rdx, %rsi
pextrq $0x1, %xmm5, %rdx
cmpq %rcx, %rdx
cmovgq %rdx, %rcx
movq %rcx, %xmm8
movq %rsi, %xmm5
punpcklqdq %xmm8, %xmm5    # xmm5 = xmm5[0],xmm8[0]
addq $0x10, %rdi
cmpq %rdi, %r9
jne 0x423fd7
movq 0x20(%rsp), %rdx
movdqa (%rdx), %xmm6
testl %ebp, %ebp
jg 0x4240b5
pslldq $0x8, %xmm6             # xmm6 = zero,zero,zero,zero,zero,zero,zero,zero,xmm6[0,1,2,3,4,5,6,7]
testl %ebp, %ebp
js 0x4240ac
movq 0x50(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %rdx
pextrd $0x2, %xmm6, (%rdx,%rbx,4)
cmpq 0x18(%rsp), %r15
jne 0x423e59
movq 0x8(%rsp), %r8
cmpl $0x1, %r8d
adcl $0x0, %r8d
movq 0x28(%rsp), %r9
shlq $0x2, %r9
shlq $0x2, %r8
xorl %edi, %edi
movq 0x50(%rsp), %rbx
movdqa (%r13,%rdi,4), %xmm0
movq 0x10(%rbx), %rdx
movq 0x8(%rdx), %rdx
movd %xmm0, (%rdx,%rdi)
addq %rdi, %rdx
pextrd $0x2, %xmm0, (%r9,%rdx)
addq $0x4, %rdi
cmpq %rdi, %r8
jne 0x4240f4
movq 0x68(%rsp), %rdx
shlq $0x4, %rdx
movdqa (%r13,%rdx), %xmm0
testl %ebp, %ebp
jg 0x424139
pslldq $0x8, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
testl %ebp, %ebp
js 0x424130
xorl %edx, %edx
movq 0x48(%rsp), %r8
cmpq %r8, %r10
setle %dl
negq %rdx
xorl %edi, %edi
cmpq %r8, %r11
setle %dil
negq %rdi
movq %rdi, %xmm1
movq %rdx, %xmm2
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
xorl %edx, %edx
movq 0x70(%rsp), %rdi
cmpq %rdi, %rsi
setg %dl
negq %rdx
xorl %esi, %esi
cmpq %rdi, %rcx
setg %sil
negq %rsi
movq %rsi, %xmm1
movq %rdx, %xmm3
punpcklqdq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0]
por %xmm2, %xmm3
pmovmskb %xmm3, %ecx
testl %ecx, %ecx
je 0x4241a5
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x4241b4
pextrq $0x1, %xmm0, %rcx
movl 0x44(%rsp), %edx
movl 0x40(%rsp), %esi
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq 0x10(%rsp), %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x424220
callq 0x1d13ad
jmp 0x42421e
callq 0x1d1387
jmp 0x42421e
callq 0x1d1361
jmp 0x42421e
callq 0x1d133b
jmp 0x42421e
callq 0x1d1315
jmp 0x42421e
callq 0x1d12ef
jmp 0x42421e
callq 0x1d12c9
jmp 0x42421e
callq 0x1d12a3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)