LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copyrealmatrix(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
void copyrealmatrix(/* Real    */ ae_matrix* src,
     /* Real    */ ae_matrix* dst,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;

    ae_matrix_clear(dst);

    if( src->rows>0&&src->cols>0 )
    {
        ae_matrix_set_length(dst, src->rows, src->cols, _state);
        for(i=0; i<=src->rows-1; i++)
        {
            for(j=0; j<=src->cols-1; j++)
            {
                dst->ptr.pp_double[i][j] = src->ptr.pp_double[i][j];
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3bdd0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jle 0x1fcd4
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x1fcd4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
callq 0x3bc30
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x1fcd2
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x1fcbf
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1fc6a
jmp 0x1fcc1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1fc4e
jmp 0x1fcd4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::recsearch(alglib_impl::ae_vector*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
ae_int_t recsearch(/* Integer */ ae_vector* a,
     ae_int_t nrec,
     ae_int_t nheader,
     ae_int_t i0,
     ae_int_t i1,
     /* Integer */ ae_vector* b,
     ae_state *_state)
{
    ae_int_t mididx;
    ae_int_t cflag;
    ae_int_t k;
    ae_int_t offs;
    ae_int_t result;


    result = -1;
    for(;;)
    {
        if( i0>=i1 )
        {
            break;
        }
        mididx = (i0+i1)/2;
        offs = nrec*mididx;
        cflag = 0;
        for(k=0; k<=nheader-1; k++)
        {
            if( a->ptr.p_int[offs+k]<b->ptr.p_int[k] )
            {
                cflag = -1;
                break;
            }
            if( a->ptr.p_int[offs+k]>b->ptr.p_int[k] )
            {
                cflag = 1;
                break;
            }
        }
        if( cflag==0 )
        {
            result = mididx;
            return result;
        }
        if( cflag<0 )
        {
            i0 = mididx+1;
        }
        else
        {
            i1 = mididx;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $-0x1, -0x60(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0x1fd17
jmp 0x1fe09
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
imulq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x1fdce
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x58(%rbp), %rcx
addq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x50(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x1fd8b
movq $-0x1, -0x48(%rbp)
jmp 0x1fdce
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x58(%rbp), %rcx
addq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x50(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jle 0x1fdbb
movq $0x1, -0x48(%rbp)
jmp 0x1fdce
jmp 0x1fdbd
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x1fd4a
cmpq $0x0, -0x48(%rbp)
jne 0x1fde7
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1fe11
cmpq $0x0, -0x48(%rbp)
jge 0x1fdfc
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1fe04
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1fd08
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_apbuffers_clear(alglib_impl::apbuffers*)
void _apbuffers_clear(apbuffers* p)
{
    ae_vector_clear(&p->ia0);
    ae_vector_clear(&p->ia1);
    ae_vector_clear(&p->ia2);
    ae_vector_clear(&p->ia3);
    ae_vector_clear(&p->ra0);
    ae_vector_clear(&p->ra1);
    ae_vector_clear(&p->ra2);
    ae_vector_clear(&p->ra3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
callq 0x3b6f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::tagsort(alglib_impl::ae_vector*, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void tagsort(/* Real    */ ae_vector* a,
     ae_int_t n,
     /* Integer */ ae_vector* p1,
     /* Integer */ ae_vector* p2,
     ae_state *_state)
{
    ae_frame _frame_block;
    apbuffers buf;

    ae_frame_make(_state, &_frame_block);
    ae_vector_clear(p1);
    ae_vector_clear(p2);
    _apbuffers_init(&buf, _state, ae_true);

    tagsortbuf(a, n, p1, p2, &buf, _state);
    ae_frame_leave(_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3b0f0
movq -0x18(%rbp), %rdi
callq 0x3b6f0
movq -0x20(%rbp), %rdi
callq 0x3b6f0
movq -0x28(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
movl $0x1, %edx
callq 0x1fe20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq -0x1c0(%rbp), %r8
callq 0x202a0
movq -0x28(%rbp), %rdi
callq 0x3b030
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::tagheappopi(alglib_impl::ae_vector*, alglib_impl::ae_vector*, long*, alglib_impl::ae_state*)
void tagheappopi(/* Real    */ ae_vector* a,
     /* Integer */ ae_vector* b,
     ae_int_t* n,
     ae_state *_state)
{
    double va;
    ae_int_t vb;


    if( *n<1 )
    {
        return;
    }
    
    /*
     * N=1 is a special case
     */
    if( *n==1 )
    {
        *n = 0;
        return;
    }
    
    /*
     * swap top element and last element,
     * then reorder heap
     */
    va = a->ptr.p_double[*n-1];
    vb = b->ptr.p_int[*n-1];
    a->ptr.p_double[*n-1] = a->ptr.p_double[0];
    b->ptr.p_int[*n-1] = b->ptr.p_int[0];
    *n = *n-1;
    tagheapreplacetopi(a, b, *n, va, vb, _state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x1, (%rax)
jge 0x21f97
jmp 0x22062
movq -0x18(%rbp), %rax
cmpq $0x1, (%rax)
jne 0x21fb1
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x22062
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x21d30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::vectoridxabsmax(alglib_impl::ae_vector*, long, long, alglib_impl::ae_state*)
ae_int_t vectoridxabsmax(/* Real    */ ae_vector* x,
     ae_int_t i1,
     ae_int_t i2,
     ae_state *_state)
{
    ae_int_t i;
    double a;
    ae_int_t result;


    result = i1;
    a = ae_fabs(x->ptr.p_double[result], _state);
    for(i=i1+1; i<=i2; i++)
    {
        if( ae_fp_greater(ae_fabs(x->ptr.p_double[i], _state),ae_fabs(x->ptr.p_double[result], _state)) )
        {
            result = i;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rdi
callq 0x3c820
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x230e9
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rdi
callq 0x3c820
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rdi
callq 0x3c820
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
callq 0x3c4c0
testb $0x1, %al
jne 0x230d1
jmp 0x230d9
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x230db
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2307b
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::columnidxabsmax(alglib_impl::ae_matrix*, long, long, long, alglib_impl::ae_state*)
ae_int_t columnidxabsmax(/* Real    */ ae_matrix* x,
     ae_int_t i1,
     ae_int_t i2,
     ae_int_t j,
     ae_state *_state)
{
    ae_int_t i;
    double a;
    ae_int_t result;


    result = i1;
    a = ae_fabs(x->ptr.pp_double[result][j], _state);
    for(i=i1+1; i<=i2; i++)
    {
        if( ae_fp_greater(ae_fabs(x->ptr.pp_double[i][j], _state),ae_fabs(x->ptr.pp_double[result][j], _state)) )
        {
            result = i;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rdi
callq 0x3c820
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x231d5
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rdi
callq 0x3c820
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rdi
callq 0x3c820
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
callq 0x3c4c0
testb $0x1, %al
jne 0x231bd
jmp 0x231c5
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x231c7
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x23157
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::rowidxabsmax(alglib_impl::ae_matrix*, long, long, long, alglib_impl::ae_state*)
ae_int_t rowidxabsmax(/* Real    */ ae_matrix* x,
     ae_int_t j1,
     ae_int_t j2,
     ae_int_t i,
     ae_state *_state)
{
    ae_int_t j;
    double a;
    ae_int_t result;


    result = j1;
    a = ae_fabs(x->ptr.pp_double[i][result], _state);
    for(j=j1+1; j<=j2; j++)
    {
        if( ae_fp_greater(ae_fabs(x->ptr.pp_double[i][j], _state),ae_fabs(x->ptr.pp_double[i][result], _state)) )
        {
            result = j;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rdi
callq 0x3c820
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x232b5
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rdi
callq 0x3c820
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rdi
callq 0x3c820
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
callq 0x3c4c0
testb $0x1, %al
jne 0x2329d
jmp 0x232a5
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x232a7
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x23237
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::upperhessenberg1norm(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
double upperhessenberg1norm(/* Real    */ ae_matrix* a,
     ae_int_t i1,
     ae_int_t i2,
     ae_int_t j1,
     ae_int_t j2,
     /* Real    */ ae_vector* work,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    double result;


    ae_assert(i2-i1==j2-j1, "UpperHessenberg1Norm: I2-I1<>J2-J1!", _state);
    for(j=j1; j<=j2; j++)
    {
        work->ptr.p_double[j] = 0;
    }
    for(i=i1; i<=i2; i++)
    {
        for(j=ae_maxint(j1, j1+i-i1-1, _state); j<=j2; j++)
        {
            work->ptr.p_double[j] = work->ptr.p_double[j]+ae_fabs(a->ptr.pp_double[i][j], _state);
        }
    }
    result = 0;
    for(j=j1; j<=j2; j++)
    {
        result = ae_maxreal(result, work->ptr.p_double[j], _state);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
sete %al
movq 0x10(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x34913(%rip), %rsi     # 0x57c1e
callq 0x3b240
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x23344
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x23318
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x233fb
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x38(%rbp), %rsi
subq -0x10(%rbp), %rsi
subq $0x1, %rsi
movq 0x10(%rbp), %rdx
callq 0x3c9f0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x233e8
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rbp), %rdi
callq 0x3c820
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2337b
jmp 0x233ea
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2334c
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x23447
movsd -0x48(%rbp), %xmm0
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x10(%rbp), %rdi
callq 0x3ca70
movsd %xmm0, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2340b
movsd -0x48(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copymatrix(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_state*)
void copymatrix(/* Real    */ ae_matrix* a,
     ae_int_t is1,
     ae_int_t is2,
     ae_int_t js1,
     ae_int_t js2,
     /* Real    */ ae_matrix* b,
     ae_int_t id1,
     ae_int_t id2,
     ae_int_t jd1,
     ae_int_t jd2,
     ae_state *_state)
{
    ae_int_t isrc;
    ae_int_t idst;


    if( is1>is2||js1>js2 )
    {
        return;
    }
    ae_assert(is2-is1==id2-id1, "CopyMatrix: different sizes!", _state);
    ae_assert(js2-js1==jd2-jd1, "CopyMatrix: different sizes!", _state);
    for(isrc=is1; isrc<=is2; isrc++)
    {
        idst = isrc-is1+id1;
        ae_v_move(&b->ptr.pp_double[idst][jd1], 1, &a->ptr.pp_double[isrc][js1], 1, ae_v_len(jd1,jd2));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x234a8
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x234ad
jmp 0x2359f
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq 0x18(%rbp), %rcx
subq 0x10(%rbp), %rcx
cmpq %rcx, %rax
sete %al
movq 0x30(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x3476e(%rip), %rsi     # 0x57c42
callq 0x3b240
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
movq 0x28(%rbp), %rcx
subq 0x20(%rbp), %rcx
cmpq %rcx, %rax
sete %al
movq 0x30(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x34742(%rip), %rsi     # 0x57c42
callq 0x3b240
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x2359f
movq -0x38(%rbp), %rax
subq -0x10(%rbp), %rax
addq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq 0x20(%rbp), %rdi
movq 0x28(%rbp), %rsi
callq 0x42370
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41b10
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2350d
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copyandtranspose(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_state*)
void copyandtranspose(/* Real    */ ae_matrix* a,
     ae_int_t is1,
     ae_int_t is2,
     ae_int_t js1,
     ae_int_t js2,
     /* Real    */ ae_matrix* b,
     ae_int_t id1,
     ae_int_t id2,
     ae_int_t jd1,
     ae_int_t jd2,
     ae_state *_state)
{
    ae_int_t isrc;
    ae_int_t jdst;


    if( is1>is2||js1>js2 )
    {
        return;
    }
    ae_assert(is2-is1==jd2-jd1, "CopyAndTranspose: different sizes!", _state);
    ae_assert(js2-js1==id2-id1, "CopyAndTranspose: different sizes!", _state);
    for(isrc=is1; isrc<=is2; isrc++)
    {
        jdst = isrc-is1+jd1;
        ae_v_move(&b->ptr.pp_double[id1][jdst], b->stride, &a->ptr.pp_double[isrc][js1], 1, ae_v_len(id1,id2));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x23818
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x2381d
jmp 0x2391c
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq 0x28(%rbp), %rcx
subq 0x20(%rbp), %rcx
cmpq %rcx, %rax
sete %al
movq 0x30(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x34449(%rip), %rsi     # 0x57c8d
callq 0x3b240
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
movq 0x18(%rbp), %rcx
subq 0x10(%rbp), %rcx
cmpq %rcx, %rax
sete %al
movq 0x30(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x3441d(%rip), %rsi     # 0x57c8d
callq 0x3b240
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x2391c
movq -0x38(%rbp), %rax
subq -0x10(%rbp), %rax
addq 0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rdi
movq 0x18(%rbp), %rsi
callq 0x42370
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
callq 0x41b10
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2387d
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::applyreflectionfromtheright(alglib_impl::ae_matrix*, double, alglib_impl::ae_vector*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void applyreflectionfromtheright(/* Real    */ ae_matrix* c,
     double tau,
     /* Real    */ ae_vector* v,
     ae_int_t m1,
     ae_int_t m2,
     ae_int_t n1,
     ae_int_t n2,
     /* Real    */ ae_vector* work,
     ae_state *_state)
{
    double t;
    ae_int_t i;
    ae_int_t vm;


    if( (ae_fp_eq(tau,0)||n1>n2)||m1>m2 )
    {
        return;
    }
    vm = n2-n1+1;
    for(i=m1; i<=m2; i++)
    {
        t = ae_v_dotproduct(&c->ptr.pp_double[i][n1], 1, &v->ptr.p_double[1], 1, ae_v_len(n1,n2));
        t = t*tau;
        ae_v_subd(&c->ptr.pp_double[i][n1], 1, &v->ptr.p_double[1], 1, ae_v_len(n1,n2), t);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c3d0
testb $0x1, %al
jne 0x25dc2
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jg 0x25dc2
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x25dc7
jmp 0x25ebf
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x25ebf
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x42370
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41940
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x42370
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq %rax, %r8
movsd -0x40(%rbp), %xmm0
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x42270
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x25ddf
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::upperhessenbergschurdecomposition(alglib_impl::ae_matrix*, long, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
ae_bool upperhessenbergschurdecomposition(/* Real    */ ae_matrix* h,
     ae_int_t n,
     /* Real    */ ae_matrix* s,
     ae_state *_state)
{
    ae_frame _frame_block;
    ae_vector wi;
    ae_vector wr;
    ae_int_t info;
    ae_bool result;

    ae_frame_make(_state, &_frame_block);
    ae_matrix_clear(s);
    ae_vector_init(&wi, 0, DT_REAL, _state, ae_true);
    ae_vector_init(&wr, 0, DT_REAL, _state, ae_true);

    internalschurdecomposition(h, n, 1, 2, &wr, &wi, s, &info, _state);
    result = info==0;
    ae_frame_leave(_state);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3b0f0
movq -0x18(%rbp), %rdi
callq 0x3bdd0
movq -0x20(%rbp), %rcx
leaq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x3, %edx
movl $0x1, %r8d
callq 0x3b400
movq -0x20(%rbp), %rcx
leaq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x3, %edx
movl $0x1, %r8d
callq 0x3b400
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %r11
movq -0x20(%rbp), %rax
movl $0x1, %edx
movl $0x2, %ecx
leaq -0x98(%rbp), %r8
leaq -0x68(%rbp), %r9
leaq -0xa0(%rbp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x28b90
cmpq $0x0, -0xa0(%rbp)
sete %al
andb $0x1, %al
movb %al, -0xa1(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3b030
movb -0xa1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::xdot(alglib_impl::ae_vector*, alglib_impl::ae_vector*, long, alglib_impl::ae_vector*, double*, double*, alglib_impl::ae_state*)
void xdot(/* Real    */ ae_vector* a,
     /* Real    */ ae_vector* b,
     ae_int_t n,
     /* Real    */ ae_vector* temp,
     double* r,
     double* rerr,
     ae_state *_state)
{
    ae_int_t i;
    double mx;
    double v;

    *r = 0;
    *rerr = 0;

    
    /*
     * special cases:
     * * N=0
     */
    if( n==0 )
    {
        *r = 0;
        *rerr = 0;
        return;
    }
    mx = 0;
    for(i=0; i<=n-1; i++)
    {
        v = a->ptr.p_double[i]*b->ptr.p_double[i];
        temp->ptr.p_double[i] = v;
        mx = ae_maxreal(mx, ae_fabs(v, _state), _state);
    }
    if( ae_fp_eq(mx,0) )
    {
        *r = 0;
        *rerr = 0;
        return;
    }
    xblas_xsum(temp, mx, n, r, rerr, _state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x30bec
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x30cd2
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x30c89
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
movq 0x10(%rbp), %rdi
callq 0x3c820
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
movq 0x10(%rbp), %rdi
callq 0x3ca70
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x30bfc
movsd -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c3d0
testb $0x1, %al
jne 0x30c9c
jmp 0x30cb4
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x30cd2
movq -0x20(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x30ce0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::linminnormalized(alglib_impl::ae_vector*, double*, long, alglib_impl::ae_state*)
void linminnormalized(/* Real    */ ae_vector* d,
     double* stp,
     ae_int_t n,
     ae_state *_state)
{
    double mx;
    double s;
    ae_int_t i;


    
    /*
     * first, scale D to avoid underflow/overflow durng squaring
     */
    mx = 0;
    for(i=0; i<=n-1; i++)
    {
        mx = ae_maxreal(mx, ae_fabs(d->ptr.p_double[i], _state), _state);
    }
    if( ae_fp_eq(mx,0) )
    {
        return;
    }
    s = 1/mx;
    ae_v_muld(&d->ptr.p_double[0], 1, ae_v_len(0,n-1), s);
    *stp = *stp/s;
    
    /*
     * normalize D
     */
    s = ae_v_dotproduct(&d->ptr.p_double[0], 1, &d->ptr.p_double[0], 1, ae_v_len(0,n-1));
    s = 1/ae_sqrt(s, _state);
    ae_v_muld(&d->ptr.p_double[0], 1, ae_v_len(0,n-1), s);
    *stp = *stp/s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x315d1
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rdi
callq 0x3c820
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0x3ca70
movsd %xmm0, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x31578
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c3d0
testb $0x1, %al
jne 0x315e4
jmp 0x315e9
jmp 0x316f3
movsd 0x23a17(%rip), %xmm0    # 0x55008
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0x60(%rbp), %rdi
movq %rax, %rdx
movsd -0x30(%rbp), %xmm0
movl $0x1, %esi
callq 0x422d0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
divsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41940
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0x3c890
movaps %xmm0, %xmm1
movsd 0x23966(%rip), %xmm0    # 0x55008
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movsd -0x30(%rbp), %xmm0
movl $0x1, %esi
callq 0x422d0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
divsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_armijostate_init(alglib_impl::armijostate*, alglib_impl::ae_state*, bool)
ae_bool _armijostate_init(armijostate* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->x, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->xbase, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->s, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !_rcommstate_init(&p->rstate, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
xorl %edx, %edx
movl %edx, %esi
movl $0x3, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x340d7
movb $0x0, -0x1(%rbp)
jmp 0x3415b
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
xorl %edx, %edx
movl %edx, %esi
movl $0x3, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x34104
movb $0x0, -0x1(%rbp)
jmp 0x3415b
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
xorl %edx, %edx
movl %edx, %esi
movl $0x3, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x34131
movb $0x0, -0x1(%rbp)
jmp 0x3415b
movq -0x10(%rbp), %rdi
addq $0xd8, %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x42390
testb $0x1, %al
jne 0x34157
movb $0x0, -0x1(%rbp)
jmp 0x3415b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_armijostate_init_copy(alglib_impl::armijostate*, alglib_impl::armijostate*, alglib_impl::ae_state*, bool)
ae_bool _armijostate_init_copy(armijostate* dst, armijostate* src, ae_state *_state, ae_bool make_automatic)
{
    dst->needf = src->needf;
    if( !ae_vector_init_copy(&dst->x, &src->x, _state, make_automatic) )
        return ae_false;
    dst->f = src->f;
    dst->n = src->n;
    if( !ae_vector_init_copy(&dst->xbase, &src->xbase, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->s, &src->s, _state, make_automatic) )
        return ae_false;
    dst->stplen = src->stplen;
    dst->fcur = src->fcur;
    dst->stpmax = src->stpmax;
    dst->fmax = src->fmax;
    dst->nfev = src->nfev;
    dst->info = src->info;
    if( !_rcommstate_init_copy(&dst->rstate, &src->rstate, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x341c8
movb $0x0, -0x1(%rbp)
jmp 0x34305
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x34218
movb $0x0, -0x1(%rbp)
jmp 0x34305
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x34246
movb $0x0, -0x1(%rbp)
jmp 0x34305
movq -0x18(%rbp), %rax
movsd 0xa8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0xa8(%rax)
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0xb0(%rax)
movq -0x18(%rbp), %rax
movsd 0xb8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0xb8(%rax)
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x10(%rbp), %rdi
addq $0xd8, %rdi
movq -0x18(%rbp), %rsi
addq $0xd8, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x42470
testb $0x1, %al
jne 0x34301
movb $0x0, -0x1(%rbp)
jmp 0x34305
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_armijostate_clear(alglib_impl::armijostate*)
void _armijostate_clear(armijostate* p)
{
    ae_vector_clear(&p->x);
    ae_vector_clear(&p->xbase);
    ae_vector_clear(&p->s);
    _rcommstate_clear(&p->rstate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0xd8, %rdi
callq 0x42560
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::trimfunction(double*, alglib_impl::ae_vector*, long, double, alglib_impl::ae_state*)
void trimfunction(double* f,
     /* Real    */ ae_vector* g,
     ae_int_t n,
     double threshold,
     ae_state *_state)
{
    ae_int_t i;


    if( ae_fp_greater_eq(*f,threshold) )
    {
        *f = threshold;
        for(i=0; i<=n-1; i++)
        {
            g->ptr.p_double[i] = 0.0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x343f5
jmp 0x3443f
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x3443d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3440a
jmp 0x3443f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_ftplan_clear(alglib_impl::ftplan*)
void _ftplan_clear(ftplan* p)
{
    ae_vector_clear(&p->plan);
    ae_vector_clear(&p->precomputed);
    ae_vector_clear(&p->tmpbuf);
    ae_vector_clear(&p->stackbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0x3b6f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasefactorize(long, long, long*, long*, alglib_impl::ae_state*)
void ftbasefactorize(ae_int_t n,
     ae_int_t tasktype,
     ae_int_t* n1,
     ae_int_t* n2,
     ae_state *_state)
{
    ae_int_t j;

    *n1 = 0;
    *n2 = 0;

    *n1 = 0;
    *n2 = 0;
    
    /*
     * try to find good codelet
     */
    if( *n1*(*n2)!=n )
    {
        for(j=ftbase_ftbasecodeletrecommended; j>=2; j--)
        {
            if( n%j==0 )
            {
                *n1 = j;
                *n2 = n/j;
                break;
            }
        }
    }
    
    /*
     * try to factorize N
     */
    if( *n1*(*n2)!=n )
    {
        for(j=ftbase_ftbasecodeletrecommended+1; j<=n-1; j++)
        {
            if( n%j==0 )
            {
                *n1 = j;
                *n2 = n/j;
                break;
            }
        }
    }
    
    /*
     * looks like N is prime :(
     */
    if( *n1*(*n2)!=n )
    {
        *n1 = 1;
        *n2 = n;
    }
    
    /*
     * normalize
     */
    if( *n2==1&&*n1!=1 )
    {
        *n2 = *n1;
        *n1 = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
imulq (%rcx), %rax
cmpq -0x8(%rbp), %rax
je 0x38b3e
movq 0x2c880(%rip), %rax     # 0x65370
movq %rax, -0x30(%rbp)
cmpq $0x2, -0x30(%rbp)
jl 0x38b3c
movq -0x8(%rbp), %rax
cqto
idivq -0x30(%rbp)
cmpq $0x0, %rdx
jne 0x38b2c
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cqto
idivq -0x30(%rbp)
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x38b3c
jmp 0x38b2e
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x38af4
jmp 0x38b3e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
imulq (%rcx), %rax
cmpq -0x8(%rbp), %rax
je 0x38bb6
movq 0x2c816(%rip), %rax     # 0x65370
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x38bb4
movq -0x8(%rbp), %rax
cqto
idivq -0x30(%rbp)
cmpq $0x0, %rdx
jne 0x38ba4
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cqto
idivq -0x30(%rbp)
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x38bb4
jmp 0x38ba6
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x38b62
jmp 0x38bb6
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
imulq (%rcx), %rax
cmpq -0x8(%rbp), %rax
je 0x38be1
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x1, (%rax)
jne 0x38c0e
movq -0x18(%rbp), %rax
cmpq $0x1, (%rax)
je 0x38c0e
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbaseissmooth(long, alglib_impl::ae_state*)
ae_bool ftbaseissmooth(ae_int_t n, ae_state *_state)
{
    ae_int_t i;
    ae_bool result;


    for(i=2; i<=ftbase_ftbasemaxsmoothfactor; i++)
    {
        while(n%i==0)
        {
            n = n/i;
        }
    }
    result = n==1;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x2, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x2c749(%rip), %rax     # 0x65378
jg 0x38c63
jmp 0x38c33
movq -0x8(%rbp), %rax
cqto
idivq -0x18(%rbp)
cmpq $0x0, %rdx
jne 0x38c53
movq -0x8(%rbp), %rax
cqto
idivq -0x18(%rbp)
movq %rax, -0x8(%rbp)
jmp 0x38c33
jmp 0x38c55
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x38c24
cmpq $0x1, -0x8(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasefindsmooth(long, alglib_impl::ae_state*)
ae_int_t ftbasefindsmooth(ae_int_t n, ae_state *_state)
{
    ae_int_t best;
    ae_int_t result;


    best = 2;
    while(best<n)
    {
        best = 2*best;
    }
    ftbase_ftbasefindsmoothrec(n, 1, 2, &best, _state);
    result = best;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x2, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x38caf
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0x38c98
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movl $0x1, %esi
movl $0x2, %edx
leaq -0x18(%rbp), %rcx
callq 0x38ce0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbase_ftbasefindsmoothrec(long, long, long, long*, alglib_impl::ae_state*)
static void ftbase_ftbasefindsmoothrec(ae_int_t n,
     ae_int_t seed,
     ae_int_t leastfactor,
     ae_int_t* best,
     ae_state *_state)
{


    ae_assert(ftbase_ftbasemaxsmoothfactor<=5, "FTBaseFindSmoothRec: internal error!", _state);
    if( seed>=n )
    {
        *best = ae_minint(*best, seed, _state);
        return;
    }
    if( leastfactor<=2 )
    {
        ftbase_ftbasefindsmoothrec(n, seed*2, 2, best, _state);
    }
    if( leastfactor<=3 )
    {
        ftbase_ftbasefindsmoothrec(n, seed*3, 3, best, _state);
    }
    if( leastfactor<=5 )
    {
        ftbase_ftbasefindsmoothrec(n, seed*5, 5, best, _state);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x5, 0x2c674(%rip)     # 0x65378
setle %al
movq -0x28(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x1f204(%rip), %rsi     # 0x57f1c
callq 0x3b240
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jl 0x38d47
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3ca30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x38daf
cmpq $0x2, -0x18(%rbp)
jg 0x38d6b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
shlq %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x2, %edx
callq 0x38ce0
cmpq $0x3, -0x18(%rbp)
jg 0x38d8d
movq -0x8(%rbp), %rdi
imulq $0x3, -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x3, %edx
callq 0x38ce0
cmpq $0x5, -0x18(%rbp)
jg 0x38daf
movq -0x8(%rbp), %rdi
imulq $0x5, -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x5, %edx
callq 0x38ce0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasefindsmootheven(long, alglib_impl::ae_state*)
ae_int_t ftbasefindsmootheven(ae_int_t n, ae_state *_state)
{
    ae_int_t best;
    ae_int_t result;


    best = 2;
    while(best<n)
    {
        best = 2*best;
    }
    ftbase_ftbasefindsmoothrec(n, 2, 2, &best, _state);
    result = best;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x2, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x38def
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0x38dd8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movl $0x2, %edx
leaq -0x18(%rbp), %rcx
movq %rdx, %rsi
callq 0x38ce0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)