LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x8de9
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x8db5
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x37ddc(%rip), %rsi     # 0x40b80
leaq 0x996d(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x8dba
callq 0x3330
movq %rax, %rbx
jmp 0x8dca
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x8dd9
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x9281
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x924d
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x37944(%rip), %rsi     # 0x40b80
leaq 0x94d5(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x9252
callq 0x3330
movq %rax, %rbx
jmp 0x9262
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x9271
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x99e1
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x99ad
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x371e4(%rip), %rsi     # 0x40b80
leaq 0x8d75(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x99b2
callq 0x3330
movq %rax, %rbx
jmp 0x99c2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x99d1
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm2
movq %rbx, %rdi
callq 0x9cf5
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x9cc1
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x36ed0(%rip), %rsi     # 0x40b80
leaq 0x8a61(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x9cc6
callq 0x3330
movq %rax, %rbx
jmp 0x9cd6
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x9ce5
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm2
movq %rbx, %rdi
callq 0xa961
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xa92d
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x36264(%rip), %rsi     # 0x40b80
leaq 0x7df5(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xa932
callq 0x3330
movq %rax, %rbx
jmp 0xa942
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xa951
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xbbcf
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xbb9b
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x34ff6(%rip), %rsi     # 0x40b80
leaq 0x6b87(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xbba0
callq 0x3330
movq %rax, %rbx
jmp 0xbbb0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xbbbf
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0x24295
testb %al, %al
je 0xbc19
movsd 0x245ec(%rip), %xmm1    # 0x301f8
movsd 0x8(%rsp), %xmm0
callq 0x24259
jmp 0xbc1b
xorl %eax, %eax
movzbl %al, %edi
leaq 0x26b8f(%rip), %r12     # 0x327b4
movq %r12, %rsi
movq %rbx, %rdx
callq 0x238ca
cmpq $-0x1, %r14
setge %al
cmpq %r14, %r15
setge %cl
andb %al, %cl
movzbl %cl, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x238ca
cmpq $-0x1, %r14
je 0xbc66
subq %r14, %r15
jne 0xbc78
movsd 0x24598(%rip), %xmm0    # 0x301f8
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 0xbcaf
incq %r14
cvtsi2sd %r14, %xmm1
movsd 0x24566(%rip), %xmm2    # 0x301f8
subsd 0x8(%rsp), %xmm2
movapd %xmm3, %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9cf5
movsd 0x24541(%rip), %xmm0    # 0x301f8
subsd 0x8(%rsp), %xmm0
movapd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x24564
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xbd9e
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xbd6a
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x34e27(%rip), %rsi     # 0x40b80
leaq 0x69b8(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xbd6f
callq 0x3330
movq %rax, %rbx
jmp 0xbd7f
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xbd8e
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0x24295
testb %al, %al
je 0xbdd8
movsd 0x2442c(%rip), %xmm1    # 0x301f8
movapd (%rsp), %xmm0
callq 0x24259
jmp 0xbdda
xorl %eax, %eax
movzbl %al, %edi
leaq 0x269f5(%rip), %r12     # 0x327d9
movq %r12, %rsi
movq %rbx, %rdx
callq 0x238ca
cmpq $-0x1, %r14
setge %al
cmpq %r14, %r15
setge %cl
andb %al, %cl
movzbl %cl, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x238ca
cmpq $-0x1, %r14
je 0xbe44
xorpd %xmm0, %xmm0
subq %r14, %r15
je 0xbe4c
cvtsi2sd %r15, %xmm1
testq %r14, %r14
je 0xbe58
incq %r14
cvtsi2sd %r14, %xmm0
movaps (%rsp), %xmm2
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9cf5
movsd 0x243ac(%rip), %xmm0    # 0x301f8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd %xmm1, 0x10(%rsp)
movsd 0x25472(%rip), %xmm1    # 0x312d8
movaps (%rsp), %xmm0
callq 0x24239
testb %al, %al
je 0xbea0
movapd (%rsp), %xmm0
xorpd 0x24330(%rip), %xmm0    # 0x301b0
movq %rbx, %rdi
callq 0x22e08
mulsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x22f2c
xorpd 0x24312(%rip), %xmm0    # 0x301b0
jmp 0xbe4c
movsd 0x24350(%rip), %xmm0    # 0x301f8
subsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rdi
callq 0x24564
movsd 0x24335(%rip), %xmm1    # 0x301f8
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xbe4c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xbf9a
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xbf66
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x34c2b(%rip), %rsi     # 0x40b80
leaq 0x67bc(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xbf6b
callq 0x3330
movq %rax, %rbx
jmp 0xbf7b
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xbf8a
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0x26835(%rip), %rsi     # 0x327ff
callq 0x238ca
cvtsi2sd %r15, %xmm0
testq %r14, %r14
movsd %xmm0, 0x10(%rsp)
je 0xc039
incq %r14
cvtsi2sd %r14, %xmm1
movsd 0x24499(%rip), %xmm2    # 0x30488
movsd %xmm1, 0x18(%rsp)
movq %rbx, %rdi
callq 0x9cf5
movsd 0x24483(%rip), %xmm1    # 0x30488
callq 0x24279
testb %al, %al
je 0xc082
movsd 0x241e2(%rip), %xmm2    # 0x301f8
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 0xa961
movsd 0x2529f(%rip), %xmm1    # 0x312e0
movsd 0x8(%rsp), %xmm0
callq 0x24279
testb %al, %al
je 0xc09e
movsd 0x8(%rsp), %xmm0
addsd 0x241a2(%rip), %xmm0    # 0x30200
movq %rbx, %rdi
callq 0x22e08
divsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x22f2c
movapd %xmm0, %xmm1
xorpd 0x24130(%rip), %xmm1    # 0x301b0
jmp 0xc0c6
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %rbx, %rdi
callq 0xa961
jmp 0xc0ba
movsd 0x24152(%rip), %xmm1    # 0x301f8
divsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x24564
movsd 0x24136(%rip), %xmm1    # 0x301f8
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %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 0x23772
movq %r15, %rdi
callq 0x23631
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
callq 0xc18d
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xc159
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x34a38(%rip), %rsi     # 0x40b80
leaq 0x65c9(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xc15e
callq 0x3330
movq %rax, %rbx
jmp 0xc16e
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xc17d
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %r15, %rdi
callq 0x28cea
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movsd 0x8(%rsp), %xmm0
callq 0xc2bc
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xc288
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x34909(%rip), %rsi     # 0x40b80
leaq 0x649a(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xc28d
callq 0x3330
movq %rax, %rbx
jmp 0xc29d
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xc2ac
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %r14, %rdi
callq 0x28cf0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc3bf
leaq 0x8(%rsp), %rdi
callq 0x23631
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xc38b
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x34806(%rip), %rsi     # 0x40b80
leaq 0x6397(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xc390
callq 0x3330
movq %rax, %rbx
jmp 0xc3a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xc3af
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0x23b55
leaq 0x1(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x23add
xorl %eax, %eax
cmpq %rbx, %rax
jg 0xc3fc
movq 0x28(%r14), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0xc3e9
cmpq $0x1, %rbx
ja 0xc420
movq 0x28(%r14), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq -0x1(%rbx), %r12
cvtsi2sd %r12, %xmm0
movsd %xmm0, (%rsp)
movsd 0x23fc2(%rip), %xmm0    # 0x303f8
movq %r15, %rdi
callq 0x2455f
mulsd (%rsp), %xmm0
movq %r15, %rdi
callq 0x24569
movq 0x28(%r14), %rax
movsd %xmm0, (%rax,%rbx,8)
pushq $0x2
popq %rcx
movq %rbx, %rax
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovgq %rax, %rcx
negq %rcx
pushq $0x1
popq %rax
movsd 0x24e72(%rip), %xmm0    # 0x312e8
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
je 0xc414
movq 0x28(%r14), %rdx
cvtsi2sd %rbx, %xmm1
mulsd (%rdx,%rbx,8), %xmm1
leaq -0x1(%rbx), %rsi
cvtsi2sd %rsi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
cvtsi2sd %r12, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, -0x10(%rdx,%rbx,8)
incq %rax
decq %r12
addq $-0x2, %rbx
jmp 0xc476
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r15, %rdi
callq 0x28cea
movq %rax, %r15
movq %r14, %rdi
callq 0x28cf0
movq %rsp, %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xc587
movq %rsp, %rdi
callq 0x23631
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xc553
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3463e(%rip), %rsi     # 0x40b80
leaq 0x61cf(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xc558
callq 0x3330
movq %rax, %rbx
jmp 0xc568
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xc577
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::fromchebyshev(alglib_impl::ae_vector*, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void fromchebyshev(/* Real    */ ae_vector* a,
     ae_int_t n,
     /* Real    */ ae_vector* b,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t k;
    double e;
    double d;

    ae_vector_clear(b);

    ae_vector_set_length(b, n+1, _state);
    for(i=0; i<=n; i++)
    {
        b->ptr.p_double[i] = 0;
    }
    d = 0;
    i = 0;
    do
    {
        k = i;
        do
        {
            e = b->ptr.p_double[k];
            b->ptr.p_double[k] = 0;
            if( i<=1&&k==i )
            {
                b->ptr.p_double[k] = 1;
            }
            else
            {
                if( i!=0 )
                {
                    b->ptr.p_double[k] = 2*d;
                }
                if( k>i+1 )
                {
                    b->ptr.p_double[k] = b->ptr.p_double[k]-b->ptr.p_double[k-2];
                }
            }
            d = e;
            k = k+1;
        }
        while(k<=n);
        d = b->ptr.p_double[i];
        e = 0;
        k = i;
        while(k<=n)
        {
            e = e+b->ptr.p_double[k]*a->ptr.p_double[k];
            k = k+2;
        }
        b->ptr.p_double[i] = e;
        i = i+1;
    }
    while(i<=n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x23b55
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x23add
xorl %eax, %eax
cmpq %r14, %rax
jg 0xc5c7
movq 0x28(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0xc5b4
xorl %eax, %eax
testq %r14, %r14
movl $0x0, %ecx
cmovgq %r14, %rcx
xorpd %xmm0, %xmm0
pushq $0x1
popq %rdx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
xorl %edi, %edi
cmpq %rdi, %r14
movq %rdi, %r9
cmovgq %r14, %r9
addq %rdx, %r9
leaq 0x1(%rdi), %r8
xorl %r10d, %r10d
movapd %xmm0, %xmm1
cmpq $0x2, %rdi
setae %r11b
movq 0x28(%rbx), %r12
addq %rax, %r12
movsd (%r12,%r10,8), %xmm0
andq $0x0, (%r12,%r10,8)
testq %r10, %r10
setne %bpl
orb %r11b, %bpl
jne 0xc630
movq 0x28(%rbx), %r11
movq %rsi, (%r11,%rdi,8)
jmp 0xc669
testq %rdi, %rdi
je 0xc646
addsd %xmm1, %xmm1
movq 0x28(%rbx), %r11
addq %rax, %r11
movsd %xmm1, (%r11,%r10,8)
leaq (%rdi,%r10), %r11
cmpq %r8, %r11
jbe 0xc669
movq 0x28(%rbx), %r11
addq %rax, %r11
movsd (%r11,%r10,8), %xmm1
subsd -0x10(%r11,%r10,8), %xmm1
movsd %xmm1, (%r11,%r10,8)
incq %r10
cmpq %r10, %r9
jne 0xc5fc
movq 0x28(%rbx), %r9
movsd (%r9,%rdi,8), %xmm0
xorpd %xmm1, %xmm1
movq %rdi, %r10
cmpq %r14, %r10
jg 0xc6a1
movsd (%r9,%r10,8), %xmm2
movq 0x28(%r15), %r11
mulsd (%r11,%r10,8), %xmm2
addsd %xmm2, %xmm1
addq $0x2, %r10
jmp 0xc682
movsd %xmm1, (%r9,%rdi,8)
decq %rdx
addq $0x8, %rax
cmpq %rcx, %rdi
movq %r8, %rdi
jne 0xc5e8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::chisquaredistribution(double, double)
double chisquaredistribution(const double v, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::chisquaredistribution(v, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xc789
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xc755
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3443c(%rip), %rsi     # 0x40b80
leaq 0x5fcd(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xc75a
callq 0x3330
movq %rax, %rbx
jmp 0xc76a
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xc779
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::chisquaredistribution(double, double, alglib_impl::ae_state*)
double chisquaredistribution(double v, double x, ae_state *_state)
{
    double result;


    ae_assert(ae_fp_greater_eq(x,0)&&ae_fp_greater_eq(v,1), "Domain error in ChiSquareDistribution", _state);
    result = incompletegamma(v/2.0, x/2.0, _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps %xmm1, %xmm2
movsd %xmm0, (%rsp)
xorps %xmm1, %xmm1
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
callq 0x24295
testb %al, %al
je 0xc7c2
movsd 0x23a42(%rip), %xmm1    # 0x301f8
movsd (%rsp), %xmm0
callq 0x24295
jmp 0xc7c4
xorl %eax, %eax
movzbl %al, %edi
leaq 0x26059(%rip), %rsi     # 0x32827
movq %rbx, %rdx
callq 0x238ca
movsd 0x23caa(%rip), %xmm2    # 0x30488
movsd (%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x579e
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::chisquarecdistribution(double, double)
double chisquarecdistribution(const double v, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::chisquarecdistribution(v, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xc8c4
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xc890
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x34301(%rip), %rsi     # 0x40b80
leaq 0x5e92(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xc895
callq 0x3330
movq %rax, %rbx
jmp 0xc8a5
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xc8b4
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::chisquarecdistribution(double, double, alglib_impl::ae_state*)
double chisquarecdistribution(double v, double x, ae_state *_state)
{
    double result;


    ae_assert(ae_fp_greater_eq(x,0)&&ae_fp_greater_eq(v,1), "Domain error in ChiSquareDistributionC", _state);
    result = incompletegammac(v/2.0, x/2.0, _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps %xmm1, %xmm2
movsd %xmm0, (%rsp)
xorps %xmm1, %xmm1
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
callq 0x24295
testb %al, %al
je 0xc8fd
movsd 0x23907(%rip), %xmm1    # 0x301f8
movsd (%rsp), %xmm0
callq 0x24295
jmp 0xc8ff
xorl %eax, %eax
movzbl %al, %edi
leaq 0x25f44(%rip), %rsi     # 0x3284d
movq %rbx, %rdx
callq 0x238ca
movsd 0x23b6f(%rip), %xmm2    # 0x30488
movsd (%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x59ff
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invchisquaredistribution(double, double)
double invchisquaredistribution(const double v, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invchisquaredistribution(v, y, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xc9ff
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xc9cb
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x341c6(%rip), %rsi     # 0x40b80
leaq 0x5d57(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xc9d0
callq 0x3330
movq %rax, %rbx
jmp 0xc9e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xc9ef
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::invchisquaredistribution(double, double, alglib_impl::ae_state*)
double invchisquaredistribution(double v, double y, ae_state *_state)
{
    double result;


    ae_assert((ae_fp_greater_eq(y,0)&&ae_fp_less_eq(y,1))&&ae_fp_greater_eq(v,1), "Domain error in InvChiSquareDistribution", _state);
    result = 2*invincompletegammac(0.5*v, y, _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps %xmm1, %xmm2
movsd %xmm0, (%rsp)
xorps %xmm1, %xmm1
movsd %xmm2, 0x8(%rsp)
movaps %xmm2, %xmm0
callq 0x24295
testb %al, %al
je 0xca4f
movsd 0x237cc(%rip), %xmm1    # 0x301f8
movsd 0x8(%rsp), %xmm0
callq 0x24259
testb %al, %al
je 0xca4f
movsd 0x237b5(%rip), %xmm1    # 0x301f8
movsd (%rsp), %xmm0
callq 0x24295
jmp 0xca51
xorl %eax, %eax
movzbl %al, %edi
leaq 0x25e19(%rip), %rsi     # 0x32874
movq %rbx, %rdx
callq 0x238ca
movsd (%rsp), %xmm0
mulsd 0x23a18(%rip), %xmm0    # 0x30488
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x5d6b
addsd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::dawsonintegral(double)
double dawsonintegral(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::dawsonintegral(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23772
movsd (%rsp), %xmm0
callq 0xcb38
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xcb04
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3408d(%rip), %rsi     # 0x40b80
leaq 0x5c1e(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xcb09
callq 0x3330
movq %rax, %rbx
jmp 0xcb19
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xcb28
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::ellipticintegralk(double)
double ellipticintegralk(const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::ellipticintegralk(m, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xcf84
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xcf50
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x33c41(%rip), %rsi     # 0x40b80
leaq 0x57d2(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xcf55
callq 0x3330
movq %rax, %rbx
jmp 0xcf65
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xcf74
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::ellipticintegralkhighprecision(double)
double ellipticintegralkhighprecision(const double m1)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::ellipticintegralkhighprecision(m1, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xd04f
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xd01b
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x33b76(%rip), %rsi     # 0x40b80
leaq 0x5707(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xd020
callq 0x3330
movq %rax, %rbx
jmp 0xd030
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xd03f
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::incompleteellipticintegralk(double, double)
double incompleteellipticintegralk(const double phi, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompleteellipticintegralk(phi, m, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd28b
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xd257
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3393a(%rip), %rsi     # 0x40b80
leaq 0x54cb(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xd25c
callq 0x3330
movq %rax, %rbx
jmp 0xd26c
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xd27b
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::ellipticintegrale(double)
double ellipticintegrale(const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::ellipticintegrale(m, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xd706
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xd6d2
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x334bf(%rip), %rsi     # 0x40b80
leaq 0x5050(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xd6d7
callq 0x3330
movq %rax, %rbx
jmp 0xd6e7
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xd6f6
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::incompleteellipticintegrale(double, double)
double incompleteellipticintegrale(const double phi, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompleteellipticintegrale(phi, m, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd96c
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xd938
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x33259(%rip), %rsi     # 0x40b80
leaq 0x4dea(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xd93d
callq 0x3330
movq %rax, %rbx
jmp 0xd94d
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xd95c
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d