LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xa15b
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xa127
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x38a6a(%rip), %rsi     # 0x42b80
leaq 0x91a5(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xa12c
callq 0x3360
movq %rax, %rbx
jmp 0xa13c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xa14b
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm2
movq %rbx, %rdi
callq 0xa477
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xa443
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3874e(%rip), %rsi     # 0x42b80
leaq 0x8e89(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xa448
callq 0x3360
movq %rax, %rbx
jmp 0xa458
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xa467
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm2
movq %rbx, %rdi
callq 0xb0e5
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xb0b1
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x37ae0(%rip), %rsi     # 0x42b80
leaq 0x821b(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xb0b6
callq 0x3360
movq %rax, %rbx
jmp 0xb0c6
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xb0d5
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xc346
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x24e4e
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 0xc312
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3687f(%rip), %rsi     # 0x42b80
leaq 0x6fba(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xc317
callq 0x3360
movq %rax, %rbx
jmp 0xc327
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xc336
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25c15
testb %al, %al
je 0xc390
movsd 0x26e5d(%rip), %xmm1    # 0x331e0
movsd 0x8(%rsp), %xmm0
callq 0x25bd9
jmp 0xc392
xorl %eax, %eax
movzbl %al, %edi
leaq 0x29428(%rip), %r12     # 0x357c4
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
cmpq $-0x1, %r14
setge %al
cmpq %r14, %r15
setge %cl
andb %al, %cl
movzbl %cl, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
cmpq $-0x1, %r14
je 0xc3dd
subq %r14, %r15
jne 0xc3ef
movsd 0x26e09(%rip), %xmm0    # 0x331e0
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 0xc429
incq %r14
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd 0x26dd4(%rip), %xmm2    # 0x331e0
subsd 0x8(%rsp), %xmm2
movapd %xmm3, %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa477
movsd 0x26daf(%rip), %xmm0    # 0x331e0
subsd 0x8(%rsp), %xmm0
movapd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x25f96
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xc51a
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x24e4e
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 0xc4e6
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x366ab(%rip), %rsi     # 0x42b80
leaq 0x6de6(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xc4eb
callq 0x3360
movq %rax, %rbx
jmp 0xc4fb
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xc50a
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25c15
testb %al, %al
je 0xc554
movsd 0x26c98(%rip), %xmm1    # 0x331e0
movapd (%rsp), %xmm0
callq 0x25bd9
jmp 0xc556
xorl %eax, %eax
movzbl %al, %edi
leaq 0x29289(%rip), %r12     # 0x357e9
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
cmpq $-0x1, %r14
setge %al
cmpq %r14, %r15
setge %cl
andb %al, %cl
movzbl %cl, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
cmpq $-0x1, %r14
je 0xc5c6
xorpd %xmm0, %xmm0
subq %r14, %r15
je 0xc5ce
xorps %xmm1, %xmm1
cvtsi2sd %r15, %xmm1
testq %r14, %r14
je 0xc5da
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 0xa477
movsd 0x26c12(%rip), %xmm0    # 0x331e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd %xmm1, 0x10(%rsp)
movsd 0x27cf0(%rip), %xmm1    # 0x342d8
movaps (%rsp), %xmm0
callq 0x25bb9
testb %al, %al
je 0xc622
movapd (%rsp), %xmm0
xorpd 0x26bae(%rip), %xmm0    # 0x331b0
movq %rbx, %rdi
callq 0x245c2
mulsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x246e6
xorpd 0x26b90(%rip), %xmm0    # 0x331b0
jmp 0xc5ce
movsd 0x26bb6(%rip), %xmm0    # 0x331e0
subsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rdi
callq 0x25f96
movsd 0x26b9b(%rip), %xmm1    # 0x331e0
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xc5ce
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xc71e
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x24e4e
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 0xc6ea
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x364a7(%rip), %rsi     # 0x42b80
leaq 0x6be2(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xc6ef
callq 0x3360
movq %rax, %rbx
jmp 0xc6ff
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xc70e
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x290c1(%rip), %rsi     # 0x3580f
callq 0x2510e
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
testq %r14, %r14
movsd %xmm0, 0x10(%rsp)
je 0xc7c0
incq %r14
cvtsi2sd %r14, %xmm1
movsd 0x26d12(%rip), %xmm2    # 0x33488
movsd %xmm1, 0x18(%rsp)
movq %rbx, %rdi
callq 0xa477
movsd 0x26cfc(%rip), %xmm1    # 0x33488
callq 0x25bf9
testb %al, %al
je 0xc809
movsd 0x26a43(%rip), %xmm2    # 0x331e0
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 0xb0e5
movsd 0x27b18(%rip), %xmm1    # 0x342e0
movsd 0x8(%rsp), %xmm0
callq 0x25bf9
testb %al, %al
je 0xc825
movsd 0x8(%rsp), %xmm0
addsd 0x26a23(%rip), %xmm0    # 0x33208
movq %rbx, %rdi
callq 0x245c2
divsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x246e6
movapd %xmm0, %xmm1
xorpd 0x269a9(%rip), %xmm1    # 0x331b0
jmp 0xc84d
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %rbx, %rdi
callq 0xb0e5
jmp 0xc841
movsd 0x269b3(%rip), %xmm1    # 0x331e0
divsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25f96
movsd 0x26997(%rip), %xmm1    # 0x331e0
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm2
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
cmpq $0x1, %r14
je 0xc88e
movapd %xmm0, %xmm2
testq %rbx, %rbx
je 0xc89f
cmpq $0x1, %rbx
jne 0xc8a9
movapd %xmm2, %xmm3
jmp 0xc8d7
movsd 0x26939(%rip), %xmm3    # 0x331e0
jmp 0xc8d7
xorpd %xmm3, %xmm3
jle 0xc8d7
decq %rbx
movsd 0x26926(%rip), %xmm1    # 0x331e0
movapd %xmm2, %xmm3
movapd %xmm3, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
subsd %xmm1, %xmm3
movapd %xmm2, %xmm1
decq %rbx
jne 0xc8be
movsd %xmm3, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xc935
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3625c(%rip), %rsi     # 0x42b80
leaq 0x6997(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xc93a
callq 0x3360
movq %rax, %rbx
jmp 0xc94a
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xc959
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x70, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rdi
callq 0x24fa7
movq %r15, %rdi
callq 0x2b30a
testq %r14, %r14
jle 0xca40
movsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm0
movq 0x28(%rax), %rax
incq %r14
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm2, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm3, %xmm2
subsd %xmm1, %xmm2
addsd -0x8(%rax,%r14,8), %xmm2
decq %r14
movapd %xmm3, %xmm1
cmpq $0x1, %r14
ja 0xca0f
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
jmp 0xca53
movq 0x28(%rax), %rax
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x24e4e
cmpq $0x1, %rbx
je 0xca79
movsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm0
jmp 0xca7f
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
mulsd %xmm1, %xmm0
subsd %xmm2, %xmm0
addsd 0x18(%rsp), %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xcae4
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x68(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x360ad(%rip), %rsi     # 0x42b80
leaq 0x67e8(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xcae9
callq 0x3360
movq %rax, %rbx
jmp 0xcaf9
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xcb08
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movq %r14, %rdi
callq 0x2b310
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xcc33
leaq 0x8(%rsp), %rdi
callq 0x24e4e
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xcbff
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x35f92(%rip), %rsi     # 0x42b80
leaq 0x66cd(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xcc04
callq 0x3360
movq %rax, %rbx
jmp 0xcc14
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xcc23
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x253a5
leaq 0x1(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x25326
testq %rbx, %rbx
js 0xcc99
movq $-0x1, %rax
movq 0x28(%r14), %rcx
movq $0x0, 0x8(%rcx,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0xcc67
cmpq $0x1, %rbx
ja 0xcc99
movq 0x28(%r14), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%rbx,8)
jmp 0xcd4a
leaq -0x1(%rbx), %r12
cvtsi2sd %r12, %xmm0
movsd %xmm0, (%rsp)
movsd 0x26751(%rip), %xmm0    # 0x33400
movq %r15, %rdi
callq 0x25f91
mulsd (%rsp), %xmm0
movq %r15, %rdi
callq 0x25f9b
movq 0x28(%r14), %rax
movsd %xmm0, (%rax,%rbx,8)
cmpq $0x2, %rbx
jl 0xcd4a
movq %rbx, %rax
shrq $0x3f, %rax
addq %rbx, %rax
sarq %rax
negq %rax
movl $0x1, %ecx
movsd 0x275f8(%rip), %xmm0    # 0x342e8
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 0xccf0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movq %r15, %rdi
callq 0x2b30a
movq %rax, %r15
movq %r14, %rdi
callq 0x2b310
movq %rsp, %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xce1c
movq %rsp, %rdi
callq 0x24e4e
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xcde8
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x35da9(%rip), %rsi     # 0x42b80
leaq 0x64e4(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xcded
callq 0x3360
movq %rax, %rbx
jmp 0xcdfd
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xce0c
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::fromchebyshev(alglib_impl::ae_vector*, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void fromchebyshev(/* Real    */ ae_vector* a,
     ae_int_t n,
     /* Real    */ ae_vector* b,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t k;
    double e;
    double d;

    ae_vector_clear(b);

    ae_vector_set_length(b, n+1, _state);
    for(i=0; i<=n; i++)
    {
        b->ptr.p_double[i] = 0;
    }
    d = 0;
    i = 0;
    do
    {
        k = i;
        do
        {
            e = b->ptr.p_double[k];
            b->ptr.p_double[k] = 0;
            if( i<=1&&k==i )
            {
                b->ptr.p_double[k] = 1;
            }
            else
            {
                if( i!=0 )
                {
                    b->ptr.p_double[k] = 2*d;
                }
                if( k>i+1 )
                {
                    b->ptr.p_double[k] = b->ptr.p_double[k]-b->ptr.p_double[k-2];
                }
            }
            d = e;
            k = k+1;
        }
        while(k<=n);
        d = b->ptr.p_double[i];
        e = 0;
        k = i;
        while(k<=n)
        {
            e = e+b->ptr.p_double[k]*a->ptr.p_double[k];
            k = k+2;
        }
        b->ptr.p_double[i] = e;
        i = i+1;
    }
    while(i<=n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x253a5
leaq 0x1(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x25326
testq %r14, %r14
js 0xce66
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0xce52
xorl %eax, %eax
testq %r14, %r14
movl $0x0, %ecx
cmovgq %r14, %rcx
xorpd %xmm0, %xmm0
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rax, %rsi
incq %rax
xorl %edi, %edi
movq %rsi, %r8
movapd %xmm0, %xmm1
cmpq $0x2, %rsi
setae %r9b
movq 0x28(%rbx), %r10
movsd (%r10,%r8,8), %xmm0
movq $0x0, (%r10,%r8,8)
subq $0x1, %rdi
setae %r10b
orb %r9b, %r10b
jne 0xcec2
movq 0x28(%rbx), %r9
movq %rdx, (%r9,%rsi,8)
jmp 0xcef1
testq %rsi, %rsi
je 0xced5
addsd %xmm1, %xmm1
movq 0x28(%rbx), %r9
movsd %xmm1, (%r9,%r8,8)
cmpq %rax, %r8
jbe 0xcef1
movq 0x28(%rbx), %r9
movsd (%r9,%r8,8), %xmm1
subsd -0x10(%r9,%r8,8), %xmm1
movsd %xmm1, (%r9,%r8,8)
leaq 0x1(%r8), %r9
cmpq %r14, %r8
movq %r9, %r8
jl 0xce8d
movq 0x28(%rbx), %rdi
movsd (%rdi,%rsi,8), %xmm0
xorpd %xmm1, %xmm1
cmpq %r14, %rsi
jg 0xcf2f
movq 0x28(%r15), %r8
movq %rsi, %r9
movsd (%rdi,%r9,8), %xmm2
mulsd (%r8,%r9,8), %xmm2
addsd %xmm2, %xmm1
addq $0x2, %r9
cmpq %r14, %r9
jle 0xcf16
movsd %xmm1, (%rdi,%rsi,8)
cmpq %rcx, %rsi
jne 0xce82
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd00f
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xcfdb
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x35bb6(%rip), %rsi     # 0x42b80
leaq 0x62f1(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xcfe0
callq 0x3360
movq %rax, %rbx
jmp 0xcff0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xcfff
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25c15
testb %al, %al
je 0xd048
movsd 0x261a4(%rip), %xmm1    # 0x331e0
movsd (%rsp), %xmm0
callq 0x25c15
jmp 0xd04a
xorl %eax, %eax
movzbl %al, %edi
leaq 0x287e3(%rip), %rsi     # 0x35837
movq %rbx, %rdx
callq 0x2510e
movsd 0x26424(%rip), %xmm2    # 0x33488
movsd (%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x5e0d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd14c
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd118
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x35a79(%rip), %rsi     # 0x42b80
leaq 0x61b4(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xd11d
callq 0x3360
movq %rax, %rbx
jmp 0xd12d
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd13c
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25c15
testb %al, %al
je 0xd185
movsd 0x26067(%rip), %xmm1    # 0x331e0
movsd (%rsp), %xmm0
callq 0x25c15
jmp 0xd187
xorl %eax, %eax
movzbl %al, %edi
leaq 0x286cc(%rip), %rsi     # 0x3585d
movq %rbx, %rdx
callq 0x2510e
movsd 0x262e7(%rip), %xmm2    # 0x33488
movsd (%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x6070
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xd289
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd255
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3593c(%rip), %rsi     # 0x42b80
leaq 0x6077(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xd25a
callq 0x3360
movq %rax, %rbx
jmp 0xd26a
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd279
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25c15
testb %al, %al
je 0xd2d9
movsd 0x25f2a(%rip), %xmm1    # 0x331e0
movsd 0x8(%rsp), %xmm0
callq 0x25bd9
testb %al, %al
je 0xd2d9
movsd 0x25f13(%rip), %xmm1    # 0x331e0
movsd (%rsp), %xmm0
callq 0x25c15
jmp 0xd2db
xorl %eax, %eax
movzbl %al, %edi
leaq 0x2859f(%rip), %rsi     # 0x35884
movq %rbx, %rdx
callq 0x2510e
movsd (%rsp), %xmm0
mulsd 0x2618e(%rip), %xmm0    # 0x33488
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x63de
addsd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
callq 0xd3c4
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd390
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x35801(%rip), %rsi     # 0x42b80
leaq 0x5f3c(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xd395
callq 0x3360
movq %rax, %rbx
jmp 0xd3a5
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd3b4
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x25a65(%rip), %xmm0    # 0x331e0
subsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xd8e7
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd7e6
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x353ab(%rip), %rsi     # 0x42b80
leaq 0x5ae6(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xd7eb
callq 0x3360
movq %rax, %rbx
jmp 0xd7fb
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd80a
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xd8e7
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xd8b3
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x352de(%rip), %rsi     # 0x42b80
leaq 0x5a19(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xd8b8
callq 0x3360
movq %rax, %rbx
jmp 0xd8c8
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xd8d7
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xdb25
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xdaf1
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x350a0(%rip), %rsi     # 0x42b80
leaq 0x57db(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xdaf6
callq 0x3360
movq %rax, %rbx
jmp 0xdb06
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xdb15
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xe01b
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xdfe7
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x34baa(%rip), %rsi     # 0x42b80
leaq 0x52e5(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xdfec
callq 0x3360
movq %rax, %rbx
jmp 0xdffc
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xe00b
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0xe283
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xe24f
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x34942(%rip), %rsi     # 0x42b80
leaq 0x507d(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xe254
callq 0x3360
movq %rax, %rbx
jmp 0xe264
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xe273
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::exponentialintegralei(double)
double exponentialintegralei(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::exponentialintegralei(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xe7bd
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xe789
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x34408(%rip), %rsi     # 0x42b80
leaq 0x4b43(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xe78e
callq 0x3360
movq %rax, %rbx
jmp 0xe79e
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xe7ad
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::exponentialintegralen(double, long)
double exponentialintegralen(const double x, const ae_int_t n)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::exponentialintegralen(x, n, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedb7
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xed83
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x33e0e(%rip), %rsi     # 0x42b80
leaq 0x4549(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xed88
callq 0x3360
movq %rax, %rbx
jmp 0xed98
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xeda7
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7