LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::chebyshevcoefficients(long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void chebyshevcoefficients(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;
    }
    if( n==0||n==1 )
    {
        c->ptr.p_double[n] = 1;
    }
    else
    {
        c->ptr.p_double[n] = ae_exp((n-1)*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)/(n-i-1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b6f0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
callq 0x3b620
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jg 0x113a6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1137a
cmpq $0x0, -0x8(%rbp)
je 0x113b4
cmpq $0x1, -0x8(%rbp)
jne 0x113d2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movsd 0x43c40(%rip), %xmm0    # 0x55008
movsd %xmm0, (%rax,%rcx,8)
jmp 0x11515
movq -0x8(%rbp), %rax
subq $0x1, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movsd 0x43fd8(%rip), %xmm0    # 0x553c8
callq 0x3cd70
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rdi
callq 0x3cdd0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x11513
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq %rdx
subq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %rcx
subq %rcx, %rax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %rcx
subq %rcx, %rax
subq $0x1, %rax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movsd 0x43cff(%rip), %xmm1    # 0x551b8
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
addq $0x1, %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
subq -0x20(%rbp), %rax
subq $0x1, %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
shlq %rdx
subq %rdx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11423
jmp 0x11515
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::fromchebyshev(alglib::real_1d_array const&, long, alglib::real_1d_array&)
void fromchebyshev(const real_1d_array &a, const ae_int_t n, real_1d_array &b)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::fromchebyshev(const_cast<alglib_impl::ae_vector*>(a.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ae90
movq -0x8(%rbp), %rdi
callq 0x474c0
movq %rax, -0x80(%rbp)
jmp 0x1154f
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x474e0
movq %rax, -0x88(%rbp)
jmp 0x1156c
movq -0x88(%rbp), %rdx
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rcx
callq 0x11670
jmp 0x11589
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x11594
jmp 0x1164f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x115fd
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x115e1
movq -0x98(%rbp), %rdi
leaq 0x53589(%rip), %rsi     # 0x64b78
leaq 0xc1ba(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x11669
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x11669
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x11620
jmp 0x11658
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x11648
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x11658
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x119c0
movsd %xmm0, -0x80(%rbp)
jmp 0x118d2
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x118e7
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x11959
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x1193d
movq -0x90(%rbp), %rdi
leaq 0x5322d(%rip), %rsi     # 0x64b78
leaq 0xbe5e(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x119ba
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x119ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x1197c
jmp 0x119a9
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x119a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x119f1
jmp 0x11a06
movsd -0x8(%rbp), %xmm0
movsd 0x4360a(%rip), %xmm1    # 0x55008
callq 0x3c500
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x45bfd(%rip), %rsi     # 0x57617
callq 0x3b240
movsd -0x8(%rbp), %xmm0
movsd 0x4399c(%rip), %xmm1    # 0x553c8
divsd %xmm1, %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x4398b(%rip), %xmm2    # 0x553c8
divsd %xmm2, %xmm1
movq -0x18(%rbp), %rdi
callq 0x7240
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x11b90
movsd %xmm0, -0x80(%rbp)
jmp 0x11aa2
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x11ab7
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x11b29
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x11b0d
movq -0x90(%rbp), %rdi
leaq 0x5305d(%rip), %rsi     # 0x64b78
leaq 0xbc8e(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x11b8a
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x11b8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x11b4c
jmp 0x11b79
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x11b74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x11bc1
jmp 0x11bd6
movsd -0x8(%rbp), %xmm0
movsd 0x4343a(%rip), %xmm1    # 0x55008
callq 0x3c500
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x45a53(%rip), %rsi     # 0x5763d
callq 0x3b240
movsd -0x8(%rbp), %xmm0
movsd 0x437cc(%rip), %xmm1    # 0x553c8
divsd %xmm1, %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x437bb(%rip), %xmm2    # 0x553c8
divsd %xmm2, %xmm1
movq -0x18(%rbp), %rdi
callq 0x7580
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x11d60
movsd %xmm0, -0x80(%rbp)
jmp 0x11c72
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x11c87
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x11cf9
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x11cdd
movq -0x90(%rbp), %rdi
leaq 0x52e8d(%rip), %rsi     # 0x64b78
leaq 0xbabe(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x11d5a
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x11d5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x11d1c
jmp 0x11d49
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x11d44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x11d91
jmp 0x11dc6
movsd -0x10(%rbp), %xmm0
movsd 0x4326a(%rip), %xmm1    # 0x55008
callq 0x3c480
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x11db1
jmp 0x11dc6
movsd -0x8(%rbp), %xmm0
movsd 0x4324a(%rip), %xmm1    # 0x55008
callq 0x3c500
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x4588a(%rip), %rsi     # 0x57664
callq 0x3b240
movsd 0x43669(%rip), %xmm0    # 0x55450
mulsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movq -0x18(%rbp), %rdi
callq 0x7b10
movaps %xmm0, %xmm1
movsd 0x435c3(%rip), %xmm0    # 0x553c8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x11f40
movsd %xmm0, -0x78(%rbp)
jmp 0x11e52
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x11e67
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x11ed9
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x11ebd
movq -0x88(%rbp), %rdi
leaq 0x52cad(%rip), %rsi     # 0x64b78
leaq 0xb8de(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x11f3a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x11f3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x11efc
jmp 0x11f29
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x11f24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x12870
movsd %xmm0, -0x78(%rbp)
jmp 0x12782
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x12797
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x12809
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x127ed
movq -0x88(%rbp), %rdi
leaq 0x5237d(%rip), %rsi     # 0x64b78
leaq 0xafae(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x1286a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x1286a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x1282c
jmp 0x12859
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x12854
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x129d0
movsd %xmm0, -0x78(%rbp)
jmp 0x128e2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x128f7
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x12969
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x1294d
movq -0x88(%rbp), %rdi
leaq 0x5221d(%rip), %rsi     # 0x64b78
leaq 0xae4e(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x129ca
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x129ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x1298c
jmp 0x129b9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x129b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x12e40
movsd %xmm0, -0x80(%rbp)
jmp 0x12d52
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x12d67
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x12dd9
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x12dbd
movq -0x90(%rbp), %rdi
leaq 0x51dad(%rip), %rsi     # 0x64b78
leaq 0xa9de(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x12e3a
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x12e3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x12dfc
jmp 0x12e29
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x12e24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x13480
movsd %xmm0, -0x78(%rbp)
jmp 0x13392
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x133a7
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x13419
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x133fd
movq -0x88(%rbp), %rdi
leaq 0x5176d(%rip), %rsi     # 0x64b78
leaq 0xa39e(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x1347a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x1347a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x1343c
jmp 0x13469
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x13464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x13920
movsd %xmm0, -0x80(%rbp)
jmp 0x13832
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x13847
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x138b9
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x1389d
movq -0x90(%rbp), %rdi
leaq 0x512cd(%rip), %rsi     # 0x64b78
leaq 0x9efe(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x1391a
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x1391a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x138dc
jmp 0x13909
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x13904
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x14070
movsd %xmm0, -0x78(%rbp)
jmp 0x13f82
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x13f97
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x14009
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x13fed
movq -0x88(%rbp), %rdi
leaq 0x50b7d(%rip), %rsi     # 0x64b78
leaq 0x97ae(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x1406a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x1406a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x1402c
jmp 0x14059
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x14054
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rsi
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rdi
callq 0x15220
movsd %xmm0, -0x80(%rbp)
jmp 0x15130
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x15145
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x151b7
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x1519b
movq -0x90(%rbp), %rdi
leaq 0x4f9cf(%rip), %rsi     # 0x64b78
leaq 0x8600(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x15218
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x15218
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x151da
jmp 0x15207
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x15202
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x15b60
movsd %xmm0, -0x88(%rbp)
jmp 0x15a6b
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x15a83
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x15af5
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x15ad9
movq -0x98(%rbp), %rdi
leaq 0x4f091(%rip), %rsi     # 0x64b78
leaq 0x7cc2(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x15b56
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x15b56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0x15b18
jmp 0x15b45
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x15b40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x1, -0x8(%rbp)
movb %al, -0x31(%rbp)
jl 0x15ba1
xorl %eax, %eax
cmpq $0x1, -0x10(%rbp)
movb %al, -0x31(%rbp)
jl 0x15ba1
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movq -0x20(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x41b06(%rip), %rsi     # 0x576bb
callq 0x3b240
cvtsi2sdq -0x8(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
addsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdq -0x8(%rbp), %xmm1
movsd 0x3f85f(%rip), %xmm0    # 0x55450
mulsd %xmm1, %xmm0
cvtsi2sdq -0x10(%rbp), %xmm2
movsd 0x3f84d(%rip), %xmm1    # 0x55450
mulsd %xmm2, %xmm1
movsd -0x28(%rbp), %xmm2
movq -0x20(%rbp), %rdi
callq 0xeb20
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x15d70
movsd %xmm0, -0x88(%rbp)
jmp 0x15c7b
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x15c93
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x15d05
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x15ce9
movq -0x98(%rbp), %rdi
leaq 0x4ee81(%rip), %rsi     # 0x64b78
leaq 0x7ab2(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x15d66
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x15d66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0x15d28
jmp 0x15d55
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x15d50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x1, -0x8(%rbp)
movb %al, -0x31(%rbp)
jl 0x15db1
xorl %eax, %eax
cmpq $0x1, -0x10(%rbp)
movb %al, -0x31(%rbp)
jl 0x15db1
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movq -0x20(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x41914(%rip), %rsi     # 0x576d9
callq 0x3b240
cvtsi2sdq -0x10(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm2
cvtsi2sdq -0x8(%rbp), %xmm1
movsd -0x18(%rbp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdq -0x10(%rbp), %xmm1
movsd 0x3f650(%rip), %xmm0    # 0x55450
mulsd %xmm1, %xmm0
cvtsi2sdq -0x8(%rbp), %xmm2
movsd 0x3f63e(%rip), %xmm1    # 0x55450
mulsd %xmm2, %xmm1
movsd -0x28(%rbp), %xmm2
movq -0x20(%rbp), %rdi
callq 0xeb20
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x15f80
movsd %xmm0, -0x88(%rbp)
jmp 0x15e8b
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x15ea3
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x15f15
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x15ef9
movq -0x98(%rbp), %rdi
leaq 0x4ec71(%rip), %rsi     # 0x64b78
leaq 0x78a2(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x15f76
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x15f76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0x15f38
jmp 0x15f65
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x15f60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdx
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16280
jmp 0x1619d
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x161a8
jmp 0x16263
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x16211
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x161f5
movq -0x88(%rbp), %rdi
leaq 0x4e975(%rip), %rsi     # 0x64b78
leaq 0x75a6(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x1627d
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x1627d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x16234
jmp 0x1626c
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x1625c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x1626c
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rsi
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x16fd0
movsd %xmm0, -0x80(%rbp)
jmp 0x16ee0
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x16ef5
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x16f67
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x16f4b
movq -0x90(%rbp), %rdi
leaq 0x4dc1f(%rip), %rsi     # 0x64b78
leaq 0x6850(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x16fc8
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x16fc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x16f8a
jmp 0x16fb7
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x16fb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::hermitecalculate(long, double, alglib_impl::ae_state*)
double hermitecalculate(ae_int_t n, double x, ae_state *_state)
{
    ae_int_t i;
    double a;
    double b;
    double result;


    result = 0;
    
    /*
     * Prepare A and B
     */
    a = 1;
    b = 2*x;
    
    /*
     * Special cases: N=0 or N=1
     */
    if( n==0 )
    {
        result = a;
        return result;
    }
    if( n==1 )
    {
        result = b;
        return result;
    }
    
    /*
     * General case: N>=2
     */
    for(i=2; i<=n; i++)
    {
        result = 2*x*b-2*(i-1)*a;
        a = b;
        b = result;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x3e017(%rip), %xmm0    # 0x55008
movsd %xmm0, -0x30(%rbp)
movsd 0x3e3ca(%rip), %xmm0    # 0x553c8
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17028
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x170d1
cmpq $0x1, -0x10(%rbp)
jne 0x17048
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x170d1
movq $0x2, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jg 0x170c7
movsd 0x3e366(%rip), %xmm0    # 0x553c8
mulsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movq -0x28(%rbp), %rax
subq $0x1, %rax
shlq %rax
cvtsi2sd %rax, %xmm1
mulsd -0x30(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x17050
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)