LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::laguerresum(alglib_impl::ae_vector*, long, double, alglib_impl::ae_state*)
double laguerresum(/* Real    */ ae_vector* c,
     ae_int_t n,
     double x,
     ae_state *_state)
{
    double b1;
    double b2;
    ae_int_t i;
    double result;


    b1 = 0;
    b2 = 0;
    result = 0;
    for(i=n; i>=0; i--)
    {
        result = (2*i+1-x)*b1/(i+1)-(i+1)*b2/(i+2)+c->ptr.p_double[i];
        b2 = b1;
        b1 = result;
    }
    return result;
}

// Assembly:
testq %rsi, %rsi
js 0x10dd7
movq 0x28(%rdi), %rax
leaq 0x1(,%rsi,2), %rcx
incq %rsi
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm3
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
subsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
xorps %xmm4, %xmm4
cvtsi2sd %rsi, %xmm4
divsd %xmm4, %xmm1
mulsd %xmm4, %xmm2
leaq 0x1(%rsi), %rdx
xorps %xmm4, %xmm4
cvtsi2sd %rdx, %xmm4
divsd %xmm4, %xmm2
subsd %xmm2, %xmm1
addsd -0x8(%rax,%rsi,8), %xmm1
decq %rsi
addq $-0x2, %rcx
movapd %xmm3, %xmm2
testq %rsi, %rsi
jg 0x10d87
jmp 0x10ddb
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::laguerrecoefficients(long, alglib::real_1d_array&)
void laguerrecoefficients(const ae_int_t n, real_1d_array &c)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::laguerrecoefficients(n, const_cast<alglib_impl::ae_vector*>(c.c_ptr()), &_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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x256af
movq %r14, %rdi
callq 0x2bec0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10e97
leaq 0x8(%rsp), %rdi
callq 0x25556
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x10e63
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x32d2e(%rip), %rsi     # 0x43b80
leaq 0x2a2b(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x10e68
callq 0x3360
movq %rax, %rbx
jmp 0x10e78
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10e87
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::laguerrecoefficients(long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void laguerrecoefficients(ae_int_t n,
     /* Real    */ ae_vector* c,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(c);

    ae_vector_set_length(c, n+1, _state);
    c->ptr.p_double[0] = 1;
    for(i=0; i<=n-1; i++)
    {
        c->ptr.p_double[i+1] = -c->ptr.p_double[i]*(n-i)/(i+1)/(i+1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25ac7
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x25a42
movq 0x28(%rbx), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
testq %r14, %r14
jle 0x10f16
movl $0x1, %eax
movapd 0x23301(%rip), %xmm0    # 0x341e0
movq 0x28(%rbx), %rcx
movsd -0x8(%rcx,%rax,8), %xmm1
xorpd %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %r14, %xmm2
mulsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, (%rcx,%rax,8)
incq %rax
decq %r14
jne 0x10edf
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::legendrecalculate(long, double)
double legendrecalculate(const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::legendrecalculate(n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %r14, %rdi
callq 0x25556
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x10fcb
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x10f97
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x32bfa(%rip), %rsi     # 0x43b80
leaq 0x28f7(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x10f9c
callq 0x3360
movq %rax, %rbx
jmp 0x10fac
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10fbb
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::legendrecalculate(long, double, alglib_impl::ae_state*)
double legendrecalculate(ae_int_t n, double x, ae_state *_state)
{
    double a;
    double b;
    ae_int_t i;
    double result;


    result = 1;
    a = 1;
    b = x;
    if( n==0 )
    {
        result = a;
        return result;
    }
    if( n==1 )
    {
        result = b;
        return result;
    }
    for(i=2; i<=n; i++)
    {
        result = ((2*i-1)*x*b-(i-1)*a)/i;
        a = b;
        b = result;
    }
    return result;
}

// Assembly:
movsd 0x231cd(%rip), %xmm1    # 0x341a0
testq %rdi, %rdi
je 0x11038
cmpq $0x1, %rdi
jne 0x10fe4
movapd %xmm0, %xmm1
jmp 0x11038
jle 0x11038
movsd 0x231b2(%rip), %xmm2    # 0x341a0
movl $0x1, %eax
movl $0x3, %ecx
movapd %xmm0, %xmm1
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd %xmm0, %xmm1
incq %rax
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
divsd %xmm3, %xmm1
addq $0x2, %rcx
cmpq %rax, %rdi
jne 0x10ffc
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::legendresum(alglib::real_1d_array const&, long, double)
double legendresum(const real_1d_array &c, const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::legendresum(const_cast<alglib_impl::ae_vector*>(c.c_ptr()), n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x256af
movq %r14, %rdi
callq 0x2beba
movq %rax, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x11103
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x110cf
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x32ac2(%rip), %rsi     # 0x43b80
leaq 0x27bf(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x110d4
callq 0x3360
movq %rax, %rbx
jmp 0x110e4
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x110f3
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::legendresum(alglib_impl::ae_vector*, long, double, alglib_impl::ae_state*)
double legendresum(/* Real    */ ae_vector* c,
     ae_int_t n,
     double x,
     ae_state *_state)
{
    double b1;
    double b2;
    ae_int_t i;
    double result;


    b1 = 0;
    b2 = 0;
    result = 0;
    for(i=n; i>=0; i--)
    {
        result = (2*i+1)*x*b1/(i+1)-(i+1)*b2/(i+2)+c->ptr.p_double[i];
        b2 = b1;
        b1 = result;
    }
    return result;
}

// Assembly:
testq %rsi, %rsi
js 0x1116f
movq 0x28(%rdi), %rax
leaq 0x1(,%rsi,2), %rcx
incq %rsi
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm3
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
xorps %xmm4, %xmm4
cvtsi2sd %rsi, %xmm4
divsd %xmm4, %xmm1
mulsd %xmm4, %xmm2
leaq 0x1(%rsi), %rdx
xorps %xmm4, %xmm4
cvtsi2sd %rdx, %xmm4
divsd %xmm4, %xmm2
subsd %xmm2, %xmm1
addsd -0x8(%rax,%rsi,8), %xmm1
decq %rsi
addq $-0x2, %rcx
movapd %xmm3, %xmm2
testq %rsi, %rsi
jg 0x1111f
jmp 0x11173
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::legendrecoefficients(long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void legendrecoefficients(ae_int_t n,
     /* Real    */ ae_vector* c,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(c);

    ae_vector_set_length(c, n+1, _state);
    for(i=0; i<=n; i++)
    {
        c->ptr.p_double[i] = 0;
    }
    c->ptr.p_double[n] = 1;
    for(i=1; i<=n; i++)
    {
        c->ptr.p_double[n] = c->ptr.p_double[n]*(n+i)/2/i;
    }
    for(i=0; i<=n/2-1; i++)
    {
        c->ptr.p_double[n-2*(i+1)] = -c->ptr.p_double[n-2*i]*(n-2*i)*(n-2*i-1)/2/(i+1)/(2*(n-i)-1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25ac7
leaq 0x1(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x25a42
testq %r14, %r14
js 0x11275
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x11261
movq 0x28(%rbx), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%r14,8)
testq %r14, %r14
jle 0x112db
movq %r14, %rax
negq %rax
movl $0x1, %ecx
movsd 0x231c9(%rip), %xmm0    # 0x34468
movq 0x28(%rbx), %rdx
leaq (%r14,%rcx), %rsi
xorps %xmm1, %xmm1
cvtsi2sd %rsi, %xmm1
mulsd (%rdx,%r14,8), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %rcx, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, (%rdx,%r14,8)
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
cmpq $0x1, %rdx
jne 0x1129f
cmpq $0x2, %r14
jl 0x11367
movq %r14, %rax
shrq $0x3f, %rax
addq %r14, %rax
sarq %rax
leaq -0x1(,%r14,2), %rcx
negq %rax
movl $0x1, %edx
movsd 0x2317e(%rip), %xmm0    # 0x34488
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movq 0x28(%rbx), %rsi
mulsd (%rsi,%r14,8), %xmm1
leaq -0x1(%r14), %rdi
xorps %xmm2, %xmm2
cvtsi2sd %rdi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
xorps %xmm3, %xmm3
cvtsi2sd %rcx, %xmm3
divsd %xmm1, %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, -0x10(%rsi,%r14,8)
addq $-0x2, %rcx
leaq (%rax,%rdx), %rsi
incq %rsi
incq %rdx
addq $-0x2, %r14
cmpq $0x1, %rsi
jne 0x1130a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::poissondistribution(long, double)
double poissondistribution(const ae_int_t k, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::poissondistribution(k, m, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x11431
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x113fd
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x32794(%rip), %rsi     # 0x43b80
leaq 0x2491(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x11402
callq 0x3360
movq %rax, %rbx
jmp 0x11412
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x11421
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::poissoncdistribution(long, double)
double poissoncdistribution(const ae_int_t k, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::poissoncdistribution(k, m, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x11540
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x1150c
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x32685(%rip), %rsi     # 0x43b80
leaq 0x2382(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x11511
callq 0x3360
movq %rax, %rbx
jmp 0x11521
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x11530
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invpoissondistribution(long, double)
double invpoissondistribution(const ae_int_t k, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invpoissondistribution(k, y, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x1164f
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x1161b
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x32576(%rip), %rsi     # 0x43b80
leaq 0x2273(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x11620
callq 0x3360
movq %rax, %rbx
jmp 0x11630
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1163f
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::invpoissondistribution(long, double, alglib_impl::ae_state*)
double invpoissondistribution(ae_int_t k, double y, ae_state *_state)
{
    double result;


    ae_assert((k>=0&&ae_fp_greater_eq(y,0))&&ae_fp_less(y,1), "Domain error in InvPoissonDistribution", _state);
    result = invincompletegammac(k+1, y, _state);
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
movsd %xmm0, (%rsp)
js 0x11683
xorps %xmm1, %xmm1
callq 0x2635a
testb %al, %al
je 0x11683
movsd 0x22b29(%rip), %xmm1    # 0x341a0
movsd (%rsp), %xmm0
callq 0x262fe
jmp 0x11685
xorl %eax, %eax
movzbl %al, %edi
leaq 0x251af(%rip), %rsi     # 0x3683e
movq %rbx, %rdx
callq 0x2581c
incq %r14
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movsd (%rsp), %xmm1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64a9
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::studenttdistribution(long, double)
double studenttdistribution(const ae_int_t k, const double t)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::studenttdistribution(k, t, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x11b25
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x11af1
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x320a0(%rip), %rsi     # 0x43b80
leaq 0x1d9d(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x11af6
callq 0x3360
movq %rax, %rbx
jmp 0x11b06
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x11b15
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invstudenttdistribution(long, double)
double invstudenttdistribution(const ae_int_t k, const double p)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invstudenttdistribution(k, p, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x11ee6
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x11eb2
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x31cdf(%rip), %rsi     # 0x43b80
leaq 0x19dc(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x11eb7
callq 0x3360
movq %rax, %rbx
jmp 0x11ec7
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x11ed6
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/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 0x256af
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x121ca
leaq 0x10(%rsp), %rdi
callq 0x25556
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x12196
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x319fb(%rip), %rsi     # 0x43b80
leaq 0x16f8(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x1219b
callq 0x3360
movq %rax, %rbx
jmp 0x121ab
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x121ba
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/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 0x256af
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x128a1
leaq 0x10(%rsp), %rdi
callq 0x25556
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x1286d
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x31324(%rip), %rsi     # 0x43b80
leaq 0x1021(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x12872
callq 0x3360
movq %rax, %rbx
jmp 0x12882
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x12891
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/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 0x266e0
movsd %xmm0, 0x8(%rsp)
movsd 0x23145(%rip), %xmm1    # 0x36380
movsd (%rsp), %xmm0
callq 0x2633e
testb %al, %al
je 0x1327a
movsd 0x21217(%rip), %xmm1    # 0x34468
movsd (%rsp), %xmm0
mulsd %xmm0, %xmm1
addsd 0x2228e(%rip), %xmm1    # 0x354f0
movq %rbx, %rdi
callq 0x266db
movapd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
jmp 0x13299
movsd 0x21206(%rip), %xmm1    # 0x34488
movsd (%rsp), %xmm0
addsd %xmm0, %xmm1
movq %rbx, %rdi
callq 0x266db
divsd 0x8(%rsp), %xmm0
movsd 0x20eff(%rip), %xmm1    # 0x341a0
movapd %xmm1, %xmm2
divsd (%rsp), %xmm2
movsd 0x230d6(%rip), %xmm3    # 0x36388
mulsd %xmm2, %xmm3
addsd 0x230d2(%rip), %xmm3    # 0x36390
mulsd %xmm2, %xmm3
addsd 0x230ce(%rip), %xmm3    # 0x36398
mulsd %xmm2, %xmm3
addsd 0x230ca(%rip), %xmm3    # 0x363a0
mulsd %xmm2, %xmm3
addsd 0x230c6(%rip), %xmm3    # 0x363a8
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
mulsd 0x214de(%rip), %xmm0    # 0x347d0
mulsd %xmm3, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::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 0x25ac7
movq %rbx, %rdi
callq 0x25ac7
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x22ff5(%rip), %rsi     # 0x36aac
movq %r14, %rdx
callq 0x2581c
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
cmpq $0x2, %r12
jl 0x13b9b
movq 0x28(%r15), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x206c9(%rip), %xmm0    # 0x341d0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
leaq -0x1(%r12), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x8(%rsp), %xmm1
subsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movl $0x1, %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x8(%rsp), %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 0x2662f
addsd %xmm0, %xmm0
addsd 0x20655(%rip), %xmm0    # 0x341d0
mulsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x13b38
jmp 0x13bd3
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
mulsd 0x208b9(%rip), %xmm0    # 0x34468
movq 0x28(%r15), %rax
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x20605(%rip), %xmm0    # 0x341d0
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_O1/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 %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, (%rsp)
movq %rsi, %rdi
callq 0x25ac7
movq %rbx, %rdi
callq 0x25ac7
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x22eaa(%rip), %rsi     # 0x36acf
movq %r14, %rdx
callq 0x2581c
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm0
movapd %xmm2, %xmm1
addsd %xmm0, %xmm1
cmpq $0x2, %r12
jl 0x13d50
subsd %xmm2, %xmm0
mulsd 0x207f6(%rip), %xmm0    # 0x34468
movsd %xmm0, 0x8(%rsp)
leaq (%r12,%r12), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x1, %r13d
mulsd 0x207d0(%rip), %xmm1    # 0x34468
movsd %xmm1, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x207c3(%rip), %xmm0    # 0x34470
divsd 0x18(%rsp), %xmm0
movq %r14, %rdi
callq 0x266a9
mulsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, -0x4(%rax,%r13,4)
cmpq $0x1, %r13
jne 0x13cf5
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x204e5(%rip), %xmm0    # 0x341d0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x13d41
movq 0x28(%rbx), %rax
movsd -0xc(%rax,%r13,4), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x204b6(%rip), %xmm0    # 0x341d0
movq 0x28(%r15), %rax
movsd -0x4(%rax,%r13,4), %xmm1
subsd -0xc(%rax,%r13,4), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%rsp), %xmm1
movq 0x28(%rbx), %rax
movsd %xmm1, -0x4(%rax,%r13,4)
addq $0x2, %r13
decq %r12
jne 0x13c9d
jmp 0x13d7c
mulsd 0x20710(%rip), %xmm1    # 0x34468
movq 0x28(%r15), %rax
movsd %xmm1, (%rax)
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x2045c(%rip), %xmm0    # 0x341d0
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_O1/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 0x25ac7
movq %rbx, %rdi
callq 0x25ac7
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x22d23(%rip), %rsi     # 0x36af1
movq %r14, %rdx
callq 0x2581c
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25a42
cmpq $0x2, %r12
jl 0x13ef2
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
movsd (%rsp), %xmm2
addsd %xmm2, %xmm0
subsd %xmm1, %xmm2
mulsd 0x2064d(%rip), %xmm2    # 0x34468
movsd %xmm2, (%rsp)
leaq -0x1(%r12), %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x10(%rsp)
xorl %r13d, %r13d
mulsd 0x2062a(%rip), %xmm0    # 0x34468
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x2061c(%rip), %xmm0    # 0x34470
divsd 0x10(%rsp), %xmm0
movq %r14, %rdi
callq 0x266a9
mulsd (%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
testq %r13, %r13
je 0x13ec8
movq 0x28(%rbx), %rax
movsd -0x8(%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x2032f(%rip), %xmm0    # 0x341d0
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 0x13ee4
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x202f4(%rip), %xmm0    # 0x341d0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
incq %r13
cmpq %r13, %r12
jne 0x13e44
jmp 0x13f29
movsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
mulsd 0x20563(%rip), %xmm0    # 0x34468
movq 0x28(%r15), %rax
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x2662f
addsd %xmm0, %xmm0
addsd 0x202af(%rip), %xmm0    # 0x341d0
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_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
testq %rsi, %rsi
setg %dil
leaq 0x22bb5(%rip), %rsi     # 0x36b13
callq 0x2581c
movb $0x1, %bpl
cmpq $0x1, %rbx
je 0x1408e
movq 0x28(%r14), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
jle 0x13ffb
movl $0x1, %r13d
xorl %r12d, %r12d
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r14), %rax
movsd (%rax,%r13,8), %xmm1
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
callq 0x26626
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r14), %rax
movsd (%rax,%r13,8), %xmm1
movsd 0x10(%rsp), %xmm0
movq %r15, %rdi
callq 0x26621
movsd %xmm0, 0x10(%rsp)
testb $0x1, %r12b
movb $0x1, %r12b
jne 0x13fed
movq 0x28(%r14), %rax
movsd -0x8(%rax,%r13,8), %xmm0
movsd (%rax,%r13,8), %xmm1
callq 0x2635a
movl %eax, %r12d
incq %r13
cmpq %r13, %rbx
jne 0x13f8f
xorb $0x1, %r12b
jmp 0x14004
movsd %xmm0, 0x8(%rsp)
movb $0x1, %r12b
movzbl %r12b, %edi
leaq 0x22b2c(%rip), %rsi     # 0x36b3b
movq %r15, %rdx
callq 0x2581c
cmpq $0x2, %rbx
jl 0x1408e
movsd 0x10(%rsp), %xmm2
subsd 0x8(%rsp), %xmm2
addq $-0x2, %rbx
xorl %r15d, %r15d
movsd %xmm2, 0x10(%rsp)
movq 0x28(%r14), %rax
movsd (%rax,%r15,8), %xmm1
movsd 0x8(%rax,%r15,8), %xmm0
movsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm0
divsd %xmm2, %xmm0
movsd 0x20143(%rip), %xmm4    # 0x341a0
addsd %xmm4, %xmm0
subsd %xmm3, %xmm1
divsd %xmm2, %xmm1
addsd %xmm4, %xmm1
callq 0x262ba
movsd 0x10(%rsp), %xmm2
movl %eax, %ebp
testb %al, %al
jne 0x1408a
leaq 0x1(%r15), %rax
cmpq %r15, %rbx
movq %rax, %r15
jne 0x14036
xorb $0x1, %bpl
movl %ebp, %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::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 $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsp), %rsi
movq %rcx, %rdi
callq 0x2575d
movq %rsp, %rdi
movl $0x3, %ecx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x25b46
movq (%r12), %rbp
movq 0x8(%r12), %r13
movq %r12, %rdi
movq %rsp, %rsi
callq 0x25f14
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x25df3
testq %r15, %r15
jle 0x1417e
xorl %eax, %eax
testq %r14, %r14
jle 0x14176
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cmpq %rbp, %rax
jge 0x14160
cmpq %r13, %rcx
jge 0x14160
movq 0x38(%rsp), %rdx
movq (%rdx,%rax,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq 0x38(%r12), %rdx
movq (%rdx,%rax,8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x14145
incq %rax
cmpq %r15, %rax
jne 0x1413e
movq %rbx, %rdi
callq 0x256fa
addq $0x58, %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::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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x229b4(%rip), %rsi     # 0x36b6a
callq 0x2581c
testq %rbx, %rbx
setle %bpl
jle 0x14207
movq 0x28(%r15), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x26472
testb %al, %al
je 0x14207
movl $0x1, %ecx
movq %rcx, %r12
cmpq %rcx, %rbx
je 0x14200
movq 0x28(%r15), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
callq 0x26472
leaq 0x1(%r12), %rcx
testb %al, %al
jne 0x141dd
cmpq %rbx, %r12
setge %bpl
movl %ebp, %eax
popq %rbx
popq %r12
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::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, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x2295f(%rip), %rsi     # 0x36b95
callq 0x2581c
testq %r14, %r14
setle %bpl
jle 0x1429f
movq 0x28(%r15), %rax
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
je 0x1429f
movl $0x1, %r12d
xorl %r13d, %r13d
movq 0x28(%r15), %rax
movsd 0x8(%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
je 0x1429f
cmpq %r14, %r12
setge %bpl
je 0x1429f
movq 0x28(%r15), %rax
movsd 0x10(%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x26472
addq $0x10, %r13
incq %r12
testb %al, %al
jne 0x14261
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::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, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %edi, %edi
testq %rdx, %rdx
setns %dil
leaq 0x228e6(%rip), %rsi     # 0x36bc1
movq %rcx, %rdx
callq 0x2581c
xorl %edi, %edi
testq %r15, %r15
setns %dil
leaq 0x228f9(%rip), %rsi     # 0x36bec
movq %rbx, %rdx
callq 0x2581c
movq %r15, (%rsp)
testq %r15, %r15
setle %bpl
jle 0x14343
xorl %r13d, %r13d
testq %r14, %r14
jle 0x14336
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
je 0x14343
incq %r15
cmpq %r15, %r14
jne 0x14313
incq %r13
cmpq (%rsp), %r13
setge %bpl
jne 0x1430b
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::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 %rsi, %r14
movq %rdi, %r12
xorl %edi, %edi
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
setns %dil
leaq 0x22893(%rip), %rsi     # 0x36c17
movq %rcx, %rdx
callq 0x2581c
xorl %edi, %edi
testq %r14, %r14
setns %dil
leaq 0x228a7(%rip), %rsi     # 0x36c43
movq %rbx, %rdx
callq 0x2581c
movq %r14, 0x10(%rsp)
testq %r14, %r14
setle %bpl
jle 0x14413
xorl %r13d, %r13d
cmpq $0x0, 0x8(%rsp)
jle 0x14405
xorl %r15d, %r15d
movq 0x8(%rsp), %r14
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r15), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
je 0x14413
movq 0x38(%r12), %rax
movq (%rax,%r13,8), %rax
movsd 0x8(%rax,%r15), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
je 0x14413
addq $0x10, %r15
decq %r14
jne 0x143c5
incq %r13
cmpq 0x10(%rsp), %r13
setge %bpl
jne 0x143b5
andb $0x1, %bpl
movl %ebp, %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::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, %r13
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x2281c(%rip), %rsi     # 0x36c6f
movq %rcx, %rdx
callq 0x2581c
testq %r13, %r13
setle %r12b
jle 0x144c8
leaq -0x1(%r13), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movq %r13, 0x8(%rsp)
cmpb $0x0, 0x4(%rsp)
movl $0x0, %r13d
cmovneq %r14, %r13
movq %r14, %rbp
cmovneq 0x10(%rsp), %rbp
cmpq %rbp, %r13
jg 0x144b7
incq %rbp
movq 0x38(%r15), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x26472
testb %al, %al
je 0x144c8
incq %r13
cmpq %r13, %rbp
jne 0x14495
incq %r14
movq 0x8(%rsp), %r13
cmpq %r13, %r14
setge %r12b
jne 0x14475
andb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq