LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::fdistribution(long, long, double)
double fdistribution(const ae_int_t a, const ae_int_t b, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::fdistribution(a, b, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x24fa7
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xf3b9
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 0xf385
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3380c(%rip), %rsi     # 0x42b80
leaq 0x3f47(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xf38a
callq 0x3360
movq %rax, %rbx
jmp 0xf39a
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xf3a9
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::fdistribution(long, long, double, alglib_impl::ae_state*)
double fdistribution(ae_int_t a, ae_int_t b, double x, ae_state *_state)
{
    double w;
    double result;


    ae_assert((a>=1&&b>=1)&&ae_fp_greater_eq(x,0), "Domain error in FDistribution", _state);
    w = a*x;
    w = w/(b+w);
    result = incompletebeta(0.5*a, 0.5*b, w, _state);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
setle %al
testq %rsi, %rsi
setle %cl
orb %al, %cl
movsd %xmm0, 0x8(%rsp)
jne 0xf3eb
xorps %xmm1, %xmm1
callq 0x25c15
jmp 0xf3ed
xorl %eax, %eax
movzbl %al, %edi
leaq 0x264e4(%rip), %rsi     # 0x358db
movq %rbx, %rdx
callq 0x2510e
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movapd %xmm2, %xmm3
addsd %xmm1, %xmm3
divsd %xmm3, %xmm2
movsd 0x2405b(%rip), %xmm3    # 0x33488
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa477
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::fcdistribution(long, long, double)
double fcdistribution(const ae_int_t a, const ae_int_t b, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::fcdistribution(a, b, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x24fa7
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xf512
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 0xf4de
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x336b3(%rip), %rsi     # 0x42b80
leaq 0x3dee(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xf4e3
callq 0x3360
movq %rax, %rbx
jmp 0xf4f3
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xf502
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::fcdistribution(long, long, double, alglib_impl::ae_state*)
double fcdistribution(ae_int_t a, ae_int_t b, double x, ae_state *_state)
{
    double w;
    double result;


    ae_assert((a>=1&&b>=1)&&ae_fp_greater_eq(x,0), "Domain error in FCDistribution", _state);
    w = b/(b+a*x);
    result = incompletebeta(0.5*b, 0.5*a, w, _state);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
setle %al
testq %rsi, %rsi
setle %cl
orb %al, %cl
movsd %xmm0, 0x8(%rsp)
jne 0xf544
xorps %xmm1, %xmm1
callq 0x25c15
jmp 0xf546
xorl %eax, %eax
movzbl %al, %edi
leaq 0x263a9(%rip), %rsi     # 0x358f9
movq %rbx, %rdx
callq 0x2510e
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movapd %xmm0, %xmm2
divsd %xmm3, %xmm2
movsd 0x23f02(%rip), %xmm3    # 0x33488
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa477
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invfdistribution(long, long, double)
double invfdistribution(const ae_int_t a, const ae_int_t b, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invfdistribution(a, b, y, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x24fa7
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xf66b
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 0xf637
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3355a(%rip), %rsi     # 0x42b80
leaq 0x3c95(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xf63c
callq 0x3360
movq %rax, %rbx
jmp 0xf64c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xf65b
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::invfdistribution(long, long, double, alglib_impl::ae_state*)
double invfdistribution(ae_int_t a,
     ae_int_t b,
     double y,
     ae_state *_state)
{
    double w;
    double result;


    ae_assert(((a>=1&&b>=1)&&ae_fp_greater(y,0))&&ae_fp_less_eq(y,1), "Domain error in InvFDistribution", _state);
    
    /*
     * Compute probability for x = 0.5
     */
    w = incompletebeta(0.5*b, 0.5*a, 0.5, _state);
    
    /*
     * If that is greater than y, then the solution w < .5
     * Otherwise, solve at 1-y to remove cancellation in (b - b*w)
     */
    if( ae_fp_greater(w,y)||ae_fp_less(y,0.001) )
    {
        w = invincompletebeta(0.5*b, 0.5*a, y, _state);
        result = (b-b*w)/(a*w);
    }
    else
    {
        w = invincompletebeta(0.5*a, 0.5*b, 1.0-y, _state);
        result = b*w/(a*(1.0-w));
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
setle %al
testq %rsi, %rsi
setle %cl
orb %al, %cl
movsd %xmm0, 0x8(%rsp)
jne 0xf6b4
xorps %xmm1, %xmm1
callq 0x25bf9
testb %al, %al
je 0xf6b4
movsd 0x23b39(%rip), %xmm1    # 0x331e0
movsd 0x8(%rsp), %xmm0
callq 0x25bd9
jmp 0xf6b6
xorl %eax, %eax
movzbl %al, %edi
leaq 0x26258(%rip), %rsi     # 0x35918
movq %rbx, %rdx
callq 0x2510e
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movsd 0x23db0(%rip), %xmm2    # 0x33488
movsd %xmm0, 0x20(%rsp)
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd %xmm2, %xmm1
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
callq 0xa477
movsd 0x8(%rsp), %xmm1
callq 0x25bf9
testb %al, %al
jne 0xf72e
movsd 0x24f71(%rip), %xmm1    # 0x34690
movsd 0x8(%rsp), %xmm0
callq 0x25bb9
testb %al, %al
je 0xf75c
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %rbx, %rdi
callq 0xb0e5
movapd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm1
jmp 0xf794
movsd 0x23a7c(%rip), %xmm2    # 0x331e0
subsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rdi
callq 0xb0e5
movsd 0x23a5a(%rip), %xmm2    # 0x331e0
movsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm0, %xmm2
mulsd 0x28(%rsp), %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::fresnelintegral(double, double&, double&)
void fresnelintegral(const double x, double &c, double &s)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::fresnelintegral(x, &c, &s, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x24fa7
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf86c
leaq 0x10(%rsp), %rdi
callq 0x24e4e
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0xf838
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x33359(%rip), %rsi     # 0x42b80
leaq 0x3a94(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xf83d
callq 0x3360
movq %rax, %rbx
jmp 0xf84d
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xf85c
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::hermitecalculate(long, double)
double hermitecalculate(const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::hermitecalculate(n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24fa7
testq %rbx, %rbx
je 0xfe2e
movsd (%rsp), %xmm2
addsd %xmm2, %xmm2
cmpq $0x1, %rbx
jne 0xfe38
movapd %xmm2, %xmm3
jmp 0xfe77
movsd 0x233aa(%rip), %xmm3    # 0x331e0
jmp 0xfe77
xorpd %xmm3, %xmm3
jle 0xfe77
decq %rbx
movsd 0x23397(%rip), %xmm0    # 0x331e0
movl $0x2, %eax
movapd %xmm2, %xmm3
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm3, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm1, %xmm3
addq $0x2, %rax
decq %rbx
jne 0xfe52
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 0xfed5
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x32cbc(%rip), %rsi     # 0x42b80
leaq 0x33f7(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0xfeda
callq 0x3360
movq %rax, %rbx
jmp 0xfeea
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0xfef9
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::hermitesum(alglib::real_1d_array const&, long, double)
double hermitesum(const real_1d_array &c, const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::hermitesum(const_cast<alglib_impl::ae_vector*>(c.c_ptr()), n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x24fa7
movq %r14, %rdi
callq 0x2b30a
testq %rbx, %rbx
js 0xffd6
movq 0x28(%rax), %rax
incq %rbx
xorpd %xmm3, %xmm3
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rbx, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm3, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm1, %xmm3
addsd %xmm3, %xmm3
addsd -0x8(%rax,%rbx,8), %xmm3
decq %rbx
jne 0xffa9
jmp 0xffda
xorpd %xmm3, %xmm3
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 0x10038
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x32b59(%rip), %rsi     # 0x42b80
leaq 0x3294(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x1003d
callq 0x3360
movq %rax, %rbx
jmp 0x1004d
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1005c
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::hermitesum(alglib_impl::ae_vector*, long, double, alglib_impl::ae_state*)
double hermitesum(/* Real    */ ae_vector* c,
     ae_int_t n,
     double x,
     ae_state *_state)
{
    double b1;
    double b2;
    ae_int_t i;
    double result;


    b1 = 0;
    b2 = 0;
    result = 0;
    for(i=n; i>=0; i--)
    {
        result = 2*(x*b1-(i+1)*b2)+c->ptr.p_double[i];
        b2 = b1;
        b1 = result;
    }
    return result;
}

// Assembly:
testq %rsi, %rsi
js 0x100ad
movq 0x28(%rdi), %rax
incq %rsi
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %rsi, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
addsd %xmm1, %xmm1
addsd -0x8(%rax,%rsi,8), %xmm1
decq %rsi
jne 0x10080
jmp 0x100b1
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::hermitecoefficients(long, alglib::real_1d_array&)
void hermitecoefficients(const ae_int_t n, real_1d_array &c)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::hermitecoefficients(n, const_cast<alglib_impl::ae_vector*>(c.c_ptr()), &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24fa7
movq %r14, %rdi
callq 0x2b310
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1016d
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 0x10139
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x32a58(%rip), %rsi     # 0x42b80
leaq 0x3193(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x1013e
callq 0x3360
movq %rax, %rbx
jmp 0x1014e
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1015d
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::hermitecoefficients(long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void hermitecoefficients(ae_int_t n,
     /* Real    */ ae_vector* c,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(c);

    ae_vector_set_length(c, n+1, _state);
    for(i=0; i<=n; i++)
    {
        c->ptr.p_double[i] = 0;
    }
    c->ptr.p_double[n] = ae_exp(n*ae_log(2, _state), _state);
    for(i=0; i<=n/2-1; i++)
    {
        c->ptr.p_double[n-2*(i+1)] = -c->ptr.p_double[n-2*i]*(n-2*i)*(n-2*i-1)/4/(i+1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x253a5
leaq 0x1(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x25326
testq %r14, %r14
js 0x101b3
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x1019f
cvtsi2sd %r14, %xmm0
movsd %xmm0, (%rsp)
movsd 0x2323b(%rip), %xmm0    # 0x33400
movq %r15, %rdi
callq 0x25f91
mulsd (%rsp), %xmm0
movq %r15, %rdi
callq 0x25f9b
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
cmpq $0x2, %r14
jl 0x10254
movq %r14, %rax
shrq $0x3f, %rax
addq %r14, %rax
sarq %rax
negq %rax
movl $0x1, %ecx
movsd 0x240e1(%rip), %xmm0    # 0x342e8
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movq 0x28(%rbx), %rdx
mulsd (%rdx,%r14,8), %xmm1
leaq -0x1(%r14), %rsi
xorps %xmm2, %xmm2
cvtsi2sd %rsi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, -0x10(%rdx,%r14,8)
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
addq $-0x2, %r14
cmpq $0x1, %rdx
jne 0x10207
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::jacobianellipticfunctions(double, double, double&, double&, double&, double&)
void jacobianellipticfunctions(const double u, const double m, double &sn, double &cn, double &dn, double &ph)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::jacobianellipticfunctions(u, m, &sn, &cn, &dn, &ph, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x24fa7
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x1033e
leaq 0x10(%rsp), %rdi
callq 0x24e4e
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x1030a
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x32887(%rip), %rsi     # 0x42b80
leaq 0x2fc2(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x1030f
callq 0x3360
movq %rax, %rbx
jmp 0x1031f
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1032e
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::laguerrecalculate(long, double)
double laguerrecalculate(const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::laguerrecalculate(n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x10939
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 0x10905
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3228c(%rip), %rsi     # 0x42b80
leaq 0x29c7(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x1090a
callq 0x3360
movq %rax, %rbx
jmp 0x1091a
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10929
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::laguerrecalculate(long, double, alglib_impl::ae_state*)
double laguerrecalculate(ae_int_t n, double x, ae_state *_state)
{
    double a;
    double b;
    double i;
    double result;


    result = 1;
    a = 1;
    b = 1-x;
    if( n==1 )
    {
        result = b;
    }
    i = 2;
    while(ae_fp_less_eq(i,n))
    {
        result = ((2*i-1-x)*b-(i-1)*a)/i;
        a = b;
        b = result;
        i = i+1;
    }
    return result;
}

// Assembly:
subq $0x28, %rsp
movsd 0x2289b(%rip), %xmm1    # 0x331e0
movapd %xmm1, %xmm2
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
cmpq $0x1, %rdi
je 0x10966
movapd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %rdi, %xmm1
movsd 0x22a84(%rip), %xmm0    # 0x33400
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
callq 0x25bd9
movsd 0x8(%rsp), %xmm0
testb %al, %al
movsd 0x10(%rsp), %xmm1
je 0x10a21
movsd 0x22837(%rip), %xmm2    # 0x331e0
movsd (%rsp), %xmm0
movapd %xmm0, %xmm4
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movapd %xmm0, %xmm5
addsd %xmm0, %xmm5
movsd 0x2283b(%rip), %xmm3    # 0x33208
addsd %xmm3, %xmm5
subsd %xmm1, %xmm5
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm4, %xmm5
subsd %xmm1, %xmm5
divsd %xmm0, %xmm5
movsd %xmm5, 0x8(%rsp)
addsd 0x227e5(%rip), %xmm0    # 0x331e0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
callq 0x25bd9
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm2
testb %al, %al
jne 0x109ae
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::laguerresum(alglib::real_1d_array const&, long, double)
double laguerresum(const real_1d_array &c, const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::laguerresum(const_cast<alglib_impl::ae_vector*>(c.c_ptr()), n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x24fa7
movq %r14, %rdi
callq 0x2b30a
movq %rax, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x10aec
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 0x10ab8
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x320d9(%rip), %rsi     # 0x42b80
leaq 0x2814(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x10abd
callq 0x3360
movq %rax, %rbx
jmp 0x10acd
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10adc
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::laguerresum(alglib_impl::ae_vector*, long, double, alglib_impl::ae_state*)
double laguerresum(/* Real    */ ae_vector* c,
     ae_int_t n,
     double x,
     ae_state *_state)
{
    double b1;
    double b2;
    ae_int_t i;
    double result;


    b1 = 0;
    b2 = 0;
    result = 0;
    for(i=n; i>=0; i--)
    {
        result = (2*i+1-x)*b1/(i+1)-(i+1)*b2/(i+2)+c->ptr.p_double[i];
        b2 = b1;
        b1 = result;
    }
    return result;
}

// Assembly:
testq %rsi, %rsi
js 0x10ba7
movq 0x28(%rdi), %rax
leaq 0x1(,%rsi,2), %rcx
xorpd %xmm2, %xmm2
movdqa 0x24733(%rip), %xmm3    # 0x35240
movdqa 0x2473b(%rip), %xmm4    # 0x35250
movdqa 0x243b3(%rip), %xmm5    # 0x34ed0
movdqa 0x2473b(%rip), %xmm6    # 0x35260
movapd 0x24743(%rip), %xmm7    # 0x35270
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
subsd %xmm0, %xmm1
movq %rsi, %xmm8
pshufd $0x44, %xmm8, %xmm8     # xmm8 = xmm8[0,1,0,1]
paddq %xmm3, %xmm8
movdqa %xmm8, %xmm9
pand %xmm4, %xmm9
por %xmm5, %xmm9
psrlq $0x20, %xmm8
por %xmm6, %xmm8
subpd %xmm7, %xmm8
addpd %xmm9, %xmm8
movapd %xmm8, %xmm9
shufpd $0x1, %xmm1, %xmm9      # xmm9 = xmm9[1],xmm1[0]
mulpd %xmm2, %xmm9
divpd %xmm8, %xmm9
movapd %xmm9, %xmm1
unpckhpd %xmm9, %xmm1            # xmm1 = xmm1[1],xmm9[1]
subsd %xmm9, %xmm1
addsd (%rax,%rsi,8), %xmm1
addq $-0x2, %rcx
shufpd $0x1, %xmm1, %xmm2      # xmm2 = xmm2[1],xmm1[0]
addq $-0x1, %rsi
jb 0x10b2d
jmp 0x10bab
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::laguerrecoefficients(long, alglib::real_1d_array&)
void laguerrecoefficients(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::laguerrecoefficients(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 0x10c67
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 0x10c33
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x31f5e(%rip), %rsi     # 0x42b80
leaq 0x2699(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x10c38
callq 0x3360
movq %rax, %rbx
jmp 0x10c48
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10c57
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::laguerrecoefficients(long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void laguerrecoefficients(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);
    c->ptr.p_double[0] = 1;
    for(i=0; i<=n-1; i++)
    {
        c->ptr.p_double[i+1] = -c->ptr.p_double[i]*(n-i)/(i+1)/(i+1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x253a5
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x25326
movq 0x28(%rbx), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
testq %r14, %r14
jle 0x10ce6
movl $0x1, %eax
movapd 0x22501(%rip), %xmm0    # 0x331b0
movq 0x28(%rbx), %rcx
movsd -0x8(%rcx,%rax,8), %xmm1
xorpd %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %r14, %xmm2
mulsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, (%rcx,%rax,8)
incq %rax
decq %r14
jne 0x10caf
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::legendrecalculate(long, double)
double legendrecalculate(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::legendrecalculate(n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24fa7
movq %r14, %rdi
callq 0x24e4e
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x10d9b
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x10d67
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x31e2a(%rip), %rsi     # 0x42b80
leaq 0x2565(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x10d6c
callq 0x3360
movq %rax, %rbx
jmp 0x10d7c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10d8b
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::legendrecalculate(long, double, alglib_impl::ae_state*)
double legendrecalculate(ae_int_t n, double x, ae_state *_state)
{
    double a;
    double b;
    ae_int_t i;
    double result;


    result = 1;
    a = 1;
    b = x;
    if( n==0 )
    {
        result = a;
        return result;
    }
    if( n==1 )
    {
        result = b;
        return result;
    }
    for(i=2; i<=n; i++)
    {
        result = ((2*i-1)*x*b-(i-1)*a)/i;
        a = b;
        b = result;
    }
    return result;
}

// Assembly:
movsd 0x2243d(%rip), %xmm1    # 0x331e0
testq %rdi, %rdi
je 0x10e08
cmpq $0x1, %rdi
jne 0x10db4
movapd %xmm0, %xmm1
jmp 0x10e08
jle 0x10e08
movsd 0x22422(%rip), %xmm2    # 0x331e0
movl $0x1, %eax
movl $0x3, %ecx
movapd %xmm0, %xmm1
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd %xmm0, %xmm1
incq %rax
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
divsd %xmm3, %xmm1
addq $0x2, %rcx
cmpq %rax, %rdi
jne 0x10dcc
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::legendresum(alglib::real_1d_array const&, long, double)
double legendresum(const real_1d_array &c, const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::legendresum(const_cast<alglib_impl::ae_vector*>(c.c_ptr()), n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x24fa7
movq %r14, %rdi
callq 0x2b30a
movq %rax, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x10ed3
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 0x10e9f
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x31cf2(%rip), %rsi     # 0x42b80
leaq 0x242d(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x10ea4
callq 0x3360
movq %rax, %rbx
jmp 0x10eb4
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x10ec3
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::legendresum(alglib_impl::ae_vector*, long, double, alglib_impl::ae_state*)
double legendresum(/* Real    */ ae_vector* c,
     ae_int_t n,
     double x,
     ae_state *_state)
{
    double b1;
    double b2;
    ae_int_t i;
    double result;


    b1 = 0;
    b2 = 0;
    result = 0;
    for(i=n; i>=0; i--)
    {
        result = (2*i+1)*x*b1/(i+1)-(i+1)*b2/(i+2)+c->ptr.p_double[i];
        b2 = b1;
        b1 = result;
    }
    return result;
}

// Assembly:
testq %rsi, %rsi
js 0x10f8e
movq 0x28(%rdi), %rax
leaq 0x1(,%rsi,2), %rcx
xorpd %xmm2, %xmm2
movdqa 0x2434c(%rip), %xmm3    # 0x35240
movdqa 0x24354(%rip), %xmm4    # 0x35250
movdqa 0x23fcc(%rip), %xmm5    # 0x34ed0
movdqa 0x24354(%rip), %xmm6    # 0x35260
movapd 0x2435c(%rip), %xmm7    # 0x35270
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd %xmm0, %xmm1
movq %rsi, %xmm8
pshufd $0x44, %xmm8, %xmm8     # xmm8 = xmm8[0,1,0,1]
paddq %xmm3, %xmm8
movdqa %xmm8, %xmm9
pand %xmm4, %xmm9
por %xmm5, %xmm9
psrlq $0x20, %xmm8
por %xmm6, %xmm8
subpd %xmm7, %xmm8
addpd %xmm9, %xmm8
movapd %xmm8, %xmm9
shufpd $0x1, %xmm1, %xmm9      # xmm9 = xmm9[1],xmm1[0]
mulpd %xmm2, %xmm9
divpd %xmm8, %xmm9
movapd %xmm9, %xmm1
unpckhpd %xmm9, %xmm1            # xmm1 = xmm1[1],xmm9[1]
subsd %xmm9, %xmm1
addsd (%rax,%rsi,8), %xmm1
addq $-0x2, %rcx
shufpd $0x1, %xmm1, %xmm2      # xmm2 = xmm2[1],xmm1[0]
addq $-0x1, %rsi
jb 0x10f14
jmp 0x10f92
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::legendrecoefficients(long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void legendrecoefficients(ae_int_t n,
     /* Real    */ ae_vector* c,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(c);

    ae_vector_set_length(c, n+1, _state);
    for(i=0; i<=n; i++)
    {
        c->ptr.p_double[i] = 0;
    }
    c->ptr.p_double[n] = 1;
    for(i=1; i<=n; i++)
    {
        c->ptr.p_double[n] = c->ptr.p_double[n]*(n+i)/2/i;
    }
    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)/2/(i+1)/(2*(n-i)-1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
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 0x11185
movq $-0x1, %rax
movq 0x28(%r14), %rcx
movq $0x0, 0x8(%rcx,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x11083
movq 0x28(%r14), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%rbx,8)
testq %rbx, %rbx
je 0x11197
movq %rbx, %rax
negq %rax
movl $0x1, %ecx
movsd 0x223c2(%rip), %xmm0    # 0x33488
movq 0x28(%r14), %rdx
leaq (%rbx,%rcx), %rsi
xorps %xmm1, %xmm1
cvtsi2sd %rsi, %xmm1
mulsd (%rdx,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %rcx, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, (%rdx,%rbx,8)
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
cmpq $0x1, %rdx
jne 0x110c6
cmpq $0x2, %rbx
jl 0x11197
movq %rbx, %rax
shrq %rax
leaq -0x1(,%rbx,2), %rcx
negq %rax
movl $0x1, %edx
movsd 0x22380(%rip), %xmm0    # 0x334a8
xorps %xmm1, %xmm1
cvtsi2sd %rbx, %xmm1
movq 0x28(%r14), %rsi
mulsd (%rsi,%rbx,8), %xmm1
leaq -0x1(%rbx), %rdi
xorps %xmm2, %xmm2
cvtsi2sd %rdi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
xorps %xmm3, %xmm3
cvtsi2sd %rcx, %xmm3
divsd %xmm1, %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, -0x10(%rsi,%rbx,8)
addq $-0x2, %rcx
leaq (%rax,%rdx), %rsi
incq %rsi
incq %rdx
addq $-0x2, %rbx
cmpq $0x1, %rsi
jne 0x11128
jmp 0x11197
movq 0x28(%r14), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%rbx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::poissondistribution(long, double)
double poissondistribution(const ae_int_t k, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::poissondistribution(k, 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)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x1125b
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 0x11227
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3196a(%rip), %rsi     # 0x42b80
leaq 0x20a5(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x1122c
callq 0x3360
movq %rax, %rbx
jmp 0x1123c
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1124b
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::poissoncdistribution(long, double)
double poissoncdistribution(const ae_int_t k, const double m)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::poissoncdistribution(k, 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)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x1136a
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 0x11336
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3185b(%rip), %rsi     # 0x42b80
leaq 0x1f96(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x1133b
callq 0x3360
movq %rax, %rbx
jmp 0x1134b
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1135a
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::invpoissondistribution(long, double)
double invpoissondistribution(const ae_int_t k, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invpoissondistribution(k, 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 $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x11479
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 0x11445
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3174c(%rip), %rsi     # 0x42b80
leaq 0x1e87(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x1144a
callq 0x3360
movq %rax, %rbx
jmp 0x1145a
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x11469
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::invpoissondistribution(long, double, alglib_impl::ae_state*)
double invpoissondistribution(ae_int_t k, double y, ae_state *_state)
{
    double result;


    ae_assert((k>=0&&ae_fp_greater_eq(y,0))&&ae_fp_less(y,1), "Domain error in InvPoissonDistribution", _state);
    result = invincompletegammac(k+1, y, _state);
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
movsd %xmm0, (%rsp)
js 0x114ad
xorps %xmm1, %xmm1
callq 0x25c15
testb %al, %al
je 0x114ad
movsd 0x21d3f(%rip), %xmm1    # 0x331e0
movsd (%rsp), %xmm0
callq 0x25bb9
jmp 0x114af
xorl %eax, %eax
movzbl %al, %edi
leaq 0x24525(%rip), %rsi     # 0x359de
movq %rbx, %rdx
callq 0x2510e
incq %r14
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movsd (%rsp), %xmm1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x63de
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::studenttdistribution(long, double)
double studenttdistribution(const ae_int_t k, const double t)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::studenttdistribution(k, t, &_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 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x1194f
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 0x1191b
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x31276(%rip), %rsi     # 0x42b80
leaq 0x19b1(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x11920
callq 0x3360
movq %rax, %rbx
jmp 0x11930
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1193f
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::invstudenttdistribution(long, double)
double invstudenttdistribution(const ae_int_t k, const double p)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invstudenttdistribution(k, 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 %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x11d10
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 0x11cdc
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x30eb5(%rip), %rsi     # 0x42b80
leaq 0x15f0(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x11ce1
callq 0x3360
movq %rax, %rbx
jmp 0x11cf1
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x11d00
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::sinecosineintegrals(double, double&, double&)
void sinecosineintegrals(const double x, double &si, double &ci)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::sinecosineintegrals(x, &si, &ci, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x24fa7
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x11ff4
leaq 0x10(%rsp), %rdi
callq 0x24e4e
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x11fc0
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x30bd1(%rip), %rsi     # 0x42b80
leaq 0x130c(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x11fc5
callq 0x3360
movq %rax, %rbx
jmp 0x11fd5
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x11fe4
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7