LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::inplacetranspose(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void inplacetranspose(/* 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;
    ae_int_t ips;
    ae_int_t jps;
    ae_int_t l;


    if( i1>i2||j1>j2 )
    {
        return;
    }
    ae_assert(i1-i2==j1-j2, "InplaceTranspose error: incorrect array size!", _state);
    for(i=i1; i<=i2-1; i++)
    {
        j = j1+i-i1;
        ips = i+1;
        jps = j1+ips-i1;
        l = i2-i;
        ae_v_move(&work->ptr.p_double[1], 1, &a->ptr.pp_double[ips][j], a->stride, ae_v_len(1,l));
        ae_v_move(&a->ptr.pp_double[ips][j], a->stride, &a->ptr.pp_double[i][jps], 1, ae_v_len(ips,i2));
        ae_v_move(&a->ptr.pp_double[i][jps], 1, &work->ptr.p_double[1], 1, ae_v_len(jps,j2));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x30(%rsp)
movq %rsi, %rbx
movq %rsi, %rax
movq %rdx, 0x10(%rsp)
subq %rdx, %rax
setg %dl
movq %rcx, %r9
movq %r8, 0x40(%rsp)
subq %r8, %r9
setg %sil
orb %dl, %sil
jne 0x16d92
movq %rdi, %rbp
movq 0x80(%rsp), %rdx
xorl %edi, %edi
cmpq %r9, %rax
sete %dil
leaq 0x20160(%rip), %rsi     # 0x36d8b
movq %rcx, %r12
callq 0x2581c
cmpq 0x10(%rsp), %rbx
jge 0x16d92
leaq (,%rbx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
subq %rbx, %rax
leaq 0x1(%r12), %rcx
movq %rcx, 0x18(%rsp)
shlq $0x3, %r12
incq %rbx
movq %rbx, 0x28(%rsp)
xorl %r13d, %r13d
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rbx
addq $0x8, %rbx
movq 0x38(%rbp), %rax
movq 0x20(%rsp), %r14
addq %r14, %rax
movq 0x8(%r13,%rax), %r15
addq %r12, %r15
addq %r13, %r15
movq 0x10(%rbp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
movq 0x38(%rsp), %rsi
callq 0x2923f
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
movq 0x8(%rsp), %rcx
movq %rax, %r8
callq 0x28ecd
movq 0x38(%rbp), %rax
addq %r14, %rax
movq 0x8(%r13,%rax), %rbx
addq %r12, %rbx
addq %r13, %rbx
movq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rsp)
movq (%r13,%rax), %rax
addq %r12, %rax
leaq (%rax,%r13), %r15
addq $0x8, %r15
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x2923f
movl $0x1, %ecx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0x28ecd
movq 0x38(%rbp), %rax
addq 0x20(%rsp), %rax
movq (%r13,%rax), %rax
addq %r12, %rax
addq %r13, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %r15
addq $0x8, %r15
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
callq 0x2923f
movl $0x1, %esi
movl $0x1, %ecx
movq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %rax, %r8
callq 0x28ecd
movq 0x38(%rsp), %rax
addq $0x8, %r13
incq %rbx
movq %rbx, 0x18(%rsp)
incq %r14
movq %r14, 0x28(%rsp)
decq %rax
jne 0x16c6c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rsi, %r12
movq %rdx, (%rsp)
movq %rdx, %rax
subq %rsi, %rax
setl %sil
movq %rcx, 0x8(%rsp)
subq %rcx, %r13
setl %dl
orb %sil, %dl
jne 0x16e9a
movq %r9, %rbx
movq %rdi, %r15
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %rbp
movq 0x58(%rsp), %r14
subq %rbp, %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
leaq 0x1ffb5(%rip), %rsi     # 0x36db9
callq 0x2581c
movq %r14, %rax
subq 0x50(%rsp), %rax
xorl %edi, %edi
cmpq %rax, %r13
sete %dil
leaq 0x1ff98(%rip), %rsi     # 0x36db9
movq 0x70(%rsp), %rdx
callq 0x2581c
incq (%rsp)
shlq $0x3, %rbp
shlq $0x3, 0x8(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rbx), %rax
movq 0x50(%rsp), %rdi
movq (%rax,%rdi,8), %r14
addq %rbp, %r14
movq 0x38(%r15), %rax
movq %rbx, %r13
movq %r15, %rbx
movq (%rax,%r12,8), %r15
addq 0x8(%rsp), %r15
movq 0x58(%rsp), %rsi
callq 0x2923f
movl $0x1, %ecx
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %rbx, %r15
movq %r13, %rbx
movq %rax, %r8
callq 0x28ecd
incq %r12
addq $0x8, %rbp
cmpq %r12, (%rsp)
jne 0x16e39
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x28(%rsp)
movq %rdi, %r13
xorps %xmm1, %xmm1
movsd %xmm0, 0x20(%rsp)
callq 0x262ba
cmpq %r15, %r12
jg 0x18bd9
movq %rbx, %r14
cmpq %rbx, %rbp
jg 0x18bd9
testb %al, %al
jne 0x18bd9
incq %r15
leaq (,%rbp,8), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x18(%rsp)
movq %r13, 0x10(%rsp)
movq 0x38(%r13), %rax
movq (%rax,%r12,8), %r15
addq 0x8(%rsp), %r15
movq 0x28(%rsp), %r13
movq 0x28(%r13), %rbx
addq $0x8, %rbx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2923f
movl $0x1, %esi
movl $0x1, %ecx
movq %r15, %rdi
movq %rbx, %rdx
movq %rax, %r8
callq 0x28ddc
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax,%r12,8), %rbx
addq 0x8(%rsp), %rbx
movq 0x28(%r13), %r15
movq 0x10(%rsp), %r13
addq $0x8, %r15
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2923f
movl $0x1, %esi
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rdx
movq 0x18(%rsp), %r15
movq %rax, %r8
movsd 0x30(%rsp), %xmm0
callq 0x291f0
incq %r12
cmpq %r12, %r15
jne 0x18b37
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsp), %rsi
movq %rcx, %rdi
callq 0x2575d
movq %r14, %rdi
callq 0x25edd
leaq 0x10(%rsp), %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl $0x1, %r8d
callq 0x25900
leaq 0x58(%rsp), %rbp
movl $0x3, %edx
movq %rbp, %rdi
xorl %esi, %esi
movq %rbx, %rcx
movl $0x1, %r8d
callq 0x25900
subq $0x8, %rsp
leaq 0x10(%rsp), %r13
movl $0x1, %edx
movl $0x2, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %r8
leaq 0x18(%rsp), %r9
pushq %rbx
pushq %r13
pushq %r14
callq 0x1aa0a
addq $0x20, %rsp
cmpq $0x0, (%r13)
sete %bpl
movq %rbx, %rdi
callq 0x256fa
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::safesolve_cbasicsolveandupdate(alglib_impl::ae_complex, alglib_impl::ae_complex, double, double, double, double*, alglib_impl::ae_complex*, alglib_impl::ae_state*)
static ae_bool safesolve_cbasicsolveandupdate(ae_complex alpha,
     ae_complex beta,
     double lnmax,
     double bnorm,
     double maxgrowth,
     double* xnorm,
     ae_complex* x,
     ae_state *_state)
{
    double v;
    ae_bool result;

    x->x = 0;
    x->y = 0;

    result = ae_false;
    if( ae_c_eq_d(alpha,0) )
    {
        return result;
    }
    if( ae_c_neq_d(beta,0) )
    {
        
        /*
         * alpha*x[i]=beta
         */
        v = ae_log(ae_c_abs(beta, _state), _state)-ae_log(ae_c_abs(alpha, _state), _state);
        if( ae_fp_greater(v,lnmax) )
        {
            return result;
        }
        *x = ae_c_div(beta,alpha);
    }
    else
    {
        
        /*
         * alpha*x[i]=0
         */
        *x = ae_complex_from_d(0);
    }
    
    /*
     * update NrmX, test growth limit
     */
    *xnorm = ae_maxreal(*xnorm, ae_c_abs(*x, _state), _state);
    if( ae_fp_greater(*xnorm,maxgrowth*bnorm) )
    {
        return result;
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd %xmm6, 0x30(%rsp)
movsd %xmm5, 0x38(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
xorps %xmm2, %xmm2
movups %xmm2, (%rsi)
xorps %xmm2, %xmm2
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
callq 0x28050
testb %al, %al
je 0x1f11b
xorl %eax, %eax
jmp 0x1f1f5
xorps %xmm2, %xmm2
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x28094
testb %al, %al
je 0x1f1aa
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movq %r14, %rdi
callq 0x27ea6
movq %r14, %rdi
callq 0x266d6
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %r14, %rdi
callq 0x27ea6
movq %r14, %rdi
callq 0x266d6
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x2633e
testb %al, %al
jne 0x1f114
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
callq 0x27fc3
jmp 0x1f1b2
xorps %xmm0, %xmm0
callq 0x27e6b
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movsd (%rbx), %xmm2
movsd %xmm2, (%rsp)
movq %r14, %rdi
callq 0x27ea6
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %r14, %rdi
callq 0x26621
movsd %xmm0, (%rbx)
movsd 0x38(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
callq 0x2633e
xorb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x50(%rsp), %r12
xorl %eax, %eax
movq %rax, (%r8)
movq %rax, (%r9)
testq %rdx, %rdx
je 0x1fda7
movq %rcx, %r13
movq %rdx, %r15
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
jle 0x1fdb1
movq %rsi, %rbp
movq %rdi, %rbx
xorps %xmm0, %xmm0
xorl %r14d, %r14d
movsd %xmm0, (%rsp)
movq 0x28(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movq 0x28(%rbp), %rax
mulsd (%rax,%r14,8), %xmm0
movq 0x28(%r13), %rax
movsd %xmm0, (%rax,%r14,8)
movq %r12, %rdi
callq 0x26575
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %r12, %rdi
callq 0x26621
incq %r14
cmpq %r14, %r15
jne 0x1fd61
jmp 0x1fdb4
xorl %eax, %eax
movq %rax, (%r8)
movq %rax, (%r9)
jmp 0x1fdd8
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
callq 0x262ba
testb %al, %al
je 0x1fde7
xorl %eax, %eax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movsd (%rsp), %xmm0
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r12, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fe0f
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorpd %xmm0, %xmm0
testq %rdx, %rdx
jle 0x204f5
xorl %r13d, %r13d
movsd %xmm0, (%rsp)
movq 0x28(%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq %r12, %rdi
callq 0x26575
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %r12, %rdi
callq 0x26621
incq %r13
cmpq %r13, %r14
jne 0x204c5
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
callq 0x262ba
testb %al, %al
jne 0x205c6
decq %r14
movsd 0x13c8a(%rip), %xmm0    # 0x341a0
movsd %xmm0, 0x8(%rsp)
divsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%r15), %r13
xorl %edi, %edi
movq %r14, %rsi
callq 0x2923f
movl $0x1, %esi
movq %r13, %rdi
movq %rax, %rdx
movsd (%rsp), %xmm0
callq 0x291fc
movsd (%rbx), %xmm0
divsd (%rsp), %xmm0
movsd %xmm0, (%rbx)
movq 0x28(%r15), %r13
xorl %edi, %edi
movq %r14, %rsi
callq 0x2923f
movl $0x1, %esi
movl $0x1, %ecx
movq %r13, %rdi
movq %r13, %rdx
movq %rax, %r8
callq 0x28ddc
movq %r12, %rdi
callq 0x2658d
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x28(%r15), %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x2923f
movl $0x1, %esi
movq %r15, %rdi
movq %rax, %rdx
movsd 0x8(%rsp), %xmm0
callq 0x291fc
movsd (%rbx), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::armijocreate(long, alglib_impl::ae_vector*, double, alglib_impl::ae_vector*, double, double, long, alglib_impl::armijostate*, alglib_impl::ae_state*)
void armijocreate(ae_int_t n,
     /* Real    */ ae_vector* x,
     double f,
     /* Real    */ ae_vector* s,
     double stp,
     double stpmax,
     ae_int_t fmax,
     armijostate* state,
     ae_state *_state)
{


    if( state->x.cnt<n )
    {
        ae_vector_set_length(&state->x, n, _state);
    }
    if( state->xbase.cnt<n )
    {
        ae_vector_set_length(&state->xbase, n, _state);
    }
    if( state->s.cnt<n )
    {
        ae_vector_set_length(&state->s, n, _state);
    }
    state->stpmax = stpmax;
    state->fmax = fmax;
    state->stplen = stp;
    state->fcur = f;
    state->n = n;
    ae_v_move(&state->xbase.ptr.p_double[0], 1, &x->ptr.p_double[0], 1, ae_v_len(0,n-1));
    ae_v_move(&state->s.ptr.p_double[0], 1, &s->ptr.p_double[0], 1, ae_v_len(0,n-1));
    ae_vector_set_length(&state->rstate.ia, 0+1, _state);
    ae_vector_set_length(&state->rstate.ra, 0+1, _state);
    state->rstate.stage = -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %rbp
movsd %xmm2, (%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rdx, %r15
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r13
movq %rdi, %r12
cmpq %rdi, 0x8(%r8)
jge 0x21b59
leaq 0x8(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
cmpq %r12, 0x48(%rbx)
jge 0x21b6e
leaq 0x48(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
cmpq %r12, 0x78(%rbx)
jge 0x21b83
leaq 0x78(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
movsd (%rsp), %xmm0
movsd %xmm0, 0xb8(%rbx)
movq %rbp, 0xc0(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0xa8(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xb0(%rbx)
movq %r12, 0x40(%rbx)
movq 0x70(%rbx), %rbp
movq 0x28(%r13), %r13
decq %r12
xorl %edi, %edi
movq %r12, %rsi
callq 0x2923f
movl $0x1, %esi
movl $0x1, %ecx
movq %rbp, %rdi
movq %r13, %rdx
movq %rax, %r8
callq 0x28ecd
movq 0xa0(%rbx), %r13
movq 0x28(%r15), %r15
xorl %edi, %edi
movq %r12, %rsi
callq 0x2923f
movl $0x1, %esi
movl $0x1, %ecx
movq %r13, %rdi
movq %r15, %rdx
movq %rax, %r8
callq 0x28ecd
leaq 0xe0(%rbx), %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x25a42
leaq 0x140(%rbx), %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x25a42
movl $0xffffffff, 0xd8(%rbx) # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_linminstate_init_copy(alglib_impl::linminstate*, alglib_impl::linminstate*, alglib_impl::ae_state*, bool)
ae_bool _linminstate_init_copy(linminstate* dst, linminstate* src, ae_state *_state, ae_bool make_automatic)
{
    dst->brackt = src->brackt;
    dst->stage1 = src->stage1;
    dst->infoc = src->infoc;
    dst->dg = src->dg;
    dst->dgm = src->dgm;
    dst->dginit = src->dginit;
    dst->dgtest = src->dgtest;
    dst->dgx = src->dgx;
    dst->dgxm = src->dgxm;
    dst->dgy = src->dgy;
    dst->dgym = src->dgym;
    dst->finit = src->finit;
    dst->ftest1 = src->ftest1;
    dst->fm = src->fm;
    dst->fx = src->fx;
    dst->fxm = src->fxm;
    dst->fy = src->fy;
    dst->fym = src->fym;
    dst->stx = src->stx;
    dst->sty = src->sty;
    dst->stmin = src->stmin;
    dst->stmax = src->stmax;
    dst->width = src->width;
    dst->width1 = src->width1;
    dst->xtrapf = src->xtrapf;
    return ae_true;
}

// Assembly:
movb (%rsi), %al
movb %al, (%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x30(%rsi), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x40(%rsi), %xmm0
movsd %xmm0, 0x40(%rdi)
movsd 0x48(%rsi), %xmm0
movsd %xmm0, 0x48(%rdi)
movsd 0x50(%rsi), %xmm0
movsd %xmm0, 0x50(%rdi)
movsd 0x58(%rsi), %xmm0
movsd %xmm0, 0x58(%rdi)
movsd 0x60(%rsi), %xmm0
movsd %xmm0, 0x60(%rdi)
movsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x68(%rdi)
movsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x70(%rdi)
movsd 0x78(%rsi), %xmm0
movsd %xmm0, 0x78(%rdi)
movsd 0x80(%rsi), %xmm0
movsd %xmm0, 0x80(%rdi)
movsd 0x88(%rsi), %xmm0
movsd %xmm0, 0x88(%rdi)
movsd 0x90(%rsi), %xmm0
movsd %xmm0, 0x90(%rdi)
movsd 0x98(%rsi), %xmm0
movsd %xmm0, 0x98(%rdi)
movsd 0xa0(%rsi), %xmm0
movsd %xmm0, 0xa0(%rdi)
movsd 0xa8(%rsi), %xmm0
movsd %xmm0, 0xa8(%rdi)
movsd 0xb0(%rsi), %xmm0
movsd %xmm0, 0xb0(%rdi)
movsd 0xb8(%rsi), %xmm0
movsd %xmm0, 0xb8(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x221c0
leaq 0x48(%r14), %rdi
movzbl %bpl, %ebp
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x221c0
leaq 0x78(%r14), %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x221c0
addq $0xd8, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x29247
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb (%rsi), %al
movb %al, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x2597e
testb %al, %al
je 0x222c3
movsd 0x38(%r14), %xmm0
movsd %xmm0, 0x38(%r15)
movq 0x40(%r14), %rax
movq %rax, 0x40(%r15)
leaq 0x48(%r15), %rdi
leaq 0x48(%r14), %rsi
movzbl %bpl, %ebp
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x222c3
leaq 0x78(%r15), %rdi
leaq 0x78(%r14), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x222c3
movsd 0xa8(%r14), %xmm0
movsd %xmm0, 0xa8(%r15)
movsd 0xb0(%r14), %xmm0
movsd %xmm0, 0xb0(%r15)
movsd 0xb8(%r14), %xmm0
movsd %xmm0, 0xb8(%r15)
movq 0xc0(%r14), %rax
movq %rax, 0xc0(%r15)
movq 0xc8(%r14), %rax
movq %rax, 0xc8(%r15)
movq 0xd0(%r14), %rax
movq %rax, 0xd0(%r15)
movl $0xd8, %eax
addq %rax, %r15
addq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2937c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x25ac7
leaq 0x48(%rbx), %rdi
callq 0x25ac7
leaq 0x78(%rbx), %rdi
callq 0x25ac7
addq $0xd8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x293ff
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movaps %xmm0, %xmm1
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rdi), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x2635a
testb %al, %al
je 0x22376
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r15)
testq %rbx, %rbx
jle 0x22376
xorl %eax, %eax
movq 0x28(%r14), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x22362
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasegeneratecomplexfftplan(long, alglib_impl::ftplan*, alglib_impl::ae_state*)
void ftbasegeneratecomplexfftplan(ae_int_t n,
     ftplan* plan,
     ae_state *_state)
{
    ae_int_t planarraysize;
    ae_int_t plansize;
    ae_int_t precomputedsize;
    ae_int_t tmpmemsize;
    ae_int_t stackmemsize;
    ae_int_t stackptr;

    _ftplan_clear(plan);

    planarraysize = 1;
    plansize = 0;
    precomputedsize = 0;
    stackmemsize = 0;
    stackptr = 0;
    tmpmemsize = 2*n;
    ae_vector_set_length(&plan->plan, planarraysize, _state);
    ftbase_ftbasegenerateplanrec(n, ftbase_ftbasecffttask, plan, &plansize, &precomputedsize, &planarraysize, &tmpmemsize, &stackmemsize, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateComplexFFTPlan: stack ptr!", _state);
    ae_vector_set_length(&plan->stackbuf, ae_maxint(stackmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->tmpbuf, ae_maxint(tmpmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->precomputed, ae_maxint(precomputedsize, 1, _state), _state);
    stackptr = 0;
    ftbase_ftbaseprecomputeplanrec(plan, 0, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateComplexFFTPlan: stack ptr!", _state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x224c0
leaq 0x10(%rsp), %rax
movq $0x1, (%rax)
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
movq %r13, (%rbp)
leaq 0x18(%rsp), %r15
movq %r13, (%r15)
movq %rsp, %rax
movq %r13, (%rax)
leaq (%r12,%r12), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25a42
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbp, %rcx
movq %r15, %r8
leaq 0x10(%rsp), %r9
pushq %rbx
pushq %r13
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x20(%rsp), %rax
pushq %rax
callq 0x224eb
addq $0x20, %rsp
leaq 0x14b63(%rip), %r12     # 0x36f76
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
leaq 0x90(%r14), %r13
movq %rsp, %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2660b
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25a42
leaq 0x60(%r14), %r13
leaq 0x8(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2660b
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25a42
leaq 0x30(%r14), %r13
movq (%r15), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2660b
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25a42
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x22b33
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x25ac7
leaq 0x30(%rbx), %rdi
callq 0x25ac7
leaq 0x60(%rbx), %rdi
callq 0x25ac7
addq $0x90, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x25ac7
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasegeneraterealfhtplan(long, alglib_impl::ftplan*, alglib_impl::ae_state*)
void ftbasegeneraterealfhtplan(ae_int_t n, ftplan* plan, ae_state *_state)
{
    ae_int_t planarraysize;
    ae_int_t plansize;
    ae_int_t precomputedsize;
    ae_int_t tmpmemsize;
    ae_int_t stackmemsize;
    ae_int_t stackptr;

    _ftplan_clear(plan);

    planarraysize = 1;
    plansize = 0;
    precomputedsize = 0;
    stackmemsize = 0;
    stackptr = 0;
    tmpmemsize = n;
    ae_vector_set_length(&plan->plan, planarraysize, _state);
    ftbase_ftbasegenerateplanrec(n, ftbase_ftbaserfhttask, plan, &plansize, &precomputedsize, &planarraysize, &tmpmemsize, &stackmemsize, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateRealFHTPlan: stack ptr!", _state);
    ae_vector_set_length(&plan->stackbuf, ae_maxint(stackmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->tmpbuf, ae_maxint(tmpmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->precomputed, ae_maxint(precomputedsize, 1, _state), _state);
    stackptr = 0;
    ftbase_ftbaseprecomputeplanrec(plan, 0, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateRealFHTPlan: stack ptr!", _state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x224c0
leaq 0x10(%rsp), %rax
movq $0x1, (%rax)
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
movq %r13, (%rbp)
leaq 0x18(%rsp), %r15
movq %r13, (%r15)
movq %rsp, %rax
movq %r13, (%rax)
leaq 0x8(%rsp), %rax
movq %r12, (%rax)
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25a42
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %rbp, %rcx
movq %r15, %r8
leaq 0x10(%rsp), %r9
pushq %rbx
pushq %r13
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x20(%rsp), %rax
pushq %rax
callq 0x224eb
addq $0x20, %rsp
leaq 0x13eee(%rip), %r12     # 0x36fe9
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
leaq 0x90(%r14), %r13
movq %rsp, %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2660b
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25a42
leaq 0x60(%r14), %r13
leaq 0x8(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2660b
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25a42
leaq 0x30(%r14), %r13
movq (%r15), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2660b
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25a42
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x22b33
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0x2, %ecx
movq %rdi, %rax
cqto
idivq %rcx
testq %rdx, %rdx
jne 0x24a84
movq %rdi, %rax
cqto
idivq %rcx
movq %rax, %rdi
jmp 0x24a6d
incq %rcx
cmpq $0x6, %rcx
jne 0x24a6a
cmpq $0x1, %rdi
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rsi, %r8
movl $0x2, %ecx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rdi, %rax
jl 0x24a9d
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x24ad0
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x12557(%rip), %r13     # 0x37048
movl $0x1, %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2581c
cmpq %r12, %r15
jge 0x24b4b
cmpq $0x2, %rbp
jg 0x24b23
leaq (%r15,%r15), %rsi
movl $0x2, %edx
movq %r12, %rdi
movq %rbx, %rcx
movq %r14, %r8
callq 0x24ad0
cmpq $0x3, %rbp
jg 0x24b40
leaq (%r15,%r15,2), %rsi
movl $0x3, %edx
movq %r12, %rdi
movq %rbx, %rcx
movq %r14, %r8
callq 0x24ad0
leaq (%r15,%r15,4), %r15
movl $0x5, %ebp
jmp 0x24af1
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x26616
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rsi, %r8
movl $0x2, %ecx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rdi, %rax
jl 0x24b73
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x2, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x24ad0
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_ftplan_init(alglib_impl::ftplan*, alglib_impl::ae_state*, bool)
ae_bool _ftplan_init(ftplan* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->plan, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->precomputed, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->tmpbuf, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->stackbuf, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x24c9b
leaq 0x30(%r14), %rdi
movzbl %bpl, %ebp
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x24c9b
leaq 0x60(%r14), %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x24c9b
addq $0x90, %r14
movl $0x3, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x25900
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_ftplan_init_copy(alglib_impl::ftplan*, alglib_impl::ftplan*, alglib_impl::ae_state*, bool)
ae_bool _ftplan_init_copy(ftplan* dst, ftplan* src, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init_copy(&dst->plan, &src->plan, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->precomputed, &src->precomputed, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->tmpbuf, &src->tmpbuf, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->stackbuf, &src->stackbuf, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2597e
testb %al, %al
je 0x24d12
leaq 0x30(%r15), %rdi
leaq 0x30(%r14), %rsi
movzbl %bpl, %ebp
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x24d12
leaq 0x60(%r15), %rdi
leaq 0x60(%r14), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x24d12
movl $0x90, %eax
addq %rax, %r15
addq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2597e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::nulog1p(double, alglib_impl::ae_state*)
double nulog1p(double x, ae_state *_state)
{
    double z;
    double lp;
    double lq;
    double result;


    z = 1.0+x;
    if( ae_fp_less(z,0.70710678118654752440)||ae_fp_greater(z,1.41421356237309504880) )
    {
        result = ae_log(z, _state);
        return result;
    }
    z = x*x;
    lp = 4.5270000862445199635215E-5;
    lp = lp*x+4.9854102823193375972212E-1;
    lp = lp*x+6.5787325942061044846969E0;
    lp = lp*x+2.9911919328553073277375E1;
    lp = lp*x+6.0949667980987787057556E1;
    lp = lp*x+5.7112963590585538103336E1;
    lp = lp*x+2.0039553499201281259648E1;
    lq = 1.0000000000000000000000E0;
    lq = lq*x+1.5062909083469192043167E1;
    lq = lq*x+8.3047565967967209469434E1;
    lq = lq*x+2.2176239823732856465394E2;
    lq = lq*x+3.0909872225312059774938E2;
    lq = lq*x+2.1642788614495947685003E2;
    lq = lq*x+6.0118660497603843919306E1;
    z = -0.5*z+x*(z*lp/lq);
    result = x+z;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xf471(%rip), %xmm2     # 0x341a0
movsd %xmm0, 0x8(%rsp)
addsd %xmm0, %xmm2
movsd 0x11c27(%rip), %xmm1    # 0x36968
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
callq 0x262fe
testb %al, %al
jne 0x24d69
movsd 0xf8cd(%rip), %xmm1     # 0x34628
movsd (%rsp), %xmm0
callq 0x2633e
testb %al, %al
je 0x24d7b
movsd (%rsp), %xmm0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x266d6
movsd 0x11bed(%rip), %xmm1    # 0x36970
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm1
addsd 0x11be3(%rip), %xmm1    # 0x36978
mulsd %xmm3, %xmm1
addsd 0x11bdf(%rip), %xmm1    # 0x36980
mulsd %xmm3, %xmm1
addsd 0x11bdb(%rip), %xmm1    # 0x36988
mulsd %xmm3, %xmm1
addsd 0x11bd7(%rip), %xmm1    # 0x36990
mulsd %xmm3, %xmm1
addsd 0x11bd3(%rip), %xmm1    # 0x36998
mulsd %xmm3, %xmm1
addsd 0x11bcf(%rip), %xmm1    # 0x369a0
movsd 0x11bcf(%rip), %xmm2    # 0x369a8
addsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
addsd 0x11bc7(%rip), %xmm2    # 0x369b0
mulsd %xmm3, %xmm2
addsd 0x11bc3(%rip), %xmm2    # 0x369b8
mulsd %xmm3, %xmm2
addsd 0x11bbf(%rip), %xmm2    # 0x369c0
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm2
addsd 0x11bb7(%rip), %xmm2    # 0x369c8
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm2
addsd 0x11baf(%rip), %xmm2    # 0x369d0
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
mulsd 0xf657(%rip), %xmm0     # 0x34488
mulsd %xmm3, %xmm1
addsd %xmm1, %xmm0
addsd %xmm3, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::nuexpm1(double, alglib_impl::ae_state*)
double nuexpm1(double x, ae_state *_state)
{
    double r;
    double xx;
    double ep;
    double eq;
    double result;


    if( ae_fp_less(x,-0.5)||ae_fp_greater(x,0.5) )
    {
        result = ae_exp(x, _state)-1.0;
        return result;
    }
    xx = x*x;
    ep = 1.2617719307481059087798E-4;
    ep = ep*xx+3.0299440770744196129956E-2;
    ep = ep*xx+9.9999999999999999991025E-1;
    eq = 3.0019850513866445504159E-6;
    eq = eq*xx+2.5244834034968410419224E-3;
    eq = eq*xx+2.2726554820815502876593E-1;
    eq = eq*xx+2.0000000000000000000897E0;
    r = x*ep;
    r = r/(eq-r);
    result = r+r;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xf635(%rip), %xmm1     # 0x34488
movsd %xmm0, 0x8(%rsp)
callq 0x262fe
testb %al, %al
jne 0x24e79
movsd 0xf5fe(%rip), %xmm1     # 0x34468
movsd 0x8(%rsp), %xmm0
callq 0x2633e
testb %al, %al
je 0x24e91
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x266e0
addsd 0xf341(%rip), %xmm0     # 0x341d0
jmp 0x24efb
movsd 0x8(%rsp), %xmm3
movapd %xmm3, %xmm1
mulsd %xmm3, %xmm1
movsd 0x11b31(%rip), %xmm0    # 0x369d8
mulsd %xmm1, %xmm0
addsd 0x11b2d(%rip), %xmm0    # 0x369e0
mulsd %xmm1, %xmm0
addsd 0xf2e1(%rip), %xmm0     # 0x341a0
movsd 0x11b21(%rip), %xmm2    # 0x369e8
mulsd %xmm1, %xmm2
addsd 0x11b1d(%rip), %xmm2    # 0x369f0
mulsd %xmm1, %xmm2
addsd 0x11b19(%rip), %xmm2    # 0x369f8
mulsd %xmm1, %xmm2
addsd 0xf4f5(%rip), %xmm2     # 0x343e0
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm2
divsd %xmm2, %xmm0
addsd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::nucosm1(double, alglib_impl::ae_state*)
double nucosm1(double x, ae_state *_state)
{
    double xx;
    double c;
    double result;


    if( ae_fp_less(x,-0.25*ae_pi)||ae_fp_greater(x,0.25*ae_pi) )
    {
        result = ae_cos(x, _state)-1;
        return result;
    }
    xx = x*x;
    c = 4.7377507964246204691685E-14;
    c = c*xx-1.1470284843425359765671E-11;
    c = c*xx+2.0876754287081521758361E-9;
    c = c*xx-2.7557319214999787979814E-7;
    c = c*xx+2.4801587301570552304991E-5;
    c = c*xx-1.3888888888888872993737E-3;
    c = c*xx+4.1666666666666666609054E-2;
    result = -0.5*xx+xx*xx*c;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xfdc7(%rip), %xmm1     # 0x34cd8
movsd %xmm0, 0x8(%rsp)
callq 0x262fe
testb %al, %al
jne 0x24f37
movsd 0xfbf0(%rip), %xmm1     # 0x34b18
movsd 0x8(%rsp), %xmm0
callq 0x2633e
testb %al, %al
je 0x24f4f
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x266a9
addsd 0xf283(%rip), %xmm0     # 0x341d0
jmp 0x24fc1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x11a9f(%rip), %xmm2    # 0x36a00
mulsd %xmm0, %xmm2
addsd 0x11a9b(%rip), %xmm2    # 0x36a08
mulsd %xmm0, %xmm2
addsd 0x11a97(%rip), %xmm2    # 0x36a10
mulsd %xmm0, %xmm2
addsd 0x11a93(%rip), %xmm2    # 0x36a18
mulsd %xmm0, %xmm2
addsd 0x11a8f(%rip), %xmm2    # 0x36a20
mulsd %xmm0, %xmm2
addsd 0x11a8b(%rip), %xmm2    # 0x36a28
mulsd %xmm0, %xmm2
addsd 0x11a87(%rip), %xmm2    # 0x36a30
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
mulsd 0xf4cb(%rip), %xmm0     # 0x34488
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::xblas_xfastpow(double, long, alglib_impl::ae_state*)
static double xblas_xfastpow(double r, ae_int_t n, ae_state *_state)
{
    double result;


    result = 0;
    if( n>0 )
    {
        if( n%2==0 )
        {
            result = ae_sqr(xblas_xfastpow(r, n/2, _state), _state);
        }
        else
        {
            result = r*xblas_xfastpow(r, n-1, _state);
        }
        return result;
    }
    if( n==0 )
    {
        result = 1;
    }
    if( n<0 )
    {
        result = xblas_xfastpow(1/r, -n, _state);
    }
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movapd %xmm0, %xmm2
movsd 0xf18a(%rip), %xmm1     # 0x341a0
testq %rdi, %rdi
jg 0x25038
movapd %xmm1, %xmm0
je 0x25025
xorpd %xmm0, %xmm0
jns 0x25075
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
negq %rdi
movapd %xmm0, %xmm2
jmp 0x25016
testb $0x1, %dil
jne 0x2505a
shrq %rdi
movapd %xmm2, %xmm0
movq %rbx, %rsi
callq 0x25002
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x26588
decq %rdi
movapd %xmm2, %xmm0
movq %rbx, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x25002
mulsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_break(alglib_impl::ae_state*, alglib_impl::ae_error_type, char const*)
void ae_break(ae_state *state, ae_error_type error_type, const char *msg)
{
#ifndef AE_USE_CPP_ERROR_HANDLING
    if( state!=NULL )
    {
        ae_state_clear(state);
        state->last_error = error_type;
        state->error_msg = msg;
        if( state->break_jump!=NULL )
            longjmp(*(state->break_jump), 1);
        else
            abort();
    }
    else
        abort();
#else
    if( state!=NULL )
    {
        ae_state_clear(state);
        state->last_error = error_type;
        state->error_msg = msg;
    }
    throw error_type;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
testq %rdi, %rdi
je 0x25539
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%r15), %rax
movq 0x10(%rax), %rax
cmpq $0x1, %rax
je 0x25531
movq %r15, %rdi
callq 0x256fa
jmp 0x25519
movl %ebx, 0x40(%r15)
movq %r14, 0x48(%r15)
movl $0x4, %edi
callq 0x3140
movl %ebx, (%rax)
leaq 0x1e624(%rip), %rsi     # 0x43b70
movq %rax, %rdi
xorl %edx, %edx
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_malloc(unsigned long, alglib_impl::ae_state*)
void* ae_malloc(size_t size, ae_state *state)
{
    void *result;
    if( size==0 )
        return NULL;
    result = aligned_malloc(size,AE_DATA_ALIGN);
    if( result==NULL && state!=NULL)
        ae_break(state, ERR_OUT_OF_MEMORY, "ae_malloc(): out of memory");
    return result;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x25628
movq %rsi, %rbx
movl $0x10, %esi
callq 0x25580
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x2562a
leaq 0x12031(%rip), %rdx     # 0x3764c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x25507
xorl %eax, %eax
popq %rbx
retq