LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::fromchebyshev(alglib_impl::ae_vector*, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void fromchebyshev(/* Real    */ ae_vector* a,
     ae_int_t n,
     /* Real    */ ae_vector* b,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t k;
    double e;
    double d;

    ae_vector_clear(b);

    ae_vector_set_length(b, n+1, _state);
    for(i=0; i<=n; i++)
    {
        b->ptr.p_double[i] = 0;
    }
    d = 0;
    i = 0;
    do
    {
        k = i;
        do
        {
            e = b->ptr.p_double[k];
            b->ptr.p_double[k] = 0;
            if( i<=1&&k==i )
            {
                b->ptr.p_double[k] = 1;
            }
            else
            {
                if( i!=0 )
                {
                    b->ptr.p_double[k] = 2*d;
                }
                if( k>i+1 )
                {
                    b->ptr.p_double[k] = b->ptr.p_double[k]-b->ptr.p_double[k-2];
                }
            }
            d = e;
            k = k+1;
        }
        while(k<=n);
        d = b->ptr.p_double[i];
        e = 0;
        k = i;
        while(k<=n)
        {
            e = e+b->ptr.p_double[k]*a->ptr.p_double[k];
            k = k+2;
        }
        b->ptr.p_double[i] = e;
        i = i+1;
    }
    while(i<=n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x25ac7
leaq 0x1(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x25a42
testq %r14, %r14
js 0xceed
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0xced9
xorl %eax, %eax
testq %r14, %r14
movl $0x0, %ecx
cmovgq %r14, %rcx
xorpd %xmm0, %xmm0
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
xorl %esi, %esi
movq %rsi, %rdi
incq %rsi
xorl %r8d, %r8d
movapd %xmm0, %xmm1
cmpq $0x2, %rdi
setae %r9b
movq 0x28(%rbx), %r10
addq %rax, %r10
movsd (%r10,%r8,8), %xmm0
movq $0x0, (%r10,%r8,8)
testq %r8, %r8
setne %r10b
orb %r9b, %r10b
jne 0xcf4e
movq 0x28(%rbx), %r9
addq %rax, %r9
movq %rdx, (%r9,%r8,8)
jmp 0xcf87
testq %rdi, %rdi
je 0xcf64
addsd %xmm1, %xmm1
movq 0x28(%rbx), %r9
addq %rax, %r9
movsd %xmm1, (%r9,%r8,8)
leaq (%rdi,%r8), %r9
cmpq %rsi, %r9
jbe 0xcf87
movq 0x28(%rbx), %r9
addq %rax, %r9
movsd (%r9,%r8,8), %xmm1
subsd -0x10(%r9,%r8,8), %xmm1
movsd %xmm1, (%r9,%r8,8)
leaq (%rdi,%r8), %r9
incq %r9
incq %r8
decq %r9
cmpq %r14, %r9
jl 0xcf14
movq 0x28(%rbx), %r8
movsd (%r8,%rdi,8), %xmm0
xorpd %xmm1, %xmm1
cmpq %r14, %rdi
jg 0xcfd0
movq 0x28(%r15), %r9
movq %rdi, %r10
movsd (%r8,%r10,8), %xmm2
mulsd (%r9,%r10,8), %xmm2
addsd %xmm2, %xmm1
addq $0x2, %r10
cmpq %r14, %r10
jle 0xcfb7
movsd %xmm1, (%r8,%rdi,8)
addq $0x8, %rax
cmpq %rcx, %rdi
jne 0xcf0b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::chisquaredistribution(double, double)
double chisquaredistribution(const double v, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::chisquaredistribution(v, 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 $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd0b5
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd081
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x36b10(%rip), %rsi     # 0x43b80
leaq 0x680d(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xd086
callq 0x3360
movq %rax, %rbx
jmp 0xd096
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd0a5
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::chisquaredistribution(double, double, alglib_impl::ae_state*)
double chisquaredistribution(double v, double x, ae_state *_state)
{
    double result;


    ae_assert(ae_fp_greater_eq(x,0)&&ae_fp_greater_eq(v,1), "Domain error in ChiSquareDistribution", _state);
    result = incompletegamma(v/2.0, x/2.0, _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps %xmm1, %xmm2
movsd %xmm0, (%rsp)
xorps %xmm1, %xmm1
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
callq 0x2635a
testb %al, %al
je 0xd0ee
movsd 0x270be(%rip), %xmm1    # 0x341a0
movsd (%rsp), %xmm0
callq 0x2635a
jmp 0xd0f0
xorl %eax, %eax
movzbl %al, %edi
leaq 0x2959d(%rip), %rsi     # 0x36697
movq %rbx, %rdx
callq 0x2581c
movsd 0x2735e(%rip), %xmm2    # 0x34468
movsd (%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x5e8e
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::chisquarecdistribution(double, double)
double chisquarecdistribution(const double v, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::chisquarecdistribution(v, 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 $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd1f2
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd1be
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x369d3(%rip), %rsi     # 0x43b80
leaq 0x66d0(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xd1c3
callq 0x3360
movq %rax, %rbx
jmp 0xd1d3
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd1e2
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::chisquarecdistribution(double, double, alglib_impl::ae_state*)
double chisquarecdistribution(double v, double x, ae_state *_state)
{
    double result;


    ae_assert(ae_fp_greater_eq(x,0)&&ae_fp_greater_eq(v,1), "Domain error in ChiSquareDistributionC", _state);
    result = incompletegammac(v/2.0, x/2.0, _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps %xmm1, %xmm2
movsd %xmm0, (%rsp)
xorps %xmm1, %xmm1
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
callq 0x2635a
testb %al, %al
je 0xd22b
movsd 0x26f81(%rip), %xmm1    # 0x341a0
movsd (%rsp), %xmm0
callq 0x2635a
jmp 0xd22d
xorl %eax, %eax
movzbl %al, %edi
leaq 0x29486(%rip), %rsi     # 0x366bd
movq %rbx, %rdx
callq 0x2581c
movsd 0x27221(%rip), %xmm2    # 0x34468
movsd (%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x60f1
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invchisquaredistribution(double, double)
double invchisquaredistribution(const double v, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invchisquaredistribution(v, 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 $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd32f
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd2fb
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x36896(%rip), %rsi     # 0x43b80
leaq 0x6593(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xd300
callq 0x3360
movq %rax, %rbx
jmp 0xd310
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd31f
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::invchisquaredistribution(double, double, alglib_impl::ae_state*)
double invchisquaredistribution(double v, double y, ae_state *_state)
{
    double result;


    ae_assert((ae_fp_greater_eq(y,0)&&ae_fp_less_eq(y,1))&&ae_fp_greater_eq(v,1), "Domain error in InvChiSquareDistribution", _state);
    result = 2*invincompletegammac(0.5*v, y, _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps %xmm1, %xmm2
movsd %xmm0, (%rsp)
xorps %xmm1, %xmm1
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
callq 0x2635a
testb %al, %al
je 0xd37f
movsd 0x26e44(%rip), %xmm1    # 0x341a0
movsd 0x8(%rsp), %xmm0
callq 0x2631e
testb %al, %al
je 0xd37f
movsd 0x26e2d(%rip), %xmm1    # 0x341a0
movsd (%rsp), %xmm0
callq 0x2635a
jmp 0xd381
xorl %eax, %eax
movzbl %al, %edi
leaq 0x29359(%rip), %rsi     # 0x366e4
movq %rbx, %rdx
callq 0x2581c
movsd (%rsp), %xmm0
mulsd 0x270c8(%rip), %xmm0    # 0x34468
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x64a9
addsd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::dawsonintegral(double)
double dawsonintegral(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::dawsonintegral(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)
leaq 0x8(%rsp), %rdi
callq 0x256af
movsd (%rsp), %xmm0
callq 0xd46a
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 0xd436
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3675b(%rip), %rsi     # 0x43b80
leaq 0x6458(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xd43b
callq 0x3360
movq %rax, %rbx
jmp 0xd44b
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd45a
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::ellipticintegralk(double)
double ellipticintegralk(const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::ellipticintegralk(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)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x26969(%rip), %xmm0    # 0x341a0
subsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xd9a3
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 0xd8a2
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x362ef(%rip), %rsi     # 0x43b80
leaq 0x5fec(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xd8a7
callq 0x3360
movq %rax, %rbx
jmp 0xd8b7
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd8c6
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::ellipticintegralkhighprecision(double)
double ellipticintegralkhighprecision(const double m1)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::ellipticintegralkhighprecision(m1, &_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)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xd9a3
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 0xd96f
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x36222(%rip), %rsi     # 0x43b80
leaq 0x5f1f(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xd974
callq 0x3360
movq %rax, %rbx
jmp 0xd984
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd993
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::incompleteellipticintegralk(double, double)
double incompleteellipticintegralk(const double phi, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompleteellipticintegralk(phi, 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 $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xdbe1
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xdbad
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x35fe4(%rip), %rsi     # 0x43b80
leaq 0x5ce1(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xdbb2
callq 0x3360
movq %rax, %rbx
jmp 0xdbc2
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xdbd1
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::ellipticintegrale(double)
double ellipticintegrale(const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::ellipticintegrale(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)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xe0d7
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 0xe0a3
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x35aee(%rip), %rsi     # 0x43b80
leaq 0x57eb(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xe0a8
callq 0x3360
movq %rax, %rbx
jmp 0xe0b8
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xe0c7
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::incompleteellipticintegrale(double, double)
double incompleteellipticintegrale(const double phi, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompleteellipticintegrale(phi, 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 $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xe33f
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xe30b
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x35886(%rip), %rsi     # 0x43b80
leaq 0x5583(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xe310
callq 0x3360
movq %rax, %rbx
jmp 0xe320
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xe32f
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::exponentialintegralei(double)
double exponentialintegralei(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::exponentialintegralei(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)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xe858
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 0xe824
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3536d(%rip), %rsi     # 0x43b80
leaq 0x506a(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xe829
callq 0x3360
movq %rax, %rbx
jmp 0xe839
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xe848
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::exponentialintegralen(double, long)
double exponentialintegralen(const double x, const ae_int_t n)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::exponentialintegralen(x, n, &_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
movq %rdi, %rbx
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xefff
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 0xefcb
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x34bc6(%rip), %rsi     # 0x43b80
leaq 0x48c3(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xefd0
callq 0x3360
movq %rax, %rbx
jmp 0xefe0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xefef
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::fdistribution(long, long, double)
double fdistribution(const ae_int_t a, const ae_int_t b, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::fdistribution(a, b, 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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x256af
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xf632
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xf5fe
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x34593(%rip), %rsi     # 0x43b80
leaq 0x4290(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xf603
callq 0x3360
movq %rax, %rbx
jmp 0xf613
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xf622
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::fdistribution(long, long, double, alglib_impl::ae_state*)
double fdistribution(ae_int_t a, ae_int_t b, double x, ae_state *_state)
{
    double w;
    double result;


    ae_assert((a>=1&&b>=1)&&ae_fp_greater_eq(x,0), "Domain error in FDistribution", _state);
    w = a*x;
    w = w/(b+w);
    result = incompletebeta(0.5*a, 0.5*b, w, _state);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
setle %al
testq %rsi, %rsi
setle %cl
orb %al, %cl
movsd %xmm0, 0x8(%rsp)
jne 0xf664
xorps %xmm1, %xmm1
callq 0x2635a
jmp 0xf666
xorl %eax, %eax
movzbl %al, %edi
leaq 0x270cb(%rip), %rsi     # 0x3673b
movq %rbx, %rdx
callq 0x2581c
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movapd %xmm2, %xmm3
addsd %xmm1, %xmm3
divsd %xmm3, %xmm2
movsd 0x24dc2(%rip), %xmm3    # 0x34468
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa5e4
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::fcdistribution(long, long, double)
double fcdistribution(const ae_int_t a, const ae_int_t b, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::fcdistribution(a, b, 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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x256af
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xf78b
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xf757
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3443a(%rip), %rsi     # 0x43b80
leaq 0x4137(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xf75c
callq 0x3360
movq %rax, %rbx
jmp 0xf76c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xf77b
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::fcdistribution(long, long, double, alglib_impl::ae_state*)
double fcdistribution(ae_int_t a, ae_int_t b, double x, ae_state *_state)
{
    double w;
    double result;


    ae_assert((a>=1&&b>=1)&&ae_fp_greater_eq(x,0), "Domain error in FCDistribution", _state);
    w = b/(b+a*x);
    result = incompletebeta(0.5*b, 0.5*a, w, _state);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
setle %al
testq %rsi, %rsi
setle %cl
orb %al, %cl
movsd %xmm0, 0x8(%rsp)
jne 0xf7bd
xorps %xmm1, %xmm1
callq 0x2635a
jmp 0xf7bf
xorl %eax, %eax
movzbl %al, %edi
leaq 0x26f90(%rip), %rsi     # 0x36759
movq %rbx, %rdx
callq 0x2581c
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movapd %xmm0, %xmm2
divsd %xmm3, %xmm2
movsd 0x24c69(%rip), %xmm3    # 0x34468
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa5e4
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invfdistribution(long, long, double)
double invfdistribution(const ae_int_t a, const ae_int_t b, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invfdistribution(a, b, 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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x256af
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xf8e4
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xf8b0
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x342e1(%rip), %rsi     # 0x43b80
leaq 0x3fde(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xf8b5
callq 0x3360
movq %rax, %rbx
jmp 0xf8c5
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xf8d4
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::invfdistribution(long, long, double, alglib_impl::ae_state*)
double invfdistribution(ae_int_t a,
     ae_int_t b,
     double y,
     ae_state *_state)
{
    double w;
    double result;


    ae_assert(((a>=1&&b>=1)&&ae_fp_greater(y,0))&&ae_fp_less_eq(y,1), "Domain error in InvFDistribution", _state);
    
    /*
     * Compute probability for x = 0.5
     */
    w = incompletebeta(0.5*b, 0.5*a, 0.5, _state);
    
    /*
     * If that is greater than y, then the solution w < .5
     * Otherwise, solve at 1-y to remove cancellation in (b - b*w)
     */
    if( ae_fp_greater(w,y)||ae_fp_less(y,0.001) )
    {
        w = invincompletebeta(0.5*b, 0.5*a, y, _state);
        result = (b-b*w)/(a*w);
    }
    else
    {
        w = invincompletebeta(0.5*a, 0.5*b, 1.0-y, _state);
        result = b*w/(a*(1.0-w));
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
setle %al
testq %rsi, %rsi
setle %cl
orb %al, %cl
movsd %xmm0, 0x8(%rsp)
jne 0xf92d
xorps %xmm1, %xmm1
callq 0x2633e
testb %al, %al
je 0xf92d
movsd 0x24880(%rip), %xmm1    # 0x341a0
movsd 0x8(%rsp), %xmm0
callq 0x2631e
jmp 0xf92f
xorl %eax, %eax
movzbl %al, %edi
leaq 0x26e3f(%rip), %rsi     # 0x36778
movq %rbx, %rdx
callq 0x2581c
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movsd 0x24b17(%rip), %xmm2    # 0x34468
movsd %xmm0, 0x20(%rsp)
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd %xmm2, %xmm1
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
callq 0xa5e4
movsd 0x8(%rsp), %xmm1
callq 0x2633e
testb %al, %al
jne 0xf9a7
movsd 0x261e0(%rip), %xmm1    # 0x35b78
movsd 0x8(%rsp), %xmm0
callq 0x262fe
testb %al, %al
je 0xf9d5
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %rbx, %rdi
callq 0xb2f1
movapd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm1
jmp 0xfa0d
movsd 0x247c3(%rip), %xmm2    # 0x341a0
subsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rdi
callq 0xb2f1
movsd 0x247a1(%rip), %xmm2    # 0x341a0
movsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm0, %xmm2
mulsd 0x28(%rsp), %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::fresnelintegral(double, double&, double&)
void fresnelintegral(const double x, double &c, double &s)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::fresnelintegral(x, &c, &s, &_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 0xfae5
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 0xfab1
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x340e0(%rip), %rsi     # 0x43b80
leaq 0x3ddd(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xfab6
callq 0x3360
movq %rax, %rbx
jmp 0xfac6
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xfad5
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::hermitecalculate(long, double)
double hermitecalculate(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::hermitecalculate(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), %rdi
callq 0x256af
testq %rbx, %rbx
je 0x100a7
movsd (%rsp), %xmm2
addsd %xmm2, %xmm2
cmpq $0x1, %rbx
jne 0x100b1
movapd %xmm2, %xmm3
jmp 0x100f0
movsd 0x240f1(%rip), %xmm3    # 0x341a0
jmp 0x100f0
xorpd %xmm3, %xmm3
jle 0x100f0
decq %rbx
movsd 0x240de(%rip), %xmm0    # 0x341a0
movl $0x2, %eax
movapd %xmm2, %xmm3
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm3, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm1, %xmm3
addq $0x2, %rax
decq %rbx
jne 0x100cb
movsd %xmm3, (%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 0x1014e
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x33a43(%rip), %rsi     # 0x43b80
leaq 0x3740(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x10153
callq 0x3360
movq %rax, %rbx
jmp 0x10163
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10172
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::hermitesum(alglib::real_1d_array const&, long, double)
double hermitesum(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::hermitesum(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
testq %rbx, %rbx
js 0x10252
movq 0x28(%rax), %rax
incq %rbx
xorpd %xmm3, %xmm3
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rbx, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm3, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm1, %xmm3
addsd %xmm3, %xmm3
addsd -0x8(%rax,%rbx,8), %xmm3
decq %rbx
testq %rbx, %rbx
jg 0x10222
jmp 0x10256
xorpd %xmm3, %xmm3
movsd %xmm3, (%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 0x102b4
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x338dd(%rip), %rsi     # 0x43b80
leaq 0x35da(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x102b9
callq 0x3360
movq %rax, %rbx
jmp 0x102c9
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x102d8
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::hermitesum(alglib_impl::ae_vector*, long, double, alglib_impl::ae_state*)
double hermitesum(/* 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*(x*b1-(i+1)*b2)+c->ptr.p_double[i];
        b2 = b1;
        b1 = result;
    }
    return result;
}

// Assembly:
testq %rsi, %rsi
js 0x1032c
movq 0x28(%rdi), %rax
incq %rsi
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %rsi, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
addsd %xmm1, %xmm1
addsd -0x8(%rax,%rsi,8), %xmm1
decq %rsi
testq %rsi, %rsi
jg 0x102fc
jmp 0x10330
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::hermitecoefficients(long, alglib::real_1d_array&)
void hermitecoefficients(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::hermitecoefficients(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 0x103ec
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 0x103b8
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x337d9(%rip), %rsi     # 0x43b80
leaq 0x34d6(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x103bd
callq 0x3360
movq %rax, %rbx
jmp 0x103cd
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x103dc
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::hermitecoefficients(long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void hermitecoefficients(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] = ae_exp(n*ae_log(2, _state), _state);
    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)/4/(i+1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25ac7
leaq 0x1(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x25a42
testq %r14, %r14
js 0x10432
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x1041e
cvtsi2sd %r14, %xmm0
movsd %xmm0, (%rsp)
movsd 0x23f9c(%rip), %xmm0    # 0x343e0
movq %r15, %rdi
callq 0x266d6
mulsd (%rsp), %xmm0
movq %r15, %rdi
callq 0x266e0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
cmpq $0x2, %r14
jl 0x104d3
movq %r14, %rax
shrq $0x3f, %rax
addq %r14, %rax
sarq %rax
negq %rax
movl $0x1, %ecx
movsd 0x2506a(%rip), %xmm0    # 0x354f0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movq 0x28(%rbx), %rdx
mulsd (%rdx,%r14,8), %xmm1
leaq -0x1(%r14), %rsi
xorps %xmm2, %xmm2
cvtsi2sd %rsi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, -0x10(%rdx,%r14,8)
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
addq $-0x2, %r14
cmpq $0x1, %rdx
jne 0x10486
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::jacobianellipticfunctions(double, double, double&, double&, double&, double&)
void jacobianellipticfunctions(const double u, const double m, double &sn, double &cn, double &dn, double &ph)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::jacobianellipticfunctions(u, m, &sn, &cn, &dn, &ph, &_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 %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x105bd
leaq 0x10(%rsp), %rdi
callq 0x25556
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x10589
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x33608(%rip), %rsi     # 0x43b80
leaq 0x3305(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x1058e
callq 0x3360
movq %rax, %rbx
jmp 0x1059e
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x105ad
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::laguerrecalculate(long, double)
double laguerrecalculate(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::laguerrecalculate(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), %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x10bb8
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 0x10b84
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3300d(%rip), %rsi     # 0x43b80
leaq 0x2d0a(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x10b89
callq 0x3360
movq %rax, %rbx
jmp 0x10b99
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10ba8
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::laguerrecalculate(long, double, alglib_impl::ae_state*)
double laguerrecalculate(ae_int_t n, double x, ae_state *_state)
{
    double a;
    double b;
    double i;
    double result;


    result = 1;
    a = 1;
    b = 1-x;
    if( n==1 )
    {
        result = b;
    }
    i = 2;
    while(ae_fp_less_eq(i,n))
    {
        result = ((2*i-1-x)*b-(i-1)*a)/i;
        a = b;
        b = result;
        i = i+1;
    }
    return result;
}

// Assembly:
subq $0x28, %rsp
movsd 0x235dc(%rip), %xmm1    # 0x341a0
movapd %xmm1, %xmm2
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
cmpq $0x1, %rdi
je 0x10be5
movapd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %rdi, %xmm1
movsd 0x237e5(%rip), %xmm0    # 0x343e0
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
callq 0x2631e
movsd 0x8(%rsp), %xmm0
testb %al, %al
movsd 0x10(%rsp), %xmm1
je 0x10ca0
movsd 0x23578(%rip), %xmm2    # 0x341a0
movsd (%rsp), %xmm0
movapd %xmm0, %xmm4
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movapd %xmm0, %xmm5
addsd %xmm0, %xmm5
movsd 0x23584(%rip), %xmm3    # 0x341d0
addsd %xmm3, %xmm5
subsd %xmm1, %xmm5
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm4, %xmm5
subsd %xmm1, %xmm5
divsd %xmm0, %xmm5
movsd %xmm5, 0x8(%rsp)
addsd 0x23526(%rip), %xmm0    # 0x341a0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
callq 0x2631e
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm2
testb %al, %al
jne 0x10c2d
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::laguerresum(alglib::real_1d_array const&, long, double)
double laguerresum(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::laguerresum(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 0x10d6b
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 0x10d37
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x32e5a(%rip), %rsi     # 0x43b80
leaq 0x2b57(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x10d3c
callq 0x3360
movq %rax, %rbx
jmp 0x10d4c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10d5b
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878