LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::incompletegamma(double, double, alglib_impl::ae_state*)
double incompletegamma(double a, double x, ae_state *_state)
{
    double igammaepsilon;
    double ans;
    double ax;
    double c;
    double r;
    double tmp;
    double result;


    igammaepsilon = 0.000000000000001;
    if( ae_fp_less_eq(x,0)||ae_fp_less_eq(a,0) )
    {
        result = 0;
        return result;
    }
    if( ae_fp_greater(x,1)&&ae_fp_greater(x,a) )
    {
        result = 1-incompletegammac(a, x, _state);
        return result;
    }
    ax = a*ae_log(x, _state)-x-lngamma(a, &tmp, _state);
    if( ae_fp_less(ax,-709.78271289338399) )
    {
        result = 0;
        return result;
    }
    ax = ae_exp(ax, _state);
    r = a;
    c = 1;
    ans = 1;
    do
    {
        r = r+1;
        c = c*x/r;
        ans = ans+c;
    }
    while(ae_fp_greater(c/ans,igammaepsilon));
    result = ans*ax/a;
    return result;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movapd %xmm1, %xmm2
movsd %xmm0, 0x8(%rsp)
xorpd %xmm1, %xmm1
movsd %xmm2, 0x10(%rsp)
movapd %xmm2, %xmm0
callq 0x2631e
xorpd %xmm2, %xmm2
testb %al, %al
jne 0x601f
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x2631e
testb %al, %al
je 0x5edb
xorpd %xmm2, %xmm2
jmp 0x601f
movsd 0x2e2bd(%rip), %xmm1    # 0x341a0
movsd 0x10(%rsp), %xmm0
callq 0x2633e
testb %al, %al
je 0x5f2c
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2633e
testb %al, %al
je 0x5f2c
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rdi
callq 0x60f1
movsd 0x2e27d(%rip), %xmm2    # 0x341a0
subsd %xmm0, %xmm2
jmp 0x601f
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x266d6
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm1
subsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x4e78
movsd 0x18(%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x2e865(%rip), %xmm1    # 0x347d8
movsd %xmm2, 0x18(%rsp)
movapd %xmm2, %xmm0
callq 0x262fe
testb %al, %al
xorpd %xmm2, %xmm2
jne 0x601f
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x266e0
movsd %xmm0, 0x20(%rsp)
movsd 0x2e1f6(%rip), %xmm0    # 0x341a0
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm3
addsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
mulsd 0x10(%rsp), %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, 0x30(%rsp)
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rsp)
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd 0x2e7f4(%rip), %xmm1    # 0x347e0
callq 0x2633e
movsd 0x28(%rsp), %xmm3
movsd 0x30(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x2e195(%rip), %xmm0    # 0x341a0
testb %al, %al
jne 0x5fb8
movsd 0x20(%rsp), %xmm2
mulsd %xmm1, %xmm2
divsd 0x8(%rsp), %xmm2
movapd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::incompletegammac(double, double)
double incompletegammac(const double a, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompletegammac(a, 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 0x60f1
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 0x60bd
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3dad4(%rip), %rsi     # 0x43b80
leaq 0xd7d1(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x60c2
callq 0x3360
movq %rax, %rbx
jmp 0x60d2
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x60e1
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::invincompletegammac(double, double)
double invincompletegammac(const double a, const double y0)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invincompletegammac(a, y0, &_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 0x64a9
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 0x6475
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3d71c(%rip), %rsi     # 0x43b80
leaq 0xd419(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x647a
callq 0x3360
movq %rax, %rbx
jmp 0x648a
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x6499
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::airy(double, double&, double&, double&, double&)
void airy(const double x, double &ai, double &aip, double &bi, double &bip)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::airy(x, &ai, &aip, &bi, &bip, &_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 %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x256af
movsd 0x8(%rsp), %xmm0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x6aa8
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 0x6a74
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3d11d(%rip), %rsi     # 0x43b80
leaq 0xce1a(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x6a79
callq 0x3360
movq %rax, %rbx
jmp 0x6a89
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x6a98
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::besselj1(double)
double besselj1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselj1(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 0x79b6
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 0x7982
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3c20f(%rip), %rsi     # 0x43b80
leaq 0xbf0c(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x7987
callq 0x3360
movq %rax, %rbx
jmp 0x7997
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x79a6
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::besseljn(long, double)
double besseljn(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::besseljn(n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x7c9e
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 0x7c6a
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3bf27(%rip), %rsi     # 0x43b80
leaq 0xbc24(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x7c6f
callq 0x3360
movq %rax, %rbx
jmp 0x7c7f
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x7c8e
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::bessely0(double)
double bessely0(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::bessely0(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 0x7f98
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 0x7f64
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3bc2d(%rip), %rsi     # 0x43b80
leaq 0xb92a(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x7f69
callq 0x3360
movq %rax, %rbx
jmp 0x7f79
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x7f88
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::besselyn(long, double)
double besselyn(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::besselyn(n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x8512
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 0x84de
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3b6b3(%rip), %rsi     # 0x43b80
leaq 0xb3b0(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x84e3
callq 0x3360
movq %rax, %rbx
jmp 0x84f3
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x8502
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::besselyn(long, double, alglib_impl::ae_state*)
double besselyn(ae_int_t n, double x, ae_state *_state)
{
    ae_int_t i;
    double a;
    double b;
    double tmp;
    double s;
    double result;


    s = 1;
    if( n<0 )
    {
        n = -n;
        if( n%2!=0 )
        {
            s = -1;
        }
    }
    if( n==0 )
    {
        result = bessely0(x, _state);
        return result;
    }
    if( n==1 )
    {
        result = s*bessely1(x, _state);
        return result;
    }
    a = bessely0(x, _state);
    b = bessely1(x, _state);
    for(i=1; i<=n-1; i++)
    {
        tmp = b;
        b = 2*i/x*b-a;
        a = tmp;
    }
    result = s*b;
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x2bc79(%rip), %xmm1    # 0x341a0
testq %rdi, %rdi
jns 0x853c
negq %rbx
testb $0x1, %bl
je 0x853c
movsd 0x2bc94(%rip), %xmm1    # 0x341d0
cmpq $0x1, %rbx
je 0x8556
testq %rbx, %rbx
jne 0x8578
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x7f98
movsd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x8241
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
jmp 0x85eb
movsd %xmm1, (%rsp)
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x7f98
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x8241
cmpq $0x2, %rbx
jl 0x85de
decq %rbx
movl $0x2, %eax
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movapd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
subsd %xmm3, %xmm0
addq $0x2, %rax
movapd %xmm1, %xmm3
decq %rbx
jne 0x85b9
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besseli0(double)
double besseli0(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besseli0(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 0x86ab
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 0x8677
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3b51a(%rip), %rsi     # 0x43b80
leaq 0xb217(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x867c
callq 0x3360
movq %rax, %rbx
jmp 0x868c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x869b
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::besseli1(double)
double besseli1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besseli1(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 0x8c7a
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 0x8c46
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3af4b(%rip), %rsi     # 0x43b80
leaq 0xac48(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x8c4b
callq 0x3360
movq %rax, %rbx
jmp 0x8c5b
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x8c6a
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::besselk1(double)
double besselk1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselk1(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 0x969b
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 0x9667
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3a52a(%rip), %rsi     # 0x43b80
leaq 0xa227(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x966c
callq 0x3360
movq %rax, %rbx
jmp 0x967c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x968b
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::besselkn(long, double)
double besselkn(const ae_int_t nn, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselkn(nn, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x9b35
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 0x9b01
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3a090(%rip), %rsi     # 0x43b80
leaq 0x9d8d(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x9b06
callq 0x3360
movq %rax, %rbx
jmp 0x9b16
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x9b25
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::beta(double, double)
double beta(const double a, const double b)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::beta(a, b, &_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 0xa2c8
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 0xa294
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x398fd(%rip), %rsi     # 0x43b80
leaq 0x95fa(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xa299
callq 0x3360
movq %rax, %rbx
jmp 0xa2a9
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xa2b8
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::incompletebeta(double, double, double)
double incompletebeta(const double a, const double b, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompletebeta(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 %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm2, (%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm2
movq %rbx, %rdi
callq 0xa5e4
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xa5b0
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x395e1(%rip), %rsi     # 0x43b80
leaq 0x92de(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xa5b5
callq 0x3360
movq %rax, %rbx
jmp 0xa5c5
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xa5d4
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::invincompletebeta(double, double, double)
double invincompletebeta(const double a, const double b, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invincompletebeta(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 %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm2, (%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm2
movq %rbx, %rdi
callq 0xb2f1
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xb2bd
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x388d4(%rip), %rsi     # 0x43b80
leaq 0x85d1(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xb2c2
callq 0x3360
movq %rax, %rbx
jmp 0xb2d2
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xb2e1
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::binomialdistribution(long, long, double)
double binomialdistribution(const ae_int_t k, const ae_int_t n, const double p)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::binomialdistribution(k, n, p, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %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 0xc44d
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 0xc419
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x37778(%rip), %rsi     # 0x43b80
leaq 0x7475(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xc41e
callq 0x3360
movq %rax, %rbx
jmp 0xc42e
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xc43d
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::binomialdistribution(long, long, double, alglib_impl::ae_state*)
double binomialdistribution(ae_int_t k,
     ae_int_t n,
     double p,
     ae_state *_state)
{
    double dk;
    double dn;
    double result;


    ae_assert(ae_fp_greater_eq(p,0)&&ae_fp_less_eq(p,1), "Domain error in BinomialDistribution", _state);
    ae_assert(k>=-1&&k<=n, "Domain error in BinomialDistribution", _state);
    if( k==-1 )
    {
        result = 0;
        return result;
    }
    if( k==n )
    {
        result = 1;
        return result;
    }
    dn = n-k;
    if( k==0 )
    {
        dk = ae_pow(1.0-p, dn, _state);
    }
    else
    {
        dk = k+1;
        dk = incompletebeta(dn, dk, 1.0-p, _state);
    }
    result = dk;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movaps %xmm0, %xmm2
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm1, %xmm1
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
callq 0x2635a
testb %al, %al
je 0xc497
movsd 0x27d16(%rip), %xmm1    # 0x341a0
movsd 0x8(%rsp), %xmm0
callq 0x2631e
jmp 0xc499
xorl %eax, %eax
movzbl %al, %edi
leaq 0x2a181(%rip), %r12     # 0x36624
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
cmpq $-0x1, %r14
setge %al
cmpq %r14, %r15
setge %cl
andb %al, %cl
movzbl %cl, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
cmpq $-0x1, %r14
je 0xc4e4
subq %r14, %r15
jne 0xc4f6
movsd 0x27cc2(%rip), %xmm0    # 0x341a0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cvtsi2sd %r15, %xmm3
testq %r14, %r14
je 0xc530
incq %r14
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd 0x27c8d(%rip), %xmm2    # 0x341a0
subsd 0x8(%rsp), %xmm2
movapd %xmm3, %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa5e4
movsd 0x27c68(%rip), %xmm0    # 0x341a0
subsd 0x8(%rsp), %xmm0
movapd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x266db
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::binomialcdistribution(long, long, double)
double binomialcdistribution(const ae_int_t k, const ae_int_t n, const double p)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::binomialcdistribution(k, n, p, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %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 0xc621
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 0xc5ed
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x375a4(%rip), %rsi     # 0x43b80
leaq 0x72a1(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xc5f2
callq 0x3360
movq %rax, %rbx
jmp 0xc602
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xc611
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::binomialcdistribution(long, long, double, alglib_impl::ae_state*)
double binomialcdistribution(ae_int_t k,
     ae_int_t n,
     double p,
     ae_state *_state)
{
    double dk;
    double dn;
    double result;


    ae_assert(ae_fp_greater_eq(p,0)&&ae_fp_less_eq(p,1), "Domain error in BinomialDistributionC", _state);
    ae_assert(k>=-1&&k<=n, "Domain error in BinomialDistributionC", _state);
    if( k==-1 )
    {
        result = 1;
        return result;
    }
    if( k==n )
    {
        result = 0;
        return result;
    }
    dn = n-k;
    if( k==0 )
    {
        if( ae_fp_less(p,0.01) )
        {
            dk = -nuexpm1(dn*nulog1p(-p, _state), _state);
        }
        else
        {
            dk = 1.0-ae_pow(1.0-p, dn, _state);
        }
    }
    else
    {
        dk = k+1;
        dk = incompletebeta(dk, dn, p, _state);
    }
    result = dk;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorpd %xmm1, %xmm1
movapd %xmm0, (%rsp)
callq 0x2635a
testb %al, %al
je 0xc65b
movsd 0x27b51(%rip), %xmm1    # 0x341a0
movapd (%rsp), %xmm0
callq 0x2631e
jmp 0xc65d
xorl %eax, %eax
movzbl %al, %edi
leaq 0x29fe2(%rip), %r12     # 0x36649
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
cmpq $-0x1, %r14
setge %al
cmpq %r14, %r15
setge %cl
andb %al, %cl
movzbl %cl, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2581c
cmpq $-0x1, %r14
je 0xc6cd
xorpd %xmm0, %xmm0
subq %r14, %r15
je 0xc6d5
xorps %xmm1, %xmm1
cvtsi2sd %r15, %xmm1
testq %r14, %r14
je 0xc6e1
incq %r14
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movaps (%rsp), %xmm2
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa5e4
movsd 0x27acb(%rip), %xmm0    # 0x341a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd %xmm1, 0x10(%rsp)
movsd 0x28df1(%rip), %xmm1    # 0x354e0
movaps (%rsp), %xmm0
callq 0x262fe
testb %al, %al
je 0xc729
movapd (%rsp), %xmm0
xorpd 0x27ad7(%rip), %xmm0    # 0x341e0
movq %rbx, %rdi
callq 0x24d1f
mulsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x24e43
xorpd 0x27ab9(%rip), %xmm0    # 0x341e0
jmp 0xc6d5
movsd 0x27a6f(%rip), %xmm0    # 0x341a0
subsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rdi
callq 0x266db
movsd 0x27a54(%rip), %xmm1    # 0x341a0
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xc6d5
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invbinomialdistribution(long, long, double)
double invbinomialdistribution(const ae_int_t k, const ae_int_t n, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invbinomialdistribution(k, n, 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 0xc825
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 0xc7f1
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x373a0(%rip), %rsi     # 0x43b80
leaq 0x709d(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xc7f6
callq 0x3360
movq %rax, %rbx
jmp 0xc806
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xc815
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::invbinomialdistribution(long, long, double, alglib_impl::ae_state*)
double invbinomialdistribution(ae_int_t k,
     ae_int_t n,
     double y,
     ae_state *_state)
{
    double dk;
    double dn;
    double p;
    double result;


    ae_assert(k>=0&&k<n, "Domain error in InvBinomialDistribution", _state);
    dn = n-k;
    if( k==0 )
    {
        if( ae_fp_greater(y,0.8) )
        {
            p = -nuexpm1(nulog1p(y-1.0, _state)/dn, _state);
        }
        else
        {
            p = 1.0-ae_pow(y, 1.0/dn, _state);
        }
    }
    else
    {
        dk = k+1;
        p = incompletebeta(dn, dk, 0.5, _state);
        if( ae_fp_greater(p,0.5) )
        {
            p = invincompletebeta(dk, dn, 1.0-y, _state);
        }
        else
        {
            p = 1.0-invincompletebeta(dn, dk, y, _state);
        }
    }
    result = p;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
setns %al
subq %rdi, %r15
setg %cl
andb %al, %cl
movzbl %cl, %edi
leaq 0x29e1a(%rip), %rsi     # 0x3666f
callq 0x2581c
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
testq %r14, %r14
movsd %xmm0, 0x10(%rsp)
je 0xc8c7
incq %r14
cvtsi2sd %r14, %xmm1
movsd 0x27beb(%rip), %xmm2    # 0x34468
movsd %xmm1, 0x18(%rsp)
movq %rbx, %rdi
callq 0xa5e4
movsd 0x27bd5(%rip), %xmm1    # 0x34468
callq 0x2633e
testb %al, %al
je 0xc910
movsd 0x278fc(%rip), %xmm2    # 0x341a0
subsd 0x8(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xb2f1
movsd 0x28c19(%rip), %xmm1    # 0x354e8
movsd 0x8(%rsp), %xmm0
callq 0x2633e
testb %al, %al
je 0xc92c
movsd 0x8(%rsp), %xmm0
addsd 0x278e4(%rip), %xmm0    # 0x341d0
movq %rbx, %rdi
callq 0x24d1f
divsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x24e43
movapd %xmm0, %xmm1
xorpd 0x278d2(%rip), %xmm1    # 0x341e0
jmp 0xc954
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %rbx, %rdi
callq 0xb2f1
jmp 0xc948
movsd 0x2786c(%rip), %xmm1    # 0x341a0
divsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x266db
movsd 0x27850(%rip), %xmm1    # 0x341a0
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %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::chebyshevcalculate(long, long, double)
double chebyshevcalculate(const ae_int_t r, 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::chebyshevcalculate(r, 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
movsd (%rsp), %xmm2
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
cmpq $0x1, %r14
je 0xc995
movapd %xmm0, %xmm2
testq %rbx, %rbx
je 0xc9a6
cmpq $0x1, %rbx
jne 0xc9b0
movapd %xmm2, %xmm3
jmp 0xc9de
movsd 0x277f2(%rip), %xmm3    # 0x341a0
jmp 0xc9de
xorpd %xmm3, %xmm3
jle 0xc9de
decq %rbx
movsd 0x277df(%rip), %xmm1    # 0x341a0
movapd %xmm2, %xmm3
movapd %xmm3, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
subsd %xmm1, %xmm3
movapd %xmm2, %xmm1
decq %rbx
jne 0xc9c5
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 0xca3c
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x37155(%rip), %rsi     # 0x43b80
leaq 0x6e52(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xca41
callq 0x3360
movq %rax, %rbx
jmp 0xca51
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xca60
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::chebyshevsum(alglib::real_1d_array const&, long, long, double)
double chebyshevsum(const real_1d_array &c, const ae_int_t r, 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::chebyshevsum(const_cast<alglib_impl::ae_vector*>(c.c_ptr()), r, 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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
callq 0x256af
movq %r15, %rdi
callq 0x2beba
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movsd 0x8(%rsp), %xmm0
callq 0xcba2
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 0xcb6e
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x37023(%rip), %rsi     # 0x43b80
leaq 0x6d20(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xcb73
callq 0x3360
movq %rax, %rbx
jmp 0xcb83
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xcb92
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::chebyshevcoefficients(long, alglib::real_1d_array&)
void chebyshevcoefficients(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::chebyshevcoefficients(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 0xccbd
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 0xcc89
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x36f08(%rip), %rsi     # 0x43b80
leaq 0x6c05(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xcc8e
callq 0x3360
movq %rax, %rbx
jmp 0xcc9e
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xccad
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::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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x25ac7
leaq 0x1(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x25a42
testq %rbx, %rbx
js 0xcd03
xorl %eax, %eax
movq 0x28(%r14), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0xccef
cmpq $0x1, %rbx
ja 0xcd20
movq 0x28(%r14), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%rbx,8)
jmp 0xcdd1
leaq -0x1(%rbx), %r12
cvtsi2sd %r12, %xmm0
movsd %xmm0, (%rsp)
movsd 0x276aa(%rip), %xmm0    # 0x343e0
movq %r15, %rdi
callq 0x266d6
mulsd (%rsp), %xmm0
movq %r15, %rdi
callq 0x266e0
movq 0x28(%r14), %rax
movsd %xmm0, (%rax,%rbx,8)
cmpq $0x2, %rbx
jl 0xcdd1
movq %rbx, %rax
shrq $0x3f, %rax
addq %rbx, %rax
sarq %rax
negq %rax
movl $0x1, %ecx
movsd 0x28779(%rip), %xmm0    # 0x354f0
xorps %xmm1, %xmm1
cvtsi2sd %rbx, %xmm1
movq 0x28(%r14), %rdx
mulsd (%rdx,%rbx,8), %xmm1
leaq -0x1(%rbx), %rsi
xorps %xmm2, %xmm2
cvtsi2sd %rsi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
xorps %xmm3, %xmm3
cvtsi2sd %r12, %xmm3
divsd %xmm1, %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, -0x10(%rdx,%rbx,8)
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
addq $-0x2, %rbx
decq %r12
cmpq $0x1, %rdx
jne 0xcd77
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::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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %rdi
callq 0x256af
movq %r15, %rdi
callq 0x2beba
movq %rax, %r15
movq %r14, %rdi
callq 0x2bec0
movq %rsp, %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xcea3
movq %rsp, %rdi
callq 0x25556
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xce6f
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x36d22(%rip), %rsi     # 0x43b80
leaq 0x6a1f(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0xce74
callq 0x3360
movq %rax, %rbx
jmp 0xce84
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xce93
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878