LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apservisfinitectrmatrix(alglib_impl::ae_matrix*, long, bool, alglib_impl::ae_state*)
ae_bool apservisfinitectrmatrix(/* Complex */ ae_matrix* x,
     ae_int_t n,
     ae_bool isupper,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j1;
    ae_int_t j2;
    ae_int_t j;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteCTRMatrix: internal error (N<0)", _state);
    for(i=0; i<=n-1; i++)
    {
        if( isupper )
        {
            j1 = i;
            j2 = n-1;
        }
        else
        {
            j1 = 0;
            j2 = i;
        }
        for(j=j1; j<=j2; j++)
        {
            if( !ae_isfinite(x->ptr.pp_complex[i][j].x, _state)||!ae_isfinite(x->ptr.pp_complex[i][j].y, _state) )
            {
                result = ae_false;
                return result;
            }
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, 0x4(%rsp)
movq %rsi, %r13
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x22794(%rip), %rsi     # 0x36c9d
movq %rcx, %rdx
callq 0x2581c
testq %r13, %r13
setle %r12b
jle 0x145a8
leaq -0x1(%r13), %rax
xorl %r14d, %r14d
movq %r13, 0x10(%rsp)
movq %rax, 0x8(%rsp)
cmpb $0x0, 0x4(%rsp)
movl $0x0, %r13d
cmovneq %r14, %r13
movq %r14, %rbp
cmovneq %rax, %rbp
cmpq %rbp, %r13
jg 0x14592
subq %r13, %rbp
incq %rbp
shlq $0x4, %r13
movq 0x38(%r15), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
je 0x145a8
movq 0x38(%r15), %rax
movq (%rax,%r14,8), %rax
movsd 0x8(%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
je 0x145a8
addq $0x10, %r13
decq %rbp
jne 0x14554
incq %r14
movq 0x10(%rsp), %r13
cmpq %r13, %r14
setge %r12b
movq 0x8(%rsp), %rax
jne 0x1452f
andb $0x1, %r12b
movl %r12d, %eax
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::apservisfiniteornanmatrix(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool apservisfiniteornanmatrix(/* Real    */ ae_matrix* x,
     ae_int_t m,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteOrNaNMatrix: internal error (N<0)", _state);
    ae_assert(m>=0, "APSERVIsFiniteOrNaNMatrix: internal error (M<0)", _state);
    for(i=0; i<=m-1; i++)
    {
        for(j=0; j<=n-1; j++)
        {
            if( !(ae_isfinite(x->ptr.pp_double[i][j], _state)||ae_isnan(x->ptr.pp_double[i][j], _state)) )
            {
                result = ae_false;
                return result;
            }
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %edi, %edi
testq %rdx, %rdx
setns %dil
leaq 0x226e6(%rip), %rsi     # 0x36ccb
movq %rcx, %rdx
callq 0x2581c
xorl %edi, %edi
testq %r15, %r15
setns %dil
leaq 0x226fe(%rip), %rsi     # 0x36cfb
movq %rbx, %rdx
callq 0x2581c
movq %r15, (%rsp)
testq %r15, %r15
setle %bpl
jle 0x14668
xorl %r13d, %r13d
testq %r14, %r14
jle 0x1465b
xorl %r15d, %r15d
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
jne 0x14653
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x26491
testb %al, %al
je 0x14668
incq %r15
cmpq %r15, %r14
jne 0x1461d
incq %r13
cmpq (%rsp), %r13
setge %bpl
jne 0x14615
andb $0x1, %bpl
movl %ebp, %eax
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::safepythag2(double, double, alglib_impl::ae_state*)
double safepythag2(double x, double y, ae_state *_state)
{
    double w;
    double xabs;
    double yabs;
    double z;
    double result;


    xabs = ae_fabs(x, _state);
    yabs = ae_fabs(y, _state);
    w = ae_maxreal(xabs, yabs, _state);
    z = ae_minreal(xabs, yabs, _state);
    if( ae_fp_eq(z,0) )
    {
        result = w;
    }
    else
    {
        result = w*ae_sqrt(1+ae_sqr(z/w, _state), _state);
    }
    return result;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd %xmm1, 0x8(%rsp)
callq 0x26575
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26575
movaps %xmm0, %xmm1
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26621
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rdi
callq 0x26626
xorpd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
callq 0x262ba
testb %al, %al
jne 0x1471c
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26588
addsd 0x1fa9c(%rip), %xmm0    # 0x341a0
movq %rbx, %rdi
callq 0x2658d
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::safepythag3(double, double, double, alglib_impl::ae_state*)
double safepythag3(double x, double y, double z, ae_state *_state)
{
    double w;
    double result;


    w = ae_maxreal(ae_fabs(x, _state), ae_maxreal(ae_fabs(y, _state), ae_fabs(z, _state), _state), _state);
    if( ae_fp_eq(w,0) )
    {
        result = 0;
        return result;
    }
    x = x/w;
    y = y/w;
    z = z/w;
    result = w*ae_sqrt(ae_sqr(x, _state)+ae_sqr(y, _state)+ae_sqr(z, _state), _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x28(%rsp)
callq 0x26575
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26575
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26575
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26621
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26621
xorpd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
callq 0x262ba
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x14823
movsd 0x28(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x18(%rsp), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
movq %rbx, %rdi
callq 0x26588
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26588
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26588
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2658d
mulsd 0x10(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apperiodicmap(double*, double, double, double*, alglib_impl::ae_state*)
void apperiodicmap(double* x,
     double a,
     double b,
     double* k,
     ae_state *_state)
{

    *k = 0;

    ae_assert(ae_fp_less(a,b), "APPeriodicMap: internal error!", _state);
    *k = ae_ifloor((*x-a)/(b-a), _state);
    *x = *x-*k*(b-a);
    while(ae_fp_less(*x,a))
    {
        *x = *x+(b-a);
        *k = *k-1;
    }
    while(ae_fp_greater(*x,b))
    {
        *x = *x-(b-a);
        *k = *k+1;
    }
    *x = ae_maxreal(*x, a, _state);
    *x = ae_minreal(*x, b, _state);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq $0x0, (%rsi)
callq 0x262fe
movzbl %al, %edi
leaq 0x222b3(%rip), %rsi     # 0x36d2b
movq %r14, %rdx
callq 0x2581c
movsd (%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
divsd %xmm2, %xmm0
movq %r14, %rdi
callq 0x265d3
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd %xmm1, (%r15)
movsd (%rbx), %xmm0
mulsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movsd 0x8(%rsp), %xmm1
callq 0x262fe
testb %al, %al
je 0x14b1e
movsd (%rbx), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
addsd 0x1f6dd(%rip), %xmm0    # 0x341d0
movsd %xmm0, (%r15)
movsd (%rbx), %xmm0
jmp 0x14ac9
movsd (%rbx), %xmm0
subsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
addsd 0x1f687(%rip), %xmm0    # 0x341a0
movsd %xmm0, (%r15)
movsd (%rbx), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2633e
testb %al, %al
jne 0x14afe
movsd (%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
callq 0x26621
movsd %xmm0, (%rbx)
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x26626
movsd %xmm0, (%rbx)
addq $0x20, %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::allocrealarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void allocrealarray(ae_serializer* s,
     /* Real    */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_alloc_entry(s);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_alloc_entry(s);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jns 0x14c41
movq (%rsi), %rbx
movq %r14, %rdi
callq 0x27a9e
testq %rbx, %rbx
jle 0x14c5b
movq %r14, %rdi
callq 0x27a9e
decq %rbx
jne 0x14c4e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::serializerealarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void serializerealarray(ae_serializer* s,
     /* Real    */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_serialize_int(s, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_serialize_double(s, v->ptr.p_double[i], _state);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
testq %rdx, %rdx
jns 0x14c80
movq (%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x27c48
testq %r15, %r15
jle 0x14cb3
xorl %r13d, %r13d
movq 0x28(%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x27d2c
incq %r13
cmpq %r13, %r15
jne 0x14c96
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::unserializerealarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void unserializerealarray(ae_serializer* s,
     /* Real    */ ae_vector* v,
     ae_state *_state)
{
    ae_int_t n;
    ae_int_t i;
    double t;

    ae_vector_clear(v);

    ae_serializer_unserialize_int(s, &n, _state);
    if( n==0 )
    {
        return;
    }
    ae_vector_set_length(v, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_unserialize_double(s, &t, _state);
        v->ptr.p_double[i] = t;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x25ac7
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27e2b
movq (%r12), %rsi
testq %rsi, %rsi
je 0x14d36
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25a42
cmpq $0x0, (%rsp)
jle 0x14d36
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27e4a
movsd 0x8(%rsp), %xmm0
movq 0x28(%r14), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
cmpq (%rsp), %r13
jl 0x14d0f
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::allocintegerarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void allocintegerarray(ae_serializer* s,
     /* Integer */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_alloc_entry(s);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_alloc_entry(s);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jns 0x14d56
movq (%rsi), %rbx
movq %r14, %rdi
callq 0x27a9e
testq %rbx, %rbx
jle 0x14d70
movq %r14, %rdi
callq 0x27a9e
decq %rbx
jne 0x14d63
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::serializeintegerarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void serializeintegerarray(ae_serializer* s,
     /* Integer */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_serialize_int(s, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_serialize_int(s, v->ptr.p_int[i], _state);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
testq %rdx, %rdx
jns 0x14d95
movq (%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x27c48
testq %r15, %r15
jle 0x14dc6
xorl %r13d, %r13d
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x27c48
incq %r13
cmpq %r13, %r15
jne 0x14dab
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::unserializeintegerarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void unserializeintegerarray(ae_serializer* s,
     /* Integer */ ae_vector* v,
     ae_state *_state)
{
    ae_int_t n;
    ae_int_t i;
    ae_int_t t;

    ae_vector_clear(v);

    ae_serializer_unserialize_int(s, &n, _state);
    if( n==0 )
    {
        return;
    }
    ae_vector_set_length(v, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_unserialize_int(s, &t, _state);
        v->ptr.p_int[i] = t;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x25ac7
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27e2b
movq (%r12), %rsi
testq %rsi, %rsi
je 0x14e46
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25a42
cmpq $0x0, (%rsp)
jle 0x14e46
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27e2b
movq 0x8(%rsp), %rax
movq 0x28(%r14), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq (%rsp), %r13
jl 0x14e22
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::allocrealmatrix(alglib_impl::ae_serializer*, alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
void allocrealmatrix(ae_serializer* s,
     /* Real    */ ae_matrix* v,
     ae_int_t n0,
     ae_int_t n1,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;


    if( n0<0 )
    {
        n0 = v->rows;
    }
    if( n1<0 )
    {
        n1 = v->cols;
    }
    ae_serializer_alloc_entry(s);
    ae_serializer_alloc_entry(s);
    for(i=0; i<=n0-1; i++)
    {
        for(j=0; j<=n1-1; j++)
        {
            ae_serializer_alloc_entry(s);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rdx, %rdx
jns 0x14e6e
movq (%rsi), %r14
testq %rbx, %rbx
jns 0x14e77
movq 0x8(%rsi), %rbx
movq %r15, %rdi
callq 0x27a9e
movq %r15, %rdi
callq 0x27a9e
testq %r14, %r14
jle 0x14eac
xorl %r12d, %r12d
testq %rbx, %rbx
jle 0x14ea4
movq %rbx, %r13
movq %r15, %rdi
callq 0x27a9e
decq %r13
jne 0x14e97
incq %r12
cmpq %r14, %r12
jne 0x14e8f
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::serializerealmatrix(alglib_impl::ae_serializer*, alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
void serializerealmatrix(ae_serializer* s,
     /* Real    */ ae_matrix* v,
     ae_int_t n0,
     ae_int_t n1,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;


    if( n0<0 )
    {
        n0 = v->rows;
    }
    if( n1<0 )
    {
        n1 = v->cols;
    }
    ae_serializer_serialize_int(s, n0, _state);
    ae_serializer_serialize_int(s, n1, _state);
    for(i=0; i<=n0-1; i++)
    {
        for(j=0; j<=n1-1; j++)
        {
            ae_serializer_serialize_double(s, v->ptr.pp_double[i][j], _state);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, (%rsp)
testq %rdx, %rdx
jns 0x14edd
movq (%r15), %rax
movq %rax, (%rsp)
testq %r14, %r14
jns 0x14ee6
movq 0x8(%r15), %r14
movq %r13, %rdi
movq (%rsp), %r12
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27c48
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27c48
testq %r12, %r12
jle 0x14f3f
xorl %ebp, %ebp
testq %r14, %r14
jle 0x14f36
xorl %r12d, %r12d
movq 0x38(%r15), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x27d2c
incq %r12
cmpq %r12, %r14
jne 0x14f15
incq %rbp
cmpq (%rsp), %rbp
jne 0x14f0d
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::unserializerealmatrix(alglib_impl::ae_serializer*, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
void unserializerealmatrix(ae_serializer* s,
     /* Real    */ ae_matrix* v,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_int_t n0;
    ae_int_t n1;
    double t;

    ae_matrix_clear(v);

    ae_serializer_unserialize_int(s, &n0, _state);
    ae_serializer_unserialize_int(s, &n1, _state);
    if( n0==0||n1==0 )
    {
        return;
    }
    ae_matrix_set_length(v, n0, n1, _state);
    for(i=0; i<=n0-1; i++)
    {
        for(j=0; j<=n1-1; j++)
        {
            ae_serializer_unserialize_double(s, &t, _state);
            v->ptr.pp_double[i][j] = t;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x25edd
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27e2b
movq %rsp, %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x27e2b
movq (%r12), %rsi
testq %rsi, %rsi
sete %al
movq (%r13), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x15001
movq %r14, %rdi
movq %rbx, %rcx
callq 0x25df3
cmpq $0x0, 0x8(%rsp)
jle 0x15001
xorl %r13d, %r13d
leaq 0x10(%rsp), %r12
cmpq $0x0, (%rsp)
jle 0x14ff7
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27e4a
movsd 0x10(%rsp), %xmm0
movq 0x38(%r14), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq (%rsp), %rbp
jl 0x14fcd
incq %r13
cmpq 0x8(%rsp), %r13
jl 0x14fc4
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::copyintegerarray(alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void copyintegerarray(/* Integer */ ae_vector* src,
     /* Integer */ ae_vector* dst,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(dst);

    if( src->cnt>0 )
    {
        ae_vector_set_length(dst, src->cnt, _state);
        for(i=0; i<=src->cnt-1; i++)
        {
            dst->ptr.p_int[i] = src->ptr.p_int[i];
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25ac7
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x15059
movq %rbx, %rdi
movq %r15, %rdx
callq 0x25a42
cmpq $0x0, (%r14)
jle 0x15059
xorl %eax, %eax
movq 0x28(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x28(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq (%r14), %rax
jl 0x15041
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::copyrealarray(alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void copyrealarray(/* Real    */ ae_vector* src,
     /* Real    */ ae_vector* dst,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(dst);

    if( src->cnt>0 )
    {
        ae_vector_set_length(dst, src->cnt, _state);
        for(i=0; i<=src->cnt-1; i++)
        {
            dst->ptr.p_double[i] = src->ptr.p_double[i];
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25ac7
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x150ac
movq %rbx, %rdi
movq %r15, %rdx
callq 0x25a42
movq (%r14), %rax
testq %rax, %rax
jle 0x150ac
xorl %ecx, %ecx
movq 0x28(%r14), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq 0x28(%rbx), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x15092
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::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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25edd
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x15123
movq 0x8(%r14), %rdx
testq %rdx, %rdx
jle 0x15123
movq %rbx, %rdi
movq %r15, %rcx
callq 0x25df3
movq (%r14), %rax
testq %rax, %rax
jle 0x15123
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
jle 0x1511b
xorl %esi, %esi
movq 0x38(%r14), %rdi
movq (%rdi,%rdx,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq 0x38(%rbx), %rdi
movq (%rdi,%rdx,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x150f9
incq %rdx
cmpq %rax, %rdx
jne 0x150f2
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::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:
movq $-0x1, %rax
cmpq %r8, %rcx
jge 0x151d5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
setg %r10b
leaq (%rcx,%r8), %rbx
movq %rbx, %r11
shrq $0x3f, %r11
addq %rbx, %r11
sarq %r11
testq %rdx, %rdx
jle 0x151a8
movq %r11, %r15
imulq %rsi, %r15
movq 0x28(%rdi), %r12
movq 0x28(%r9), %r14
movq (%r12,%r15,8), %rbx
cmpq (%r14), %rbx
setl %bl
jne 0x151aa
leaq (%r12,%r15,8), %r15
movl $0x1, %r13d
movq %r13, %r12
cmpq %r13, %rdx
je 0x1519f
movq (%r15,%r12,8), %rbx
leaq 0x1(%r12), %r13
cmpq (%r14,%r12,8), %rbx
setl %bl
je 0x15185
cmpq %rdx, %r12
setl %bpl
jmp 0x151ad
xorl %ebx, %ebx
movl %r10d, %ebp
testb %bpl, %bpl
je 0x151c8
testb $0x1, %bl
cmoveq %r11, %r8
leaq 0x1(%r11), %r11
cmovneq %r11, %rcx
cmpq %r8, %rcx
jl 0x1514a
jmp 0x151cb
movq %r11, %rax
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::_apbuffers_init(alglib_impl::apbuffers*, alglib_impl::ae_state*, bool)
ae_bool _apbuffers_init(apbuffers* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->ia0, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia1, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia2, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia3, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra0, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra1, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra2, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra3, 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 0x152d0
leaq 0x30(%r14), %rdi
movzbl %bpl, %ebp
movl $0x2, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x152d0
leaq 0x60(%r14), %rdi
movl $0x2, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x152d0
leaq 0x90(%r14), %rdi
movl $0x2, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x152d0
leaq 0xc0(%r14), %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x152d0
leaq 0xf0(%r14), %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x152d0
leaq 0x120(%r14), %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x25900
testb %al, %al
je 0x152d0
addq $0x150, %r14            # imm = 0x150
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::_apbuffers_init_copy(alglib_impl::apbuffers*, alglib_impl::apbuffers*, alglib_impl::ae_state*, bool)
ae_bool _apbuffers_init_copy(apbuffers* dst, apbuffers* src, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init_copy(&dst->ia0, &src->ia0, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia1, &src->ia1, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia2, &src->ia2, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia3, &src->ia3, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra0, &src->ra0, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra1, &src->ra1, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra2, &src->ra2, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra3, &src->ra3, _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 0x153bb
leaq 0x30(%r15), %rdi
leaq 0x30(%r14), %rsi
movzbl %bpl, %ebp
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x153bb
leaq 0x60(%r15), %rdi
leaq 0x60(%r14), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x153bb
movl $0x90, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x153bb
movl $0xc0, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x153bb
movl $0xf0, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x153bb
movl $0x120, %esi            # imm = 0x120
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x153bb
movl $0x150, %eax            # imm = 0x150
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::_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 %rbx
movq %rdi, %rbx
callq 0x25ac7
leaq 0x30(%rbx), %rdi
callq 0x25ac7
leaq 0x60(%rbx), %rdi
callq 0x25ac7
leaq 0x90(%rbx), %rdi
callq 0x25ac7
leaq 0xc0(%rbx), %rdi
callq 0x25ac7
leaq 0xf0(%rbx), %rdi
callq 0x25ac7
leaq 0x120(%rbx), %rdi
callq 0x25ac7
addq $0x150, %rbx            # imm = 0x150
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::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsp, %rsi
movq %r8, %rdi
callq 0x2575d
movq %r15, %rdi
callq 0x25ac7
movq %r14, %rdi
callq 0x25ac7
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x151d6
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbp, %r8
movq %rbx, %r9
callq 0x154a4
movq %rbx, %rdi
callq 0x256fa
addq $0x198, %rsp            # imm = 0x198
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::tagsortfast(alglib_impl::ae_vector*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void tagsortfast(/* Real    */ ae_vector* a,
     /* Real    */ ae_vector* bufa,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_bool isascending;
    ae_bool isdescending;
    double tmpr;


    
    /*
     * Special case
     */
    if( n<=1 )
    {
        return;
    }
    
    /*
     * Test for already sorted set
     */
    isascending = ae_true;
    isdescending = ae_true;
    for(i=1; i<=n-1; i++)
    {
        isascending = isascending&&a->ptr.p_double[i]>=a->ptr.p_double[i-1];
        isdescending = isdescending&&a->ptr.p_double[i]<=a->ptr.p_double[i-1];
    }
    if( isascending )
    {
        return;
    }
    if( isdescending )
    {
        for(i=0; i<=n-1; i++)
        {
            j = n-1-i;
            if( j<=i )
            {
                break;
            }
            tmpr = a->ptr.p_double[i];
            a->ptr.p_double[i] = a->ptr.p_double[j];
            a->ptr.p_double[j] = tmpr;
        }
        return;
    }
    
    /*
     * General case
     */
    if( bufa->cnt<n )
    {
        ae_vector_set_length(bufa, n, _state);
    }
    tsort_tagsortfastrec(a, bufa, 0, n-1, _state);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x2, %rdx
jl 0x15e11
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, %al
movl $0x1, %esi
movb $0x1, %dil
testb $0x1, %dil
je 0x15de8
movq 0x28(%rbx), %rdi
movsd (%rdi,%rsi,8), %xmm0
ucomisd -0x8(%rdi,%rsi,8), %xmm0
setae %dil
jmp 0x15dea
xorl %edi, %edi
testb $0x1, %al
je 0x15e02
movq 0x28(%rbx), %rax
movsd -0x8(%rax,%rsi,8), %xmm0
ucomisd (%rax,%rsi,8), %xmm0
setae %al
jmp 0x15e04
xorl %eax, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x15dcd
testb %dil, %dil
je 0x15e17
popq %rbx
popq %r14
popq %r15
retq
leaq -0x1(%rdx), %r15
testb %al, %al
je 0x15e4f
xorl %eax, %eax
cmpq %rax, %r15
jle 0x15e11
movq 0x28(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd (%rcx,%r15,8), %xmm1
movsd %xmm1, (%rcx,%rax,8)
movq 0x28(%rbx), %rcx
movsd %xmm0, (%rcx,%r15,8)
incq %rax
addq $-0x1, %r15
jb 0x15e21
jmp 0x15e11
cmpq %rdx, (%r14)
jge 0x15e62
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x25a42
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x15e74
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::vectornorm2(alglib_impl::ae_vector*, long, long, alglib_impl::ae_state*)
double vectornorm2(/* Real    */ ae_vector* x,
     ae_int_t i1,
     ae_int_t i2,
     ae_state *_state)
{
    ae_int_t n;
    ae_int_t ix;
    double absxi;
    double scl;
    double ssq;
    double result;


    n = i2-i1+1;
    if( n<1 )
    {
        result = 0;
        return result;
    }
    if( n==1 )
    {
        result = ae_fabs(x->ptr.p_double[i1], _state);
        return result;
    }
    scl = 0;
    ssq = 1;
    for(ix=i1; ix<=i2; ix++)
    {
        if( ae_fp_neq(x->ptr.p_double[ix],0) )
        {
            absxi = ae_fabs(x->ptr.p_double[ix], _state);
            if( ae_fp_less(scl,absxi) )
            {
                ssq = 1+ssq*ae_sqr(scl/absxi, _state);
                scl = absxi;
            }
            else
            {
                ssq = ssq+ae_sqr(absxi/scl, _state);
            }
        }
    }
    result = scl*ae_sqrt(ssq, _state);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorpd %xmm0, %xmm0
cmpq %rsi, %rdx
jl 0x1677c
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
jne 0x16685
movq 0x28(%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x26575
jge 0x166a3
movsd 0x1db11(%rip), %xmm0    # 0x341a0
movsd %xmm0, (%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x16769
movq %rdx, %r15
incq %r15
movsd %xmm0, 0x8(%rsp)
movsd 0x1dae9(%rip), %xmm0    # 0x341a0
movsd %xmm0, (%rsp)
movq 0x28(%r12), %rax
movsd (%rax,%r14,8), %xmm0
xorpd %xmm1, %xmm1
callq 0x262dc
testb %al, %al
je 0x1675d
movq 0x28(%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x26575
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x262fe
testb %al, %al
je 0x1673b
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26588
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x1da78(%rip), %xmm1    # 0x341a0
movsd %xmm1, (%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x1675d
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x26588
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r14
cmpq %r14, %r15
jne 0x166bc
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x2658d
mulsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x28(%rdi), %rax
movsd (%rax,%rsi,8), %xmm0
movq %rcx, %rdi
callq 0x26575
cmpq %r14, %r12
jge 0x16818
negq %r14
leaq 0x1(%r12), %r13
movq 0x28(%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x26575
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r15), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x26575
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x2633e
movl %eax, %ecx
movq %r13, %rax
testb %cl, %cl
jne 0x16803
movq %r12, %rax
leaq (%r14,%r13), %rcx
incq %rcx
incq %r13
movq %rax, %r12
cmpq $0x1, %rcx
jne 0x167bf
jmp 0x1681b
movq %r12, %rax
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::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x38(%rdi), %rax
movq (%rax,%rsi,8), %rax
movsd (%rax,%rcx,8), %xmm0
movq %r8, %rdi
callq 0x26575
cmpq %r15, %r13
jge 0x168c5
negq %r15
leaq 0x1(%r13), %rbp
movq 0x38(%r12), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x26575
movsd %xmm0, (%rsp)
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x26575
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x2633e
movl %eax, %ecx
movq %rbp, %rax
testb %cl, %cl
jne 0x168b0
movq %r13, %rax
leaq (%r15,%rbp), %rcx
incq %rcx
incq %rbp
movq %rax, %r13
cmpq $0x1, %rcx
jne 0x16864
jmp 0x168c8
movq %r13, %rax
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::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x38(%rdi), %rax
movq (%rax,%rcx,8), %rax
movsd (%rax,%rsi,8), %xmm0
movq %r8, %rdi
callq 0x26575
cmpq %r15, %r13
jge 0x16972
negq %r15
leaq 0x1(%r13), %rbp
movq 0x38(%r12), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x26575
movsd %xmm0, (%rsp)
movq 0x38(%r12), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x26575
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x2633e
movl %eax, %ecx
movq %rbp, %rax
testb %cl, %cl
jne 0x1695d
movq %r13, %rax
leaq (%r15,%rbp), %rcx
incq %rcx
incq %rbp
movq %rax, %r13
cmpq $0x1, %rcx
jne 0x16912
jmp 0x16975
movq %r13, %rax
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::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rax
movq %rsi, %r13
movq %rdi, %rbp
movq 0x60(%rsp), %rdx
movq %rax, 0x10(%rsp)
subq %rsi, %rax
movq %r8, %rcx
subq %r15, %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
leaq 0x20383(%rip), %rsi     # 0x36d4a
callq 0x2581c
cmpq %r15, %r14
jl 0x169ec
leaq 0x1(%r14), %rax
movq %r15, %rcx
movq 0x28(%rbx), %rdx
movq $0x0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x169d8
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
cmpq %r13, 0x10(%rsp)
jl 0x16a88
movq %r13, %rax
notq %rax
addq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %r12
movq 0x18(%rsp), %rax
leaq (%rax,%r13), %rsi
movq (%rsp), %rdi
movq 0x60(%rsp), %r15
movq %r15, %rdx
callq 0x2660b
cmpq 0x8(%rsp), %rax
jg 0x16a7a
movq %rax, %r14
movq 0x28(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rbp), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %r15, %rdi
callq 0x26575
addsd 0x20(%rsp), %xmm0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x16a3c
leaq 0x1(%r13), %rax
cmpq 0x10(%rsp), %r13
movq %rax, %r13
jne 0x16a18
xorpd %xmm0, %xmm0
movq 0x8(%rsp), %r14
movq (%rsp), %r12
cmpq %r12, %r14
movq 0x60(%rsp), %r15
jl 0x16abc
incq %r14
movq 0x28(%rbx), %rax
movsd (%rax,%r12,8), %xmm1
movq %r15, %rdi
callq 0x26621
incq %r12
cmpq %r12, %r14
jne 0x16aa2
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::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdx, (%rsp)
movq %rdx, %rax
subq %rsi, %rax
setl %sil
movq %rcx, 0x8(%rsp)
subq %rcx, %r8
setl %dl
orb %sil, %dl
jne 0x16bc5
movq %r9, %rbx
movq %rdi, %r15
movq 0x70(%rsp), %rdx
movq 0x60(%rsp), %rbp
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r13
subq %r13, %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
leaq 0x20243(%rip), %rsi     # 0x36d6e
movq %r8, %r14
callq 0x2581c
movq 0x68(%rsp), %rax
subq %rbp, %rax
xorl %edi, %edi
cmpq %rax, %r14
sete %dil
leaq 0x20223(%rip), %rsi     # 0x36d6e
movq 0x70(%rsp), %rdx
callq 0x2581c
incq (%rsp)
leaq (,%rbp,8), %rax
movq %rax, 0x10(%rsp)
shlq $0x3, 0x8(%rsp)
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rbp
addq 0x10(%rsp), %rbp
movq 0x38(%r15), %rax
movq %r15, %r14
movq %rbx, %r15
movq (%rax,%r12,8), %rbx
addq 0x8(%rsp), %rbx
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x2923f
movl $0x1, %esi
movl $0x1, %ecx
movq %rbp, %rdi
movq %rbx, %rdx
movq %r15, %rbx
movq %r14, %r15
movq %rax, %r8
callq 0x28ecd
incq %r12
incq %r13
cmpq %r12, (%rsp)
jne 0x16b6c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq