LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0xde75
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xde41
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x32d50(%rip), %rsi     # 0x40b80
leaq 0x48e1(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xde46
callq 0x3330
movq %rax, %rbx
jmp 0xde56
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xde65
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe46d
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xe439
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x32758(%rip), %rsi     # 0x40b80
leaq 0x42e9(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xe43e
callq 0x3330
movq %rax, %rbx
jmp 0xe44e
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xe45d
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xea2f
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xe9fb
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x32196(%rip), %rsi     # 0x40b80
leaq 0x3d27(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xea00
callq 0x3330
movq %rax, %rbx
jmp 0xea10
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xea1f
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0xea61
xorps %xmm1, %xmm1
callq 0x24295
jmp 0xea63
xorl %eax, %eax
movzbl %al, %edi
leaq 0x23e5e(%rip), %rsi     # 0x328cb
movq %rbx, %rdx
callq 0x238ca
cvtsi2sd %r15, %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
cvtsi2sd %r14, %xmm1
movapd %xmm2, %xmm3
addsd %xmm1, %xmm3
divsd %xmm3, %xmm2
movsd 0x219eb(%rip), %xmm3    # 0x30488
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x9cf5
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xeb80
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xeb4c
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x32045(%rip), %rsi     # 0x40b80
leaq 0x3bd6(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xeb51
callq 0x3330
movq %rax, %rbx
jmp 0xeb61
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xeb70
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0xebb2
xorps %xmm1, %xmm1
callq 0x24295
jmp 0xebb4
xorl %eax, %eax
movzbl %al, %edi
leaq 0x23d2b(%rip), %rsi     # 0x328e9
movq %rbx, %rdx
callq 0x238ca
cvtsi2sd %r15, %xmm0
cvtsi2sd %r14, %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movapd %xmm0, %xmm2
divsd %xmm3, %xmm2
movsd 0x2189a(%rip), %xmm3    # 0x30488
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x9cf5
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0xecd1
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xec9d
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x31ef4(%rip), %rsi     # 0x40b80
leaq 0x3a85(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xeca2
callq 0x3330
movq %rax, %rbx
jmp 0xecb2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xecc1
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0xed1a
xorps %xmm1, %xmm1
callq 0x24279
testb %al, %al
je 0xed1a
movsd 0x214eb(%rip), %xmm1    # 0x301f8
movsd 0x8(%rsp), %xmm0
callq 0x24259
jmp 0xed1c
xorl %eax, %eax
movzbl %al, %edi
leaq 0x23be2(%rip), %rsi     # 0x32908
movq %rbx, %rdx
callq 0x238ca
cvtsi2sd %r15, %xmm0
movsd 0x2174d(%rip), %xmm2    # 0x30488
movsd %xmm0, 0x20(%rsp)
mulsd %xmm2, %xmm0
cvtsi2sd %r14, %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd %xmm2, %xmm1
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
callq 0x9cf5
movsd 0x8(%rsp), %xmm1
callq 0x24279
testb %al, %al
jne 0xed8e
movsd 0x22911(%rip), %xmm1    # 0x31690
movsd 0x8(%rsp), %xmm0
callq 0x24239
testb %al, %al
je 0xedbc
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %rbx, %rdi
callq 0xa961
movapd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm1
jmp 0xedf4
movsd 0x21434(%rip), %xmm2    # 0x301f8
subsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rdi
callq 0xa961
movsd 0x21412(%rip), %xmm2    # 0x301f8
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_O2/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 0x23772
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xeeca
leaq 0x10(%rsp), %rdi
callq 0x23631
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xee96
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x31cfb(%rip), %rsi     # 0x40b80
leaq 0x388c(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xee9b
callq 0x3330
movq %rax, %rbx
jmp 0xeeab
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xeeba
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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), %r14
movq %r14, %rdi
callq 0x23772
movq %r14, %rdi
callq 0x23631
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0xf4f4
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xf4c0
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x316d1(%rip), %rsi     # 0x40b80
leaq 0x3262(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xf4c5
callq 0x3330
movq %rax, %rbx
jmp 0xf4d5
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xf4e4
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %r14, %rdi
callq 0x28cea
movq %rax, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0xf61b
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xf5e7
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x315aa(%rip), %rsi     # 0x40b80
leaq 0x313b(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xf5ec
callq 0x3330
movq %rax, %rbx
jmp 0xf5fc
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xf60b
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %r14, %rdi
callq 0x28cf0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf715
leaq 0x8(%rsp), %rdi
callq 0x23631
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xf6e1
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x314b0(%rip), %rsi     # 0x40b80
leaq 0x3041(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xf6e6
callq 0x3330
movq %rax, %rbx
jmp 0xf6f6
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xf705
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x23b55
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23add
xorl %eax, %eax
cmpq %r14, %rax
jg 0xf753
movq 0x28(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0xf740
cvtsi2sd %r14, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20c92(%rip), %xmm0    # 0x303f8
movq %r15, %rdi
callq 0x2455f
mulsd 0x8(%rsp), %xmm0
movq %r15, %rdi
callq 0x24569
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
pushq $0x2
popq %rcx
movq %r14, %rax
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovgq %rax, %rcx
negq %rcx
pushq $0x1
popq %rax
movsd 0x21b40(%rip), %xmm0    # 0x312e8
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
je 0xf7eb
movq 0x28(%rbx), %rdx
cvtsi2sd %r14, %xmm1
mulsd (%rdx,%r14,8), %xmm1
leaq -0x1(%r14), %rsi
cvtsi2sd %rsi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, -0x10(%rdx,%r14,8)
incq %rax
addq $-0x2, %r14
jmp 0xf7a8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0xf8d1
leaq 0x10(%rsp), %rdi
callq 0x23631
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xf89d
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x312f4(%rip), %rsi     # 0x40b80
leaq 0x2e85(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xf8a2
callq 0x3330
movq %rax, %rbx
jmp 0xf8b2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xf8c1
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0xfe92
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xfe5e
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x30d33(%rip), %rsi     # 0x40b80
leaq 0x28c4(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xfe63
callq 0x3330
movq %rax, %rbx
jmp 0xfe73
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0xfe82
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 $0x38, %rsp
movsd 0x2035a(%rip), %xmm1    # 0x301f8
movapd %xmm1, %xmm2
movsd %xmm0, 0x20(%rsp)
subsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsp)
cmpq $0x1, %rdi
je 0xfebc
movapd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
cvtsi2sd %rdi, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x20523(%rip), %xmm0    # 0x303f8
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd 0x28(%rsp), %xmm1
callq 0x24259
testb %al, %al
je 0xff50
movsd 0x30(%rsp), %xmm0
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd 0x202fa(%rip), %xmm3    # 0x30200
addsd %xmm3, %xmm1
subsd 0x20(%rsp), %xmm1
movapd %xmm0, %xmm2
addsd %xmm3, %xmm2
movsd 0x10(%rsp), %xmm3
mulsd %xmm2, %xmm3
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
divsd %xmm0, %xmm1
addsd 0x202bc(%rip), %xmm0    # 0x301f8
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
jmp 0xfedb
movsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
callq 0x28cea
movq %rax, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x1001f
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0xffeb
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x30ba6(%rip), %rsi     # 0x40b80
leaq 0x2737(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0xfff0
callq 0x3330
movq %rax, %rbx
jmp 0x10000
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x1000f
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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:
movapd %xmm0, %xmm1
leaq (%rsi,%rsi), %rax
xorpd %xmm0, %xmm0
pushq $0x1
popq %rcx
movdqa 0x221fa(%rip), %xmm2    # 0x32230
movdqa 0x22202(%rip), %xmm3    # 0x32240
movdqa 0x21e7a(%rip), %xmm4    # 0x31ec0
movdqa 0x22202(%rip), %xmm5    # 0x32250
movapd 0x2220a(%rip), %xmm6    # 0x32260
testq %rsi, %rsi
js 0x100da
leaq (%rax,%rcx), %rdx
cvtsi2sd %rdx, %xmm7
subsd %xmm1, %xmm7
movq %rsi, %xmm8
pshufd $0x44, %xmm8, %xmm8     # xmm8 = xmm8[0,1,0,1]
paddq %xmm2, %xmm8
movdqa %xmm8, %xmm9
pand %xmm3, %xmm9
por %xmm4, %xmm9
psrlq $0x20, %xmm8
por %xmm5, %xmm8
subpd %xmm6, %xmm8
addpd %xmm9, %xmm8
movapd %xmm8, %xmm9
shufpd $0x1, %xmm7, %xmm9      # xmm9 = xmm9[1],xmm7[0]
mulpd %xmm0, %xmm9
divpd %xmm8, %xmm9
movapd %xmm9, %xmm7
unpckhpd %xmm9, %xmm7            # xmm7 = xmm7[1],xmm9[1]
subsd %xmm9, %xmm7
movq 0x28(%rdi), %rdx
addsd (%rdx,%rsi,8), %xmm7
decq %rsi
shufpd $0x1, %xmm7, %xmm0      # xmm0 = xmm0[1],xmm7[0]
addq $-0x2, %rcx
jmp 0x10056
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
callq 0x28cf0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10194
leaq 0x8(%rsp), %rdi
callq 0x23631
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x10160
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x30a31(%rip), %rsi     # 0x40b80
leaq 0x25c2(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x10165
callq 0x3330
movq %rax, %rbx
jmp 0x10175
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x10184
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0x23b55
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23add
movq 0x28(%rbx), %rcx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
xorl %eax, %eax
testq %r14, %r14
cmovgq %r14, %rax
movq %rdx, (%rcx)
negq %rax
pushq $0x1
popq %rcx
movapd 0x1ffcf(%rip), %xmm0    # 0x301b0
leaq (%rax,%rcx), %rdx
cmpq $0x1, %rdx
je 0x1021c
movq 0x28(%rbx), %rdx
movsd -0x8(%rdx,%rcx,8), %xmm1
xorpd %xmm0, %xmm1
cvtsi2sd %r14, %xmm2
mulsd %xmm1, %xmm2
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, (%rdx,%rcx,8)
incq %rcx
decq %r14
jmp 0x101e1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
callq 0x23631
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x102cf
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x1029b
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x308f6(%rip), %rsi     # 0x40b80
leaq 0x2487(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x102a0
callq 0x3330
movq %rax, %rbx
jmp 0x102b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x102bf
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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:
testq %rdi, %rdi
je 0x102e0
cmpq $0x1, %rdi
jne 0x102ed
movapd %xmm0, %xmm1
jmp 0x102e8
movsd 0x1ff10(%rip), %xmm1    # 0x301f8
movapd %xmm1, %xmm0
retq
pushq $0x2
popq %rax
movsd 0x1ff00(%rip), %xmm3    # 0x301f8
pushq $0x3
popq %rcx
movapd %xmm0, %xmm2
movapd %xmm3, %xmm1
cmpq %rdi, %rax
jg 0x102e8
cvtsi2sd %rcx, %xmm1
mulsd %xmm0, %xmm1
leaq -0x1(%rax), %rdx
cvtsi2sd %rdx, %xmm4
mulsd %xmm4, %xmm3
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
cvtsi2sd %rax, %xmm3
divsd %xmm3, %xmm1
addq $0x2, %rcx
incq %rax
movapd %xmm2, %xmm3
movapd %xmm1, %xmm2
jmp 0x10303
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %r14, %rdi
callq 0x28cea
movq %rax, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x10404
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x103d0
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x307c1(%rip), %rsi     # 0x40b80
leaq 0x2352(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x103d5
callq 0x3330
movq %rax, %rbx
jmp 0x103e5
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x103f4
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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:
movapd %xmm0, %xmm1
leaq (%rsi,%rsi), %rax
xorpd %xmm0, %xmm0
pushq $0x1
popq %rcx
movdqa 0x21e15(%rip), %xmm2    # 0x32230
movdqa 0x21e1d(%rip), %xmm3    # 0x32240
movdqa 0x21a95(%rip), %xmm4    # 0x31ec0
movdqa 0x21e1d(%rip), %xmm5    # 0x32250
movapd 0x21e25(%rip), %xmm6    # 0x32260
testq %rsi, %rsi
js 0x104bf
leaq (%rax,%rcx), %rdx
cvtsi2sd %rdx, %xmm7
mulsd %xmm1, %xmm7
movq %rsi, %xmm8
pshufd $0x44, %xmm8, %xmm8     # xmm8 = xmm8[0,1,0,1]
paddq %xmm2, %xmm8
movdqa %xmm8, %xmm9
pand %xmm3, %xmm9
por %xmm4, %xmm9
psrlq $0x20, %xmm8
por %xmm5, %xmm8
subpd %xmm6, %xmm8
addpd %xmm9, %xmm8
movapd %xmm8, %xmm9
shufpd $0x1, %xmm7, %xmm9      # xmm9 = xmm9[1],xmm7[0]
mulpd %xmm0, %xmm9
divpd %xmm8, %xmm9
movapd %xmm9, %xmm7
unpckhpd %xmm9, %xmm7            # xmm7 = xmm7[1],xmm9[1]
subsd %xmm9, %xmm7
movq 0x28(%rdi), %rdx
addsd (%rdx,%rsi,8), %xmm7
decq %rsi
shufpd $0x1, %xmm7, %xmm0      # xmm0 = xmm0[1],xmm7[0]
addq $-0x2, %rcx
jmp 0x1043b
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x23b55
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23add
xorl %eax, %eax
movq 0x28(%rbx), %rcx
cmpq %r14, %rax
jg 0x105b3
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x105a0
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
xorl %eax, %eax
testq %r14, %r14
cmovgq %r14, %rax
movq %rdx, (%rcx,%r14,8)
negq %rax
pushq $0x1
popq %rcx
movsd 0x1feb0(%rip), %xmm0    # 0x30488
leaq (%rax,%rcx), %rdx
cmpq $0x1, %rdx
je 0x1060d
movq 0x28(%rbx), %rdx
leaq (%r14,%rcx), %rsi
cvtsi2sd %rsi, %xmm1
mulsd (%rdx,%r14,8), %xmm1
cvtsi2sd %rcx, %xmm2
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rdx,%r14,8)
incq %rcx
jmp 0x105d8
pushq $0x2
popq %rcx
movq %r14, %rax
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovgq %rax, %rcx
negq %rcx
leaq -0x1(,%r14,2), %rax
pushq $0x1
popq %rdx
movsd 0x1fe71(%rip), %xmm0    # 0x304a8
leaq (%rcx,%rdx), %rsi
cmpq $0x1, %rsi
je 0x10687
movq 0x28(%rbx), %rsi
cvtsi2sd %r14, %xmm1
mulsd (%rsi,%r14,8), %xmm1
leaq -0x1(%r14), %rdi
cvtsi2sd %rdi, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvtsi2sd %rdx, %xmm1
divsd %xmm1, %xmm2
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, -0x10(%rsi,%r14,8)
incq %rdx
addq $-0x2, %r14
addq $-0x2, %rax
jmp 0x10637
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x10749
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x10715
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3047c(%rip), %rsi     # 0x40b80
leaq 0x200d(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x1071a
callq 0x3330
movq %rax, %rbx
jmp 0x1072a
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x10739
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x10853
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x1081f
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x30372(%rip), %rsi     # 0x40b80
leaq 0x1f03(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x10824
callq 0x3330
movq %rax, %rbx
jmp 0x10834
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x10843
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x1095d
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x10929
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x30268(%rip), %rsi     # 0x40b80
leaq 0x1df9(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x1092e
callq 0x3330
movq %rax, %rbx
jmp 0x1093e
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x1094d
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::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 0x10991
xorps %xmm1, %xmm1
callq 0x24295
testb %al, %al
je 0x10991
movsd 0x1f873(%rip), %xmm1    # 0x301f8
movsd (%rsp), %xmm0
callq 0x24239
jmp 0x10993
xorl %eax, %eax
movzbl %al, %edi
leaq 0x22031(%rip), %rsi     # 0x329ce
movq %rbx, %rdx
callq 0x238ca
incq %r14
cvtsi2sd %r14, %xmm0
movsd (%rsp), %xmm1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d6b
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x10df2
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x10dbe
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x2fdd3(%rip), %rsi     # 0x40b80
leaq 0x1964(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x10dc3
callq 0x3330
movq %rax, %rbx
jmp 0x10dd3
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x10de2
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::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 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x11177
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x11143
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x2fa4e(%rip), %rsi     # 0x40b80
leaq 0x15df(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x11148
callq 0x3330
movq %rax, %rbx
jmp 0x11158
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x11167
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d