// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_striped_sse2_128_64.c
// Function: parasail_sw_rowcol_striped_profile_sse2_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
#ifdef PARASAIL_ROWCOL
    int32_t offset = 0;
    int32_t position = 0;
#endif
    __m128i* restrict vProfile = NULL;
    __m128i* restrict pvHStore = NULL;
    __m128i* restrict pvHLoad = NULL;
    __m128i* restrict pvHMax = NULL;
    __m128i* restrict pvE = NULL;
    __m128i vGapO;
    __m128i vGapE;
    __m128i vZero;
    __m128i vNegInf;
    int64_t score = 0;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    int64_t maxp = 0;
    /*int64_t stop = 0;*/
    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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 2; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
#ifdef PARASAIL_ROWCOL
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
#endif
    vProfile = (__m128i*)profile->profile64.score;
    vGapO = _mm_set1_epi64x_rpl(open);
    vGapE = _mm_set1_epi64x_rpl(gap);
    vZero = _mm_setzero_si128();
    vNegInf = _mm_set1_epi64x_rpl(NEG_INF);
    score = NEG_INF;
    vMaxH = vNegInf;
    vMaxHUnit = vNegInf;
    maxp = INT64_MAX - (int64_t)(matrix->max+1);
    /*stop = profile->stop == INT32_MAX ?  INT64_MAX : (int64_t)profile->stop;*/

    /* 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_SW | PARASAIL_FLAG_STRIPED
        | 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 */
    pvHStore = parasail_memalign___m128i(16, segLen);
    pvHLoad =  parasail_memalign___m128i(16, segLen);
    pvHMax = parasail_memalign___m128i(16, segLen);
    pvE = parasail_memalign___m128i(16, segLen);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvHMax) return NULL;
    if (!pvE) return NULL;

    /* initialize H and E */
    parasail_memset___m128i(pvHStore, vZero, segLen);
    parasail_memset___m128i(pvE, _mm_set1_epi64x_rpl(-open), segLen);

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        __m128i vF;
        __m128i vH;
        const __m128i* vP = NULL;
        __m128i* pv = NULL;

        /* Initialize F value to 0.  Any errors to vH values will be
         * corrected in the Lazy_F loop. */
        vF = vZero;

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

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

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }
        else {
            /* Swap the 2 H buffers. */
            pv = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }

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

            /* Get max from vH, vE and vF. */
            vH = _mm_max_epi64_rpl(vH, vE);
            vH = _mm_max_epi64_rpl(vH, vF);
            vH = _mm_max_epi64_rpl(vH, vZero);
            /* Save vH values. */
            _mm_store_si128(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
            vMaxH = _mm_max_epi64_rpl(vH, vMaxH);

            /* Update vE value. */
            vH = _mm_sub_epi64(vH, vGapO);
            vE = _mm_sub_epi64(vE, vGapE);
            vE = _mm_max_epi64_rpl(vE, vH);
            _mm_store_si128(pvE + i, vE);

            /* Update vF value. */
            vF = _mm_sub_epi64(vF, vGapE);
            vF = _mm_max_epi64_rpl(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) {
            vF = _mm_slli_si128(vF, 8);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi64_rpl(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
                arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vMaxH = _mm_max_epi64_rpl(vH, vMaxH);
                vH = _mm_sub_epi64(vH, vGapO);
                vF = _mm_sub_epi64(vF, vGapE);
                if (! _mm_movemask_epi8(_mm_cmpgt_epi64_rpl(vF, vH))) goto end;
                /*vF = _mm_max_epi64_rpl(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, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm_extract_epi64_rpl (vH, 1);
        }
#endif

        {
            __m128i vCompare = _mm_cmpgt_epi64_rpl(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi64_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm_set1_epi64x_rpl(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

#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

    if (score == INT64_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = INT64_MAX;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            __m128i *pv = pvHMax;
            pvHMax = pvHStore;
            pvHStore = pv;
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            __m128i *pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pv;
        }
        /* Trace the alignment ending position on read. */
        {
            int64_t *t = (int64_t*)pvHMax;
            int32_t column_len = segLen * segWidth;
            end_query = s1Len - 1;
            for (i = 0; i<column_len; ++i, ++t) {
                if (*t == score) {
                    int32_t temp = i / segWidth + i % segWidth * segLen;
                    if (temp < end_query) {
                        end_query = temp;
                    }
                }
            }
        }
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(pvE);
    parasail_free(pvHMax);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, 0x60(%rsp)
testq %rdi, %rdi
je 0x34d53c
movq 0x60(%rdi), %rax
movq %rax, 0x88(%rsp)
testq %rax, %rax
je 0x34d543
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x34d54a
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x34d551
cmpq $0x0, 0x60(%rsp)
je 0x34d558
movl %edx, %r12d
testl %edx, %edx
jle 0x34d55f
movl %ecx, %ebp
testl %ecx, %ecx
js 0x34d566
testl %r8d, %r8d
js 0x34d56d
movl %r8d, 0x4(%rsp)
movq %rax, %r13
incq %r13
movq %r13, %r14
shrq %r14
decl %eax
movl %eax, 0x24(%rsp)
cltd
idivl %r14d
movl %eax, %r15d
movl %edx, 0x40(%rsp)
movq 0x58(%rsp), %rax
movslq 0x1c(%rax), %rax
movq %rax, 0x38(%rsp)
andl $0x7ffffffe, %r13d      # imm = 0x7FFFFFFE
movl %r13d, %edi
movl %r12d, %esi
callq 0x209630
testq %rax, %rax
je 0x34d572
movq %rax, %rbx
movl %ebp, 0x28(%rsp)
movq %r13, 0x70(%rsp)
movq %r12, 0x48(%rsp)
orl $0x2840804, 0xc(%rax)   # imm = 0x2840804
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %r14, %r12
movq %rax, %r13
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r12, 0x30(%rsp)
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r12
testq %r13, %r13
sete %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
movq %r14, 0x18(%rsp)
testq %r14, %r14
sete %al
testq %r12, %r12
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x34d572
movq $0x0, 0x10(%rsp)
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movd 0x28(%rsp), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0xa0(%rsp)
movd 0x4(%rsp), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x90(%rsp)
movq 0x38(%rsp), %rax
notq %rax
addq %rcx, %rax
movq %rax, 0x38(%rsp)
pxor %xmm0, %xmm0
movq %r13, %rdi
movq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x2ea47d
movl 0x28(%rsp), %eax
negl %eax
cltq
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %r12, %rdi
movq %r14, %rsi
callq 0x2ea47d
movdqa 0x90(%rsp), %xmm7
movdqa 0xa0(%rsp), %xmm6
leal -0x1(%r14), %ecx
movl 0x40(%rsp), %edx
movl 0x48(%rsp), %eax
movq %rax, 0x78(%rsp)
movl %r14d, %edi
movq %rdi, 0x68(%rsp)
shlq $0x4, %rdi
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
movq %rax, 0x8(%rsp)
movdqa 0x2a8c69(%rip), %xmm0   # 0x5f5d40
shlq $0x4, %rcx
movq %rcx, 0x40(%rsp)
movslq %r14d, %rax
movq %rax, 0x80(%rsp)
shlq $0x4, %rdx
movq %rdx, 0x28(%rsp)
xorl %r9d, %r9d
movdqa %xmm0, %xmm1
movq %rbx, 0x50(%rsp)
movq %r13, %r14
movq 0x40(%rsp), %rax
movdqa (%r13,%rax), %xmm3
pslldq $0x8, %xmm3             # xmm3 = zero,zero,zero,zero,zero,zero,zero,zero,xmm3[0,1,2,3,4,5,6,7]
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rsp), %rcx
movzbl (%rcx,%r9), %ecx
movslq (%rax,%rcx,4), %r10
imulq 0x80(%rsp), %r10
shlq $0x4, %r10
addq 0x88(%rsp), %r10
leal -0x2(%r9), %eax
movl %eax, 0x4(%rsp)
cmpl %eax, 0x10(%rsp)
movq %rbp, %r13
cmoveq 0x18(%rsp), %r13
xorl %esi, %esi
pxor %xmm2, %xmm2
paddq (%r10,%rsi), %xmm3
movq %xmm3, %rax
movq (%r12,%rsi), %r8
cmpq %r8, %rax
cmovgq %rax, %r8
movq 0x8(%r12,%rsi), %rcx
pshufd $0xee, %xmm3, %xmm3     # xmm3 = xmm3[2,3,2,3]
movq %xmm3, %rax
cmpq %rcx, %rax
cmovgq %rax, %rcx
movq %xmm2, %rax
cmpq %rax, %r8
jg 0x34d194
movq %rax, %r8
pshufd $0xee, %xmm2, %xmm3     # xmm3 = xmm2[2,3,2,3]
movq %xmm3, %rax
cmpq %rax, %rcx
jg 0x34d1a6
movq %rax, %rcx
testq %r8, %r8
jg 0x34d1ae
xorl %r8d, %r8d
testq %rcx, %rcx
jg 0x34d1b5
xorl %ecx, %ecx
movdqa (%r12,%rsi), %xmm4
movq %r8, %xmm3
movq %rcx, %xmm5
punpcklqdq %xmm5, %xmm3    # xmm3 = xmm3[0],xmm5[0]
movdqa %xmm3, (%r13,%rsi)
movq %xmm1, %rax
cmpq %rax, %r8
jg 0x34d1dd
movq %rax, %r8
pshufd $0xee, %xmm1, %xmm1     # xmm1 = xmm1[2,3,2,3]
movq %xmm1, %rax
cmpq %rax, %rcx
jg 0x34d1ef
movq %rax, %rcx
psubq %xmm6, %xmm3
psubq %xmm7, %xmm4
movq %xmm4, %rbx
movq %xmm3, %rdx
cmpq %rdx, %rbx
jg 0x34d209
movq %rdx, %rbx
pshufd $0xee, %xmm4, %xmm1     # xmm1 = xmm4[2,3,2,3]
movq %xmm1, %r11
pshufd $0xee, %xmm3, %xmm1     # xmm1 = xmm3[2,3,2,3]
movq %xmm1, %rax
cmpq %rax, %r11
jg 0x34d225
movq %rax, %r11
movq %r8, %xmm1
movq %rcx, %xmm3
punpcklqdq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0]
movq %rbx, %xmm3
movq %r11, %xmm4
punpcklqdq %xmm4, %xmm3    # xmm3 = xmm3[0],xmm4[0]
psubq %xmm7, %xmm2
movq %xmm2, %rcx
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
movdqa %xmm3, (%r12,%rsi)
pshufd $0xee, %xmm2, %xmm2     # xmm2 = xmm2[2,3,2,3]
movq %xmm2, %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
movq %rdx, %xmm2
movq %rax, %xmm3
punpcklqdq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0]
movdqa (%r14,%rsi), %xmm3
addq $0x10, %rsi
cmpq %rsi, %rdi
jne 0x34d15b
movl 0x4(%rsp), %eax
cmpl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmoveq %rbp, %rax
movq %rax, 0x18(%rsp)
xorl %esi, %esi
pslldq $0x8, %xmm2             # xmm2 = zero,zero,zero,zero,zero,zero,zero,zero,xmm2[0,1,2,3,4,5,6,7]
xorl %ecx, %ecx
movq %xmm2, %r11
movq (%r13,%rcx), %rax
movq 0x8(%r13,%rcx), %rdx
cmpq %r11, %rax
cmovgq %rax, %r11
pshufd $0xee, %xmm2, %xmm3     # xmm3 = xmm2[2,3,2,3]
movq %xmm3, %r10
cmpq %r10, %rdx
cmovgq %rdx, %r10
movq %r11, %xmm3
movq %r10, %xmm4
punpcklqdq %xmm4, %xmm3    # xmm3 = xmm3[0],xmm4[0]
movdqa %xmm3, (%r13,%rcx)
movq %xmm1, %rax
cmpq %rax, %r11
cmovleq %rax, %r11
pshufd $0xee, %xmm1, %xmm1     # xmm1 = xmm1[2,3,2,3]
movq %xmm1, %rax
cmpq %rax, %r10
cmovleq %rax, %r10
movq %r11, %xmm1
movq %r10, %xmm4
punpcklqdq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0]
psubq %xmm6, %xmm3
psubq %xmm7, %xmm2
movq %xmm2, %rax
movq %xmm3, %rdx
xorl %r8d, %r8d
cmpq %rdx, %rax
setg %r8b
negq %r8
pshufd $0xee, %xmm2, %xmm4     # xmm4 = xmm2[2,3,2,3]
movq %xmm4, %rax
pshufd $0xee, %xmm3, %xmm3     # xmm3 = xmm3[2,3,2,3]
movq %xmm3, %rdx
xorl %ebx, %ebx
cmpq %rdx, %rax
setg %bl
negq %rbx
movq %r8, %xmm3
movq %rbx, %xmm4
punpcklqdq %xmm4, %xmm3    # xmm3 = xmm3[0],xmm4[0]
pmovmskb %xmm3, %eax
testl %eax, %eax
je 0x34d37d
addq $0x10, %rcx
cmpq %rcx, %rdi
jne 0x34d2a8
leal 0x1(%rsi), %eax
testl %esi, %esi
movl %eax, %esi
je 0x34d2a1
movq 0x28(%rsp), %rax
movdqa (%r13,%rax), %xmm2
testl %r15d, %r15d
jle 0x34d395
movq 0x50(%rsp), %rbx
jmp 0x34d3a4
movq 0x50(%rsp), %rbx
pslldq $0x8, %xmm2             # xmm2 = zero,zero,zero,zero,zero,zero,zero,zero,xmm2[0,1,2,3,4,5,6,7]
testl %r15d, %r15d
js 0x34d39a
pshufd $0xee, %xmm2, %xmm2     # xmm2 = xmm2[2,3,2,3]
movq 0x10(%rbx), %rax
movq (%rax), %rax
movd %xmm2, (%rax,%r9,4)
movq %xmm0, %rax
xorl %ecx, %ecx
cmpq %rax, %r11
setg %cl
negq %rcx
pshufd $0xee, %xmm0, %xmm2     # xmm2 = xmm0[2,3,2,3]
movq %xmm2, %rax
xorl %edx, %edx
cmpq %rax, %r10
setg %dl
negq %rdx
movq %rcx, %xmm2
movq %rdx, %xmm3
punpcklqdq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0]
pmovmskb %xmm2, %eax
movb $0x1, %cl
testl %eax, %eax
je 0x34d425
cmpq %r10, %r11
cmovgq %r11, %r10
cmpq 0x38(%rsp), %r10
jle 0x34d40e
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
movq %r10, 0x8(%rsp)
jmp 0x34d425
movq %r10, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %r10, 0x8(%rsp)
movl %r9d, %eax
movq %rax, 0x10(%rsp)
testb %cl, %cl
je 0x34d441
incq %r9
movq %r14, %rbp
cmpq 0x78(%rsp), %r9
jne 0x34d100
movq 0x48(%rsp), %r15
jmp 0x34d444
movl %r9d, %r15d
movq 0x30(%rsp), %rax
cmpl $0x1, %eax
adcl $0x0, %eax
movq 0x68(%rsp), %rsi
shlq $0x2, %rsi
shlq $0x2, %rax
xorl %ecx, %ecx
movdqa (%r13,%rcx,4), %xmm0
movq 0x10(%rbx), %rdx
movq 0x8(%rdx), %rdx
movd %xmm0, (%rdx,%rcx)
addq %rcx, %rdx
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movd %xmm0, (%rsi,%rdx)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x34d45e
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, 0x8(%rsp)
jne 0x34d49d
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
callq 0x20a805
testl %eax, %eax
je 0x34d4c0
xorl %eax, %eax
movq %r14, %rbp
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movq 0x18(%rsp), %r15
xorl %edi, %edi
jmp 0x34d59a
leal -0x1(%r15), %eax
addl $-0x2, %r15d
movq 0x10(%rsp), %rcx
cmpl %r15d, %ecx
movq %r14, %rbp
movq 0x18(%rsp), %r9
cmoveq %r9, %rbp
movq %r9, %r15
cmoveq %r14, %r15
cmpl %eax, %ecx
cmovneq %r13, %r9
cmoveq %r14, %rbp
cmoveq %r13, %r15
cmpl $0x0, 0x70(%rsp)
je 0x34d589
movq 0x30(%rsp), %r8
movl %r8d, %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
addl %eax, %eax
xorl %ecx, %ecx
movl 0x24(%rsp), %edi
movq 0x8(%rsp), %r10
cmpq %r10, (%r15,%rcx,8)
jne 0x34d533
movl %ecx, %edx
shrl %edx
testb $0x1, %cl
movl $0x0, %esi
cmovnel %r8d, %esi
addl %edx, %esi
cmpl %edi, %esi
cmovll %esi, %edi
incq %rcx
cmpl %ecx, %eax
jne 0x34d516
jmp 0x34d592
callq 0x1b64e5
jmp 0x34d572
callq 0x1b64bf
jmp 0x34d572
callq 0x1b6499
jmp 0x34d572
callq 0x1b6473
jmp 0x34d572
callq 0x1b644d
jmp 0x34d572
callq 0x1b6427
jmp 0x34d572
callq 0x1b6401
jmp 0x34d572
callq 0x1b63db
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x24(%rsp), %edi
movq 0x8(%rsp), %r10
movq %r9, %r13
movq 0x10(%rsp), %rax
movl %r10d, (%rbx)
movl %edi, 0x4(%rbx)
movl %eax, 0x8(%rbx)
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
jmp 0x34d574
nopl (%rax)