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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rsi
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0xa8e0
movsd %xmm0, -0x80(%rbp)
jmp 0xa7f0
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0xa805
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xa877
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0xa85b
movq -0x90(%rbp), %rdi
leaq 0x5a30f(%rip), %rsi     # 0x64b78
leaq 0x12f40(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0xa8d8
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xa8d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0xa89a
jmp 0xa8c7
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0xa8c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::bessely0(double)
double bessely0(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::bessely0(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0xadd0
movsd %xmm0, -0x78(%rbp)
jmp 0xace2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0xacf7
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xad69
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0xad4d
movq -0x88(%rbp), %rdi
leaq 0x59e1d(%rip), %rsi     # 0x64b78
leaq 0x12a4e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0xadca
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xadca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0xad8c
jmp 0xadb9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0xadb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besselyn(long, double)
double besselyn(const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselyn(n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rsi
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0xb760
movsd %xmm0, -0x80(%rbp)
jmp 0xb670
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0xb685
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xb6f7
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0xb6db
movq -0x90(%rbp), %rdi
leaq 0x5948f(%rip), %rsi     # 0x64b78
leaq 0x120c0(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0xb758
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xb758
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0xb71a
jmp 0xb747
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0xb742
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::besselyn(long, double, alglib_impl::ae_state*)
double besselyn(ae_int_t n, double x, ae_state *_state)
{
    ae_int_t i;
    double a;
    double b;
    double tmp;
    double s;
    double result;


    s = 1;
    if( n<0 )
    {
        n = -n;
        if( n%2!=0 )
        {
            s = -1;
        }
    }
    if( n==0 )
    {
        result = bessely0(x, _state);
        return result;
    }
    if( n==1 )
    {
        result = s*bessely1(x, _state);
        return result;
    }
    a = bessely0(x, _state);
    b = bessely1(x, _state);
    for(i=1; i<=n-1; i++)
    {
        tmp = b;
        b = 2*i/x*b-a;
        a = tmp;
    }
    result = s*b;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movsd 0x4988b(%rip), %xmm0    # 0x55008
movsd %xmm0, -0x48(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0xb7b6
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0xb7b4
movsd 0x49a21(%rip), %xmm0    # 0x551d0
movsd %xmm0, -0x48(%rbp)
jmp 0xb7b6
cmpq $0x0, -0x10(%rbp)
jne 0xb7df
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0xadd0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xb8d7
cmpq $0x1, -0x10(%rbp)
jne 0xb81e
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0xb270
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xb8d7
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0xadd0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0xb270
movsd %xmm0, -0x38(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0xb8be
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
cvtsi2sd %rax, %xmm0
divsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb84c
movsd -0x48(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besseli0(double)
double besseli0(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besseli0(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0xba10
movsd %xmm0, -0x78(%rbp)
jmp 0xb922
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0xb937
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xb9a9
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0xb98d
movq -0x88(%rbp), %rdi
leaq 0x591dd(%rip), %rsi     # 0x64b78
leaq 0x11e0e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0xba0a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xba0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0xb9cc
jmp 0xb9f9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0xb9f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besseli1(double)
double besseli1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besseli1(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0xc3c0
movsd %xmm0, -0x78(%rbp)
jmp 0xc2d2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0xc2e7
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xc359
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0xc33d
movq -0x88(%rbp), %rdi
leaq 0x5882d(%rip), %rsi     # 0x64b78
leaq 0x1145e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0xc3ba
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xc3ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0xc37c
jmp 0xc3a9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0xc3a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besselk1(double)
double besselk1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselk1(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0xd4e0
movsd %xmm0, -0x78(%rbp)
jmp 0xd3f2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0xd407
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xd479
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0xd45d
movq -0x88(%rbp), %rdi
leaq 0x5770d(%rip), %rsi     # 0x64b78
leaq 0x1033e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0xd4da
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xd4da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0xd49c
jmp 0xd4c9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0xd4c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besselkn(long, double)
double besselkn(const ae_int_t nn, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselkn(nn, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rsi
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0xdc40
movsd %xmm0, -0x80(%rbp)
jmp 0xdb50
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0xdb65
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xdbd7
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0xdbbb
movq -0x90(%rbp), %rdi
leaq 0x56faf(%rip), %rsi     # 0x64b78
leaq 0xfbe0(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0xdc38
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xdc38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0xdbfa
jmp 0xdc27
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0xdc22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::beta(double, double)
double beta(const double a, const double b)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::beta(a, b, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0xe6e0
movsd %xmm0, -0x80(%rbp)
jmp 0xe5f2
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0xe607
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xe679
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0xe65d
movq -0x90(%rbp), %rdi
leaq 0x5650d(%rip), %rsi     # 0x64b78
leaq 0xf13e(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0xe6da
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xe6da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0xe69c
jmp 0xe6c9
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0xe6c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::incompletebeta(double, double, double)
double incompletebeta(const double a, const double b, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompletebeta(a, b, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
callq 0xeb20
movsd %xmm0, -0x88(%rbp)
jmp 0xea2f
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0xea47
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xeab9
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0xea9d
movq -0x98(%rbp), %rdi
leaq 0x560cd(%rip), %rsi     # 0x64b78
leaq 0xecfe(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0xeb1a
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xeb1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0xeadc
jmp 0xeb09
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0xeb04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invincompletebeta(double, double, double)
double invincompletebeta(const double a, const double b, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invincompletebeta(a, b, y, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
callq 0xf3a0
movsd %xmm0, -0x88(%rbp)
jmp 0xf2af
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0xf2c7
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xf339
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0xf31d
movq -0x98(%rbp), %rdi
leaq 0x5584d(%rip), %rsi     # 0x64b78
leaq 0xe47e(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0xf39a
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xf39a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0xf35c
jmp 0xf389
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0xf384
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::binomialdistribution(long, long, double)
double binomialdistribution(const ae_int_t k, const ae_int_t n, const double p)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::binomialdistribution(k, n, p, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x10580
movsd %xmm0, -0x88(%rbp)
jmp 0x1048b
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x104a3
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x10515
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x104f9
movq -0x98(%rbp), %rdi
leaq 0x54671(%rip), %rsi     # 0x64b78
leaq 0xd2a2(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x10576
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x10576
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0x10538
jmp 0x10565
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x10560
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::binomialdistribution(long, long, double, alglib_impl::ae_state*)
double binomialdistribution(ae_int_t k,
     ae_int_t n,
     double p,
     ae_state *_state)
{
    double dk;
    double dn;
    double result;


    ae_assert(ae_fp_greater_eq(p,0)&&ae_fp_less_eq(p,1), "Domain error in BinomialDistribution", _state);
    ae_assert(k>=-1&&k<=n, "Domain error in BinomialDistribution", _state);
    if( k==-1 )
    {
        result = 0;
        return result;
    }
    if( k==n )
    {
        result = 1;
        return result;
    }
    dn = n-k;
    if( k==0 )
    {
        dk = ae_pow(1.0-p, dn, _state);
    }
    else
    {
        dk = k+1;
        dk = incompletebeta(dn, dk, 1.0-p, _state);
    }
    result = dk;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x105b4
jmp 0x105c9
movsd -0x20(%rbp), %xmm0
movsd 0x44a47(%rip), %xmm1    # 0x55008
callq 0x3c480
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movq -0x28(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x46fc7(%rip), %rsi     # 0x575a4
callq 0x3b240
xorl %eax, %eax
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x42(%rbp)
jl 0x105fc
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setle %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
movq -0x28(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x46f94(%rip), %rsi     # 0x575a4
callq 0x3b240
cmpq $-0x1, -0x10(%rbp)
jne 0x10633
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x106df
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x10659
movsd 0x449c3(%rip), %xmm0    # 0x55008
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x106df
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10694
movsd 0x4498e(%rip), %xmm0    # 0x55008
subsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movq -0x28(%rbp), %rdi
callq 0x3cda0
movsd %xmm0, -0x30(%rbp)
jmp 0x106cb
movq -0x10(%rbp), %rax
addq $0x1, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd 0x44950(%rip), %xmm2    # 0x55008
subsd -0x20(%rbp), %xmm2
movq -0x28(%rbp), %rdi
callq 0xeb20
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::binomialcdistribution(long, long, double)
double binomialcdistribution(const ae_int_t k, const ae_int_t n, const double p)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::binomialcdistribution(k, n, p, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x10830
movsd %xmm0, -0x88(%rbp)
jmp 0x1073b
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x10753
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x107c5
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x107a9
movq -0x98(%rbp), %rdi
leaq 0x543c1(%rip), %rsi     # 0x64b78
leaq 0xcff2(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x10826
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x10826
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0x107e8
jmp 0x10815
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x10810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invbinomialdistribution(long, long, double)
double invbinomialdistribution(const ae_int_t k, const ae_int_t n, const double y)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invbinomialdistribution(k, n, y, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x10b60
movsd %xmm0, -0x88(%rbp)
jmp 0x10a6b
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x10a83
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x10af5
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x10ad9
movq -0x98(%rbp), %rdi
leaq 0x54091(%rip), %rsi     # 0x64b78
leaq 0xccc2(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x10b56
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x10b56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0x10b18
jmp 0x10b45
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x10b40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::invbinomialdistribution(long, long, double, alglib_impl::ae_state*)
double invbinomialdistribution(ae_int_t k,
     ae_int_t n,
     double y,
     ae_state *_state)
{
    double dk;
    double dn;
    double p;
    double result;


    ae_assert(k>=0&&k<n, "Domain error in InvBinomialDistribution", _state);
    dn = n-k;
    if( k==0 )
    {
        if( ae_fp_greater(y,0.8) )
        {
            p = -nuexpm1(nulog1p(y-1.0, _state)/dn, _state);
        }
        else
        {
            p = 1.0-ae_pow(y, 1.0/dn, _state);
        }
    }
    else
    {
        dk = k+1;
        p = incompletebeta(dn, dk, 0.5, _state);
        if( ae_fp_greater(p,0.5) )
        {
            p = invincompletebeta(dk, dn, 1.0-y, _state);
        }
        else
        {
            p = 1.0-invincompletebeta(dn, dk, y, _state);
        }
    }
    result = p;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x41(%rbp)
jl 0x10b93
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movq -0x20(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x46a48(%rip), %rsi     # 0x575ef
callq 0x3b240
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10c5b
movsd -0x18(%rbp), %xmm0
movsd 0x458ba(%rip), %xmm1    # 0x56490
callq 0x3c4c0
testb $0x1, %al
jne 0x10be1
jmp 0x10c27
movsd -0x18(%rbp), %xmm0
movsd 0x4441a(%rip), %xmm1    # 0x55008
subsd %xmm1, %xmm0
movq -0x20(%rbp), %rdi
callq 0x39080
divsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0x392f0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x10c56
movsd -0x18(%rbp), %xmm0
movsd 0x443d4(%rip), %xmm1    # 0x55008
divsd -0x30(%rbp), %xmm1
movq -0x20(%rbp), %rdi
callq 0x3cda0
movaps %xmm0, %xmm1
movsd 0x443bb(%rip), %xmm0    # 0x55008
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x10cfa
movq -0x8(%rbp), %rax
addq $0x1, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq -0x20(%rbp), %rdi
movsd 0x447cd(%rip), %xmm2    # 0x55450
callq 0xeb20
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x447b6(%rip), %xmm1    # 0x55450
callq 0x3c4c0
testb $0x1, %al
jne 0x10ca5
jmp 0x10ccc
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd 0x44351(%rip), %xmm2    # 0x55008
subsd -0x18(%rbp), %xmm2
movq -0x20(%rbp), %rdi
callq 0xf3a0
movsd %xmm0, -0x38(%rbp)
jmp 0x10cf8
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movq -0x20(%rbp), %rdi
callq 0xf3a0
movaps %xmm0, %xmm1
movsd 0x44319(%rip), %xmm0    # 0x55008
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x10cfa
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::chebyshevcalculate(long, long, double)
double chebyshevcalculate(const ae_int_t r, const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::chebyshevcalculate(r, n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x10e50
movsd %xmm0, -0x88(%rbp)
jmp 0x10d5b
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3ab70
jmp 0x10d73
movsd -0x70(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x10de5
movq -0x78(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
callq 0x42660
jmp 0x10dc9
movq -0x98(%rbp), %rdi
leaq 0x53da1(%rip), %rsi     # 0x64b78
leaq 0xc9d2(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x10e46
movq -0x78(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x10e46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
jmp 0x10e08
jmp 0x10e35
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x10e30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x3460
movq -0x78(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::chebyshevcalculate(long, long, double, alglib_impl::ae_state*)
double chebyshevcalculate(ae_int_t r,
     ae_int_t n,
     double x,
     ae_state *_state)
{
    ae_int_t i;
    double a;
    double b;
    double result;


    result = 0;
    
    /*
     * Prepare A and B
     */
    if( r==1 )
    {
        a = 1;
        b = x;
    }
    else
    {
        a = 1;
        b = 2*x;
    }
    
    /*
     * Special cases: N=0 or N=1
     */
    if( n==0 )
    {
        result = a;
        return result;
    }
    if( n==1 )
    {
        result = b;
        return result;
    }
    
    /*
     * General case: N>=2
     */
    for(i=2; i<=n; i++)
    {
        result = 2*x*b-a;
        a = b;
        b = result;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x10e8d
movsd 0x4418c(%rip), %xmm0    # 0x55008
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x10eac
movsd 0x44173(%rip), %xmm0    # 0x55008
movsd %xmm0, -0x38(%rbp)
movsd 0x44526(%rip), %xmm0    # 0x553c8
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10ecc
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x10f62
cmpq $0x1, -0x18(%rbp)
jne 0x10ee9
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x10f62
movq $0x2, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x10f58
movsd 0x444c5(%rip), %xmm0    # 0x553c8
mulsd -0x20(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x10ef1
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::chebyshevsum(alglib::real_1d_array const&, long, long, double)
double chebyshevsum(const real_1d_array &c, const ae_int_t r, const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::chebyshevsum(const_cast<alglib_impl::ae_vector*>(c.c_ptr()), r, n, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3ae90
movq -0x8(%rbp), %rdi
callq 0x474c0
movq %rax, -0x90(%rbp)
jmp 0x10fa7
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
leaq -0x70(%rbp), %rcx
callq 0x110d0
movsd %xmm0, -0x98(%rbp)
jmp 0x10fce
movsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3ab70
jmp 0x10fe6
movsd -0x78(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x11061
movq -0x80(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x88(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rsi
callq 0x42660
jmp 0x11045
movq -0xa0(%rbp), %rdi
leaq 0x53b25(%rip), %rsi     # 0x64b78
leaq 0xc756(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x110cb
movq -0x80(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x110cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x3460
jmp 0x11087
jmp 0x110ba
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x31e0
jmp 0x110b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x3460
movq -0x80(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::chebyshevsum(alglib_impl::ae_vector*, long, long, double, alglib_impl::ae_state*)
double chebyshevsum(/* Real    */ ae_vector* c,
     ae_int_t r,
     ae_int_t n,
     double x,
     ae_state *_state)
{
    double b1;
    double b2;
    ae_int_t i;
    double result;


    b1 = 0;
    b2 = 0;
    for(i=n; i>=1; i--)
    {
        result = 2*x*b1-b2+c->ptr.p_double[i];
        b2 = b1;
        b1 = result;
    }
    if( r==1 )
    {
        result = -b2+x*b1+c->ptr.p_double[0];
    }
    else
    {
        result = -b2+2*x*b1+c->ptr.p_double[0];
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x1, -0x40(%rbp)
jl 0x11176
movsd 0x442b8(%rip), %xmm0    # 0x553c8
mulsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x11101
cmpq $0x1, -0x10(%rbp)
jne 0x111be
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x11205
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x441e6(%rip), %xmm0    # 0x553c8
mulsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::chebyshevcoefficients(long, alglib::real_1d_array&)
void chebyshevcoefficients(const ae_int_t n, real_1d_array &c)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::chebyshevcoefficients(n, const_cast<alglib_impl::ae_vector*>(c.c_ptr()), &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ae90
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x474e0
movq %rax, -0x78(%rbp)
jmp 0x11243
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x11340
jmp 0x11256
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x11261
jmp 0x1131c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x112ca
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x112ae
movq -0x88(%rbp), %rdi
leaq 0x538bc(%rip), %rsi     # 0x64b78
leaq 0xc4ed(%rip), %rdx      # 0x1d7b0
callq 0x3490
jmp 0x11336
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x11336
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x112ed
jmp 0x11325
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x11315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x11325
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)