LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::sinecosineintegrals(double, double&, double&)
void sinecosineintegrals(const double x, double &si, double &ci)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::sinecosineintegrals(x, &si, &ci, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x23772
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x11456
leaq 0x10(%rsp), %rdi
callq 0x23631
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x11422
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x2f76f(%rip), %rsi     # 0x40b80
leaq 0x1300(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x11427
callq 0x3330
movq %rax, %rbx
jmp 0x11437
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x11446
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::hyperbolicsinecosineintegrals(double, double&, double&)
void hyperbolicsinecosineintegrals(const double x, double &shi, double &chi)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::hyperbolicsinecosineintegrals(x, &shi, &chi, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x23772
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x11a9c
leaq 0x10(%rsp), %rdi
callq 0x23631
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x11a68
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x2f129(%rip), %rsi     # 0x40b80
leaq 0xcba(%rip), %rdx       # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x11a6d
callq 0x3330
movq %rax, %rbx
jmp 0x11a7d
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x11a8c
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::gammafunc_gammastirf(double, alglib_impl::ae_state*)
static double gammafunc_gammastirf(double x, ae_state *_state)
{
    double y;
    double w;
    double v;
    double stir;
    double result;


    w = 1/x;
    stir = 7.87311395793093628397E-4;
    stir = -2.29549961613378126380E-4+w*stir;
    stir = -2.68132617805781232825E-3+w*stir;
    stir = 3.47222221605458667310E-3+w*stir;
    stir = 8.33333333333482257126E-2+w*stir;
    w = 1+w*stir;
    y = ae_exp(x, _state);
    if( ae_fp_greater(x,143.01608) )
    {
        v = ae_pow(x, 0.5*x-0.25, _state);
        y = v*(v/y);
    }
    else
    {
        y = ae_pow(x, x-0.5, _state)/y;
    }
    result = 2.50662827463100050242*y*w;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, (%rsp)
callq 0x24569
movsd %xmm0, 0x8(%rsp)
movsd 0x1f9dc(%rip), %xmm1    # 0x31b10
movsd (%rsp), %xmm0
callq 0x24279
testb %al, %al
je 0x12173
movsd 0x1e33e(%rip), %xmm1    # 0x30488
movsd (%rsp), %xmm0
mulsd %xmm0, %xmm1
addsd 0x1f18d(%rip), %xmm1    # 0x312e8
movq %rbx, %rdi
callq 0x24564
movapd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
jmp 0x12192
movsd 0x1e32d(%rip), %xmm1    # 0x304a8
movsd (%rsp), %xmm0
addsd %xmm0, %xmm1
movq %rbx, %rdi
callq 0x24564
divsd 0x8(%rsp), %xmm0
movsd 0x1e05e(%rip), %xmm1    # 0x301f8
movapd %xmm1, %xmm2
divsd (%rsp), %xmm2
movsd 0x1f96d(%rip), %xmm3    # 0x31b18
mulsd %xmm2, %xmm3
addsd 0x1f969(%rip), %xmm3    # 0x31b20
mulsd %xmm2, %xmm3
addsd 0x1f965(%rip), %xmm3    # 0x31b28
mulsd %xmm2, %xmm3
addsd 0x1f961(%rip), %xmm3    # 0x31b30
mulsd %xmm2, %xmm3
addsd 0x1f95d(%rip), %xmm3    # 0x31b38
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
mulsd 0x1e52d(%rip), %xmm0    # 0x30718
mulsd %xmm3, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::taskgenint1dequidist(double, double, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void taskgenint1dequidist(double a,
     double b,
     ae_int_t n,
     /* Real    */ ae_vector* x,
     /* Real    */ ae_vector* y,
     ae_state *_state)
{
    ae_int_t i;
    double h;

    ae_vector_clear(x);
    ae_vector_clear(y);

    ae_assert(n>=1, "TaskGenInterpolationEqdist1D: N<1!", _state);
    ae_vector_set_length(x, n, _state);
    ae_vector_set_length(y, n, _state);
    if( n>1 )
    {
        x->ptr.p_double[0] = a;
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
        h = (b-a)/(n-1);
        for(i=1; i<=n-1; i++)
        {
            x->ptr.p_double[i] = a+i*h;
            y->ptr.p_double[i] = y->ptr.p_double[i-1]+(2*ae_randomreal(_state)-1)*h;
        }
    }
    else
    {
        x->ptr.p_double[0] = 0.5*(a+b);
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rdi
callq 0x23b55
movq %rbx, %rdi
callq 0x23b55
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x202e2(%rip), %rsi     # 0x32c24
movq %r14, %rdx
callq 0x238ca
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
cmpq $0x2, %r12
jl 0x12a24
movq 0x28(%r15), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d86e(%rip), %xmm0    # 0x30200
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
leaq -0x1(%r12), %rax
cvtsi2sd %rax, %xmm0
movsd 0x8(%rsp), %xmm1
subsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
pushq $0x1
popq %r13
movsd %xmm1, 0x8(%rsp)
cmpq %r13, %r12
je 0x12a5c
cvtsi2sd %r13, %xmm0
mulsd %xmm1, %xmm0
addsd 0x10(%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
movq 0x28(%rbx), %rax
movsd -0x8(%rax,%r13,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
callq 0x244c4
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm0
addsd 0x1d7f5(%rip), %xmm0    # 0x30200
mulsd %xmm1, %xmm0
addsd 0x18(%rsp), %xmm0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x129be
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
mulsd 0x1da50(%rip), %xmm0    # 0x30488
movq 0x28(%r15), %rax
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d7ac(%rip), %xmm0    # 0x30200
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::taskgenint1dcheb1(double, double, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void taskgenint1dcheb1(double a,
     double b,
     ae_int_t n,
     /* Real    */ ae_vector* x,
     /* Real    */ ae_vector* y,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(x);
    ae_vector_clear(y);

    ae_assert(n>=1, "TaskGenInterpolation1DCheb1: N<1!", _state);
    ae_vector_set_length(x, n, _state);
    ae_vector_set_length(y, n, _state);
    if( n>1 )
    {
        for(i=0; i<=n-1; i++)
        {
            x->ptr.p_double[i] = 0.5*(b+a)+0.5*(b-a)*ae_cos(ae_pi*(2*i+1)/(2*n), _state);
            if( i==0 )
            {
                y->ptr.p_double[i] = 2*ae_randomreal(_state)-1;
            }
            else
            {
                y->ptr.p_double[i] = y->ptr.p_double[i-1]+(2*ae_randomreal(_state)-1)*(x->ptr.p_double[i]-x->ptr.p_double[i-1]);
            }
        }
    }
    else
    {
        x->ptr.p_double[0] = 0.5*(a+b);
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rdi
callq 0x23b55
movq %rbx, %rdi
callq 0x23b55
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x20197(%rip), %rsi     # 0x32c47
movq %r14, %rdx
callq 0x238ca
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movapd %xmm2, %xmm0
addsd %xmm1, %xmm0
cmpq $0x2, %r12
jl 0x12bd5
subsd %xmm2, %xmm1
mulsd 0x1d98a(%rip), %xmm1    # 0x30488
leaq (%r12,%r12), %rax
cvtsi2sd %rax, %xmm2
movsd %xmm2, 0x18(%rsp)
pushq $0x1
popq %r13
xorl %ebp, %ebp
mulsd 0x1d96d(%rip), %xmm0    # 0x30488
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x20(%rsp)
cmpq %rbp, %r12
je 0x12c01
cvtsi2sd %r13, %xmm0
mulsd 0x1d953(%rip), %xmm0    # 0x30490
divsd 0x18(%rsp), %xmm0
movq %r14, %rdi
callq 0x24532
mulsd 0x8(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, (%rax,%rbp,8)
testq %rbp, %rbp
je 0x12bad
movq 0x28(%rbx), %rax
movsd -0x8(%rax,%rbp,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d677(%rip), %xmm0    # 0x30200
movq 0x28(%r15), %rax
movsd (%rax,%rbp,8), %xmm1
subsd -0x8(%rax,%rbp,8), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%rsp), %xmm1
movq 0x28(%rbx), %rax
movsd %xmm1, (%rax,%rbp,8)
jmp 0x12bc9
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d63f(%rip), %xmm0    # 0x30200
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
incq %rbp
addq $0x2, %r13
jmp 0x12b27
mulsd 0x1d8ab(%rip), %xmm0    # 0x30488
movq 0x28(%r15), %rax
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d607(%rip), %xmm0    # 0x30200
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::taskgenint1dcheb2(double, double, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void taskgenint1dcheb2(double a,
     double b,
     ae_int_t n,
     /* Real    */ ae_vector* x,
     /* Real    */ ae_vector* y,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(x);
    ae_vector_clear(y);

    ae_assert(n>=1, "TaskGenInterpolation1DCheb2: N<1!", _state);
    ae_vector_set_length(x, n, _state);
    ae_vector_set_length(y, n, _state);
    if( n>1 )
    {
        for(i=0; i<=n-1; i++)
        {
            x->ptr.p_double[i] = 0.5*(b+a)+0.5*(b-a)*ae_cos(ae_pi*i/(n-1), _state);
            if( i==0 )
            {
                y->ptr.p_double[i] = 2*ae_randomreal(_state)-1;
            }
            else
            {
                y->ptr.p_double[i] = y->ptr.p_double[i-1]+(2*ae_randomreal(_state)-1)*(x->ptr.p_double[i]-x->ptr.p_double[i-1]);
            }
        }
    }
    else
    {
        x->ptr.p_double[0] = 0.5*(a+b);
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdi
callq 0x23b55
movq %rbx, %rdi
callq 0x23b55
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x20015(%rip), %rsi     # 0x32c69
movq %r14, %rdx
callq 0x238ca
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
cmpq $0x2, %r12
jl 0x12d75
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
movsd (%rsp), %xmm2
addsd %xmm2, %xmm0
subsd %xmm1, %xmm2
mulsd 0x1d7e7(%rip), %xmm2    # 0x30488
leaq -0x1(%r12), %rax
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x10(%rsp)
xorl %r13d, %r13d
mulsd 0x1d7cc(%rip), %xmm0    # 0x30488
movsd %xmm0, 0x18(%rsp)
movsd %xmm2, (%rsp)
cmpq %r13, %r12
je 0x12dac
cvtsi2sd %r13, %xmm0
mulsd 0x1d7b3(%rip), %xmm0    # 0x30490
divsd 0x10(%rsp), %xmm0
movq %r14, %rdi
callq 0x24532
mulsd (%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
testq %r13, %r13
je 0x12d51
movq 0x28(%rbx), %rax
movsd -0x8(%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d4d6(%rip), %xmm0    # 0x30200
movq 0x28(%r15), %rax
movsd (%rax,%r13,8), %xmm1
subsd -0x8(%rax,%r13,8), %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rsp), %xmm1
movq 0x28(%rbx), %rax
movsd %xmm1, (%rax,%r13,8)
jmp 0x12d6d
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d49b(%rip), %xmm0    # 0x30200
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
incq %r13
jmp 0x12cc7
movsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
mulsd 0x1d700(%rip), %xmm0    # 0x30488
movq 0x28(%r15), %rax
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x244c4
addsd %xmm0, %xmm0
addsd 0x1d45c(%rip), %xmm0    # 0x30200
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::aredistinct(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool aredistinct(/* Real    */ ae_vector* x,
     ae_int_t n,
     ae_state *_state)
{
    double a;
    double b;
    ae_int_t i;
    ae_bool nonsorted;
    ae_bool result;


    ae_assert(n>=1, "APSERVAreDistinct: internal error (N<1)", _state);
    if( n==1 )
    {
        
        /*
         * everything is alright, it is up to caller to decide whether it
         * can interpolate something with just one point
         */
        result = ae_true;
        return result;
    }
    a = x->ptr.p_double[0];
    b = x->ptr.p_double[0];
    nonsorted = ae_false;
    for(i=1; i<=n-1; i++)
    {
        a = ae_minreal(a, x->ptr.p_double[i], _state);
        b = ae_maxreal(b, x->ptr.p_double[i], _state);
        nonsorted = nonsorted||ae_fp_greater_eq(x->ptr.p_double[i-1],x->ptr.p_double[i]);
    }
    ae_assert(!nonsorted, "APSERVAreDistinct: internal error (not sorted)", _state);
    for(i=1; i<=n-1; i++)
    {
        if( ae_fp_eq((x->ptr.p_double[i]-a)/(b-a)+1,(x->ptr.p_double[i-1]-a)/(b-a)+1) )
        {
            result = ae_false;
            return result;
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
testq %rsi, %rsi
setg %dil
leaq 0x1feac(%rip), %rsi     # 0x32c8b
callq 0x238ca
movb $0x1, %bpl
cmpq $0x1, %rbx
je 0x12eec
movq 0x28(%r14), %rax
movsd (%rax), %xmm0
pushq $0x1
popq %r12
xorl %ebp, %ebp
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, (%rsp)
cmpq %rbx, %r12
jge 0x12e6e
movq 0x28(%r14), %rax
movsd (%rax,%r12,8), %xmm1
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
callq 0x244bb
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r14), %rax
movsd (%rax,%r12,8), %xmm1
movsd (%rsp), %xmm0
movq %r15, %rdi
callq 0x244b6
movsd %xmm0, (%rsp)
movb $0x1, %al
testb $0x1, %bpl
jne 0x12e67
movq 0x28(%r14), %rax
movsd -0x8(%rax,%r12,8), %xmm0
movsd (%rax,%r12,8), %xmm1
callq 0x24295
incq %r12
movl %eax, %ebp
jmp 0x12e0a
notb %bpl
movzbl %bpl, %edi
andl $0x1, %edi
leaq 0x1fe34(%rip), %rsi     # 0x32cb3
movq %r15, %rdx
callq 0x238ca
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
pushq $0x1
popq %r15
cmpq %rbx, %r15
setge %bpl
jge 0x12eec
movq 0x28(%r14), %rax
movsd -0x8(%rax,%r15,8), %xmm1
movsd (%rax,%r15,8), %xmm0
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm0
movsd (%rsp), %xmm3
divsd %xmm3, %xmm0
movsd 0x1d328(%rip), %xmm4    # 0x301f8
addsd %xmm4, %xmm0
subsd %xmm2, %xmm1
divsd %xmm3, %xmm1
addsd %xmm4, %xmm1
callq 0x241f5
incq %r15
testb %al, %al
je 0x12e9b
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::rmatrixresize(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
void rmatrixresize(/* Real    */ ae_matrix* x,
     ae_int_t m,
     ae_int_t n,
     ae_state *_state)
{
    ae_frame _frame_block;
    ae_matrix oldx;
    ae_int_t i;
    ae_int_t j;
    ae_int_t m2;
    ae_int_t n2;

    ae_frame_make(_state, &_frame_block);
    ae_matrix_init(&oldx, 0, 0, DT_REAL, _state, ae_true);

    m2 = x->rows;
    n2 = x->cols;
    ae_swap_matrices(x, &oldx);
    ae_matrix_set_length(x, m, n, _state);
    for(i=0; i<=m-1; i++)
    {
        for(j=0; j<=n-1; j++)
        {
            if( i<m2&&j<n2 )
            {
                x->ptr.pp_double[i][j] = oldx.ptr.pp_double[i][j];
            }
            else
            {
                x->ptr.pp_double[i][j] = 0.0;
            }
        }
    }
    ae_frame_leave(_state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x50(%rsp), %rsi
movq %rcx, %rdi
movq %rcx, 0x8(%rsp)
callq 0x23815
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rcx
pushq $0x1
popq %r9
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r8
callq 0x23baa
movq (%r12), %r13
movq 0x8(%r12), %rbx
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x23f0c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
callq 0x23e0a
testq %r14, %r14
cmovleq %rbp, %r14
testq %r15, %r15
cmovleq %rbp, %r15
cmpq %r15, %rbp
je 0x12fe9
xorl %eax, %eax
cmpq %rax, %r14
je 0x12fe4
xorps %xmm0, %xmm0
cmpq %r13, %rbp
jge 0x12fd1
cmpq %rbx, %rax
jge 0x12fd1
movq 0x48(%rsp), %rcx
movq (%rcx,%rbp,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq 0x38(%r12), %rcx
movq (%rcx,%rbp,8), %rcx
movsd %xmm0, (%rcx,%rax,8)
incq %rax
jmp 0x12fb1
incq %rbp
jmp 0x12faa
movq 0x8(%rsp), %rdi
callq 0x237b6
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::isfinitevector(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool isfinitevector(/* Real    */ ae_vector* x,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteVector: internal error (N<0)", _state);
    for(i=0; i<=n-1; i++)
    {
        if( !ae_isfinite(x->ptr.p_double[i], _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 %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %r13d, %r13d
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
movl $0x0, %r12d
cmovgq %rsi, %r12
leaq 0x1fcaf(%rip), %rsi     # 0x32ce2
callq 0x238ca
movq %r13, %rbp
cmpq %r13, %r12
je 0x13059
movq 0x28(%r15), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r14, %rdi
callq 0x243ad
leaq 0x1(%rbp), %r13
testb %al, %al
jne 0x13038
cmpq %rbx, %rbp
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::isfinitecvector(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool isfinitecvector(/* Complex */ ae_vector* z,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteCVector: internal error (N<0)", _state);
    for(i=0; i<=n-1; i++)
    {
        if( !ae_isfinite(z->ptr.p_complex[i].x, _state)||!ae_isfinite(z->ptr.p_complex[i].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
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
movl $0x0, %r13d
cmovgq %rsi, %r13
leaq 0x1fc6e(%rip), %rsi     # 0x32d0d
callq 0x238ca
xorl %ecx, %ecx
movq %rcx, %rbp
cmpq %rcx, %r13
je 0x130e3
movq 0x28(%r15), %rax
movsd (%rax,%r12), %xmm0
movq %r14, %rdi
callq 0x243ad
testb %al, %al
je 0x130e3
movq 0x28(%r15), %rax
movsd 0x8(%rax,%r12), %xmm0
movq %r14, %rdi
callq 0x243ad
leaq 0x1(%rbp), %rcx
addq $0x10, %r12
testb %al, %al
jne 0x130a6
cmpq %rbx, %rbp
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apservisfinitematrix(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool apservisfinitematrix(/* 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, "APSERVIsFiniteMatrix: internal error (N<0)", _state);
    ae_assert(m>=0, "APSERVIsFiniteMatrix: 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) )
            {
                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, %r15
movq %rdi, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
testq %rsi, %rsi
setns %bpl
movl $0x0, %r14d
movq %rsi, (%rsp)
cmovgq %rsi, %r14
xorl %edi, %edi
testq %rdx, %rdx
setns %dil
leaq 0x1fc03(%rip), %rsi     # 0x32d39
cmovleq %r13, %r15
movq %rcx, %rdx
callq 0x238ca
movl %ebp, %edi
leaq 0x1fc19(%rip), %rsi     # 0x32d64
movq %rbx, %rdx
callq 0x238ca
cmpq %r14, %r13
je 0x13183
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x1317e
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x243ad
incq %rbp
testb %al, %al
jne 0x1315a
jmp 0x13183
incq %r13
jmp 0x13153
cmpq (%rsp), %r13
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apservisfinitecmatrix(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool apservisfinitecmatrix(/* Complex */ 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, "APSERVIsFiniteCMatrix: internal error (N<0)", _state);
    ae_assert(m>=0, "APSERVIsFiniteCMatrix: 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_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
movq %rdx, %r14
movq %rdi, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
testq %rsi, %rsi
setns %bpl
movl $0x0, %r15d
movq %rsi, 0x8(%rsp)
cmovgq %rsi, %r15
xorl %edi, %edi
testq %rdx, %rdx
setns %dil
leaq 0x1fbb4(%rip), %rsi     # 0x32d8f
cmovleq %r13, %r14
movq %rcx, %rdx
callq 0x238ca
movl %ebp, %edi
leaq 0x1fbcb(%rip), %rsi     # 0x32dbb
movq %rbx, %rdx
callq 0x238ca
incq %r14
movq %r14, 0x10(%rsp)
cmpq %r15, %r13
je 0x13257
movq %r15, %r14
xorl %ebp, %ebp
movq 0x10(%rsp), %r15
decq %r15
je 0x1324f
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp), %xmm0
movq %rbx, %rdi
callq 0x243ad
testb %al, %al
je 0x13257
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd 0x8(%rax,%rbp), %xmm0
addq $0x10, %rbp
movq %rbx, %rdi
callq 0x243ad
testb %al, %al
jne 0x1320f
jmp 0x13257
incq %r13
movq %r14, %r15
jmp 0x13200
cmpq 0x8(%rsp), %r13
setge %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::isfinitertrmatrix(alglib_impl::ae_matrix*, long, bool, alglib_impl::ae_state*)
ae_bool isfinitertrmatrix(/* Real    */ 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, "APSERVIsFiniteRTRMatrix: 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_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
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq %rdi, %r15
xorl %r14d, %r14d
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
movl $0x0, %r13d
cmovgq %rsi, %r13
leaq 0x1fb41(%rip), %rsi     # 0x32de7
movq %rcx, %rdx
callq 0x238ca
movq %r12, 0x8(%rsp)
leaq -0x1(%r12), %rax
movq %rax, 0x10(%rsp)
cmpq %r13, %r14
je 0x13301
cmpb $0x0, 0x4(%rsp)
movl $0x0, %ebp
cmovneq %r14, %rbp
movq %r14, %r12
cmovneq 0x10(%rsp), %r12
cmpq %r12, %rbp
jg 0x132fc
movq 0x38(%r15), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x243ad
incq %rbp
testb %al, %al
jne 0x132d9
jmp 0x13301
incq %r14
jmp 0x132bd
cmpq 0x8(%rsp), %r14
setge %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rcx, %rbx
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
movl $0x0, %r13d
cmovgq %rsi, %r13
leaq 0x1fac5(%rip), %rsi     # 0x32e15
movq %rcx, %rdx
callq 0x238ca
movq %r14, 0x18(%rsp)
leaq -0x1(%r14), %rax
movq %rax, 0x20(%rsp)
movq %r13, 0x10(%rsp)
cmpq %r13, %r12
je 0x133dd
cmpb $0x0, 0xc(%rsp)
movl $0x0, %r13d
cmovneq %r12, %r13
movq %r12, %r14
cmovneq 0x20(%rsp), %r14
movq %r13, %rbp
shlq $0x4, %rbp
decq %r13
incq %r13
cmpq %r14, %r13
jg 0x133d3
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rax
movsd (%rax,%rbp), %xmm0
movq %rbx, %rdi
callq 0x243ad
testb %al, %al
je 0x133dd
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rax
movsd 0x8(%rax,%rbp), %xmm0
addq $0x10, %rbp
movq %rbx, %rdi
callq 0x243ad
testb %al, %al
jne 0x13392
jmp 0x133dd
incq %r12
movq 0x10(%rsp), %r13
jmp 0x1336b
cmpq 0x18(%rsp), %r12
setge %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
testq %rsi, %rsi
setns %bpl
movl $0x0, %r14d
movq %rsi, (%rsp)
cmovgq %rsi, %r14
xorl %edi, %edi
testq %rdx, %rdx
setns %dil
leaq 0x1fa11(%rip), %rsi     # 0x32e43
cmovleq %r13, %r15
movq %rcx, %rdx
callq 0x238ca
movl %ebp, %edi
leaq 0x1fa2c(%rip), %rsi     # 0x32e73
movq %rbx, %rdx
callq 0x238ca
cmpq %r14, %r13
je 0x13499
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x13494
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x243ad
testb %al, %al
jne 0x1348f
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x243cc
testb %al, %al
je 0x13499
incq %rbp
jmp 0x13456
incq %r13
jmp 0x1344f
cmpq (%rsp), %r13
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2440c
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2440c
movaps %xmm0, %xmm1
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x244b6
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rdi
callq 0x244bb
xorpd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
callq 0x241f5
testb %al, %al
jne 0x1354e
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2441f
addsd 0x1ccc2(%rip), %xmm0    # 0x301f8
movq %rbx, %rdi
callq 0x24424
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_O2/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 0x2440c
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2440c
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2440c
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movq %rbx, %rdi
callq 0x244b6
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x244b6
xorpd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
callq 0x241f5
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x13655
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 0x2441f
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2441f
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2441f
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x24424
mulsd 0x10(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rsi)
callq 0x24239
movzbl %al, %edi
leaq 0x1f607(%rip), %rsi     # 0x32ea3
movq %r14, %rdx
callq 0x238ca
movsd (%rbx), %xmm0
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rsp)
divsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x24468
cvtsi2sd %rax, %xmm1
movsd %xmm1, (%r15)
movsd (%rbx), %xmm0
mulsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movsd 0x8(%rsp), %xmm1
callq 0x24239
testb %al, %al
je 0x1393b
movsd (%rbx), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
addsd 0x1c8ec(%rip), %xmm0    # 0x30200
movsd %xmm0, (%r15)
movsd (%rbx), %xmm0
jmp 0x138ea
subsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
addsd 0x1c8c2(%rip), %xmm0    # 0x301f8
movsd %xmm0, (%r15)
movsd (%rbx), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x24279
movsd (%rbx), %xmm0
testb %al, %al
jne 0x1391f
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
callq 0x244b6
movsd %xmm0, (%rbx)
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x244bb
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jns 0x13a5f
movq (%rsi), %r14
movq %rbx, %rdi
callq 0x2550d
xorl %r15d, %r15d
testq %r14, %r14
cmovgq %r14, %r15
subq $0x1, %r15
jb 0x13a81
movq %rbx, %rdi
callq 0x2550d
jmp 0x13a71
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13aa4
movq (%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x25676
xorl %r13d, %r13d
testq %r15, %r15
cmovleq %r13, %r15
cmpq %r13, %r15
je 0x13adb
movq 0x28(%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2573e
incq %r13
jmp 0x13abc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23b55
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25821
movq (%r12), %rsi
testq %rsi, %rsi
je 0x13b59
movq %r14, %rdi
movq %rbx, %rdx
callq 0x23add
xorl %r13d, %r13d
movq %rsp, %r12
cmpq 0x8(%rsp), %r13
jge 0x13b59
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25840
movsd (%rsp), %xmm0
movq 0x28(%r14), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x13b30
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jns 0x13b7a
movq (%rsi), %r14
movq %rbx, %rdi
callq 0x2550d
xorl %r15d, %r15d
testq %r14, %r14
cmovgq %r14, %r15
subq $0x1, %r15
jb 0x13b9c
movq %rbx, %rdi
callq 0x2550d
jmp 0x13b8c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13bbf
movq (%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x25676
xorl %r13d, %r13d
testq %r15, %r15
cmovleq %r13, %r15
cmpq %r13, %r15
je 0x13bf4
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x25676
incq %r13
jmp 0x13bd7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23b55
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25821
movq (%r12), %rsi
testq %rsi, %rsi
je 0x13c6f
movq %r14, %rdi
movq %rbx, %rdx
callq 0x23add
xorl %r13d, %r13d
movq %rsp, %r12
cmpq 0x8(%rsp), %r13
jge 0x13c6f
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25821
movq (%rsp), %rax
movq 0x28(%r14), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x13c49
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13c97
movq (%rsi), %r14
testq %rbx, %rbx
jns 0x13ca0
movq 0x8(%rsi), %rbx
movq %r15, %rdi
callq 0x2550d
movq %r15, %rdi
callq 0x2550d
xorl %r12d, %r12d
testq %rbx, %rbx
cmovleq %r12, %rbx
testq %r14, %r14
cmovleq %r12, %r14
cmpq %r14, %r12
je 0x13cde
movq %rbx, %r13
subq $0x1, %r13
jb 0x13cd9
movq %r15, %rdi
callq 0x2550d
jmp 0x13cc9
incq %r12
jmp 0x13cc1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
testq %rdx, %rdx
jns 0x13d0a
movq (%r15), %r12
testq %r14, %r14
jns 0x13d13
movq 0x8(%r15), %r14
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25676
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25676
xorl %ebp, %ebp
testq %r14, %r14
cmovleq %rbp, %r14
testq %r12, %r12
cmovleq %rbp, %r12
movq %r12, (%rsp)
cmpq (%rsp), %rbp
je 0x13d74
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x13d6f
movq 0x38(%r15), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2573e
incq %r12
jmp 0x13d4c
incq %rbp
jmp 0x13d43
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23eed
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25821
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x25821
movq (%r12), %rsi
testq %rsi, %rsi
sete %al
movq (%r13), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x13def
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rcx
callq 0x23e0a
xorl %r13d, %r13d
movq %rsp, %r12
cmpq 0x10(%rsp), %r13
jge 0x13de0
xorl %ebp, %ebp
cmpq 0x8(%rsp), %rbp
jge 0x13e35
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25840
movsd (%rsp), %xmm0
movq 0x38(%r14), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x13e09
incq %r13
jmp 0x13e00
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23b55
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x13e7f
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23add
xorl %eax, %eax
cmpq (%r14), %rax
jge 0x13e7f
movq 0x28(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x28(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
jmp 0x13e65
popq %rbx
popq %r14
popq %r15
retq