LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::hyperbolicsinecosineintegrals(double, double&, double&)
void hyperbolicsinecosineintegrals(const double x, double &shi, double &chi)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::hyperbolicsinecosineintegrals(x, &shi, &chi, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x24fa7
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1263f
leaq 0x10(%rsp), %rdi
callq 0x24e4e
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x1260b
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x30586(%rip), %rsi     # 0x42b80
leaq 0xcc1(%rip), %rdx       # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x12610
callq 0x3360
movq %rax, %rbx
jmp 0x12620
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x1262f
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::gammafunc_gammastirf(double, alglib_impl::ae_state*)
static double gammafunc_gammastirf(double x, ae_state *_state)
{
    double y;
    double w;
    double v;
    double stir;
    double result;


    w = 1/x;
    stir = 7.87311395793093628397E-4;
    stir = -2.29549961613378126380E-4+w*stir;
    stir = -2.68132617805781232825E-3+w*stir;
    stir = 3.47222221605458667310E-3+w*stir;
    stir = 8.33333333333482257126E-2+w*stir;
    w = 1+w*stir;
    y = ae_exp(x, _state);
    if( ae_fp_greater(x,143.01608) )
    {
        v = ae_pow(x, 0.5*x-0.25, _state);
        y = v*(v/y);
    }
    else
    {
        y = ae_pow(x, x-0.5, _state)/y;
    }
    result = 2.50662827463100050242*y*w;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, (%rsp)
callq 0x25f9b
movsd %xmm0, 0x8(%rsp)
movsd 0x21e36(%rip), %xmm1    # 0x34b10
movsd (%rsp), %xmm0
callq 0x25bf9
testb %al, %al
je 0x12d19
movsd 0x20798(%rip), %xmm1    # 0x33488
movsd (%rsp), %xmm0
mulsd %xmm0, %xmm1
addsd 0x215e7(%rip), %xmm1    # 0x342e8
movq %rbx, %rdi
callq 0x25f96
movapd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
jmp 0x12d38
movsd 0x20787(%rip), %xmm1    # 0x334a8
movsd (%rsp), %xmm0
addsd %xmm0, %xmm1
movq %rbx, %rdi
callq 0x25f96
divsd 0x8(%rsp), %xmm0
movsd 0x204a0(%rip), %xmm1    # 0x331e0
movapd %xmm1, %xmm2
divsd (%rsp), %xmm2
movsd 0x21dc7(%rip), %xmm3    # 0x34b18
mulsd %xmm2, %xmm3
addsd 0x21dc3(%rip), %xmm3    # 0x34b20
mulsd %xmm2, %xmm3
addsd 0x21dbf(%rip), %xmm3    # 0x34b28
mulsd %xmm2, %xmm3
addsd 0x21dbb(%rip), %xmm3    # 0x34b30
mulsd %xmm2, %xmm3
addsd 0x21db7(%rip), %xmm3    # 0x34b38
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
mulsd 0x20987(%rip), %xmm0    # 0x33718
mulsd %xmm3, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::taskgenint1dequidist(double, double, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void taskgenint1dequidist(double a,
     double b,
     ae_int_t n,
     /* Real    */ ae_vector* x,
     /* Real    */ ae_vector* y,
     ae_state *_state)
{
    ae_int_t i;
    double h;

    ae_vector_clear(x);
    ae_vector_clear(y);

    ae_assert(n>=1, "TaskGenInterpolationEqdist1D: N<1!", _state);
    ae_vector_set_length(x, n, _state);
    ae_vector_set_length(y, n, _state);
    if( n>1 )
    {
        x->ptr.p_double[0] = a;
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
        h = (b-a)/(n-1);
        for(i=1; i<=n-1; i++)
        {
            x->ptr.p_double[i] = a+i*h;
            y->ptr.p_double[i] = y->ptr.p_double[i-1]+(2*ae_randomreal(_state)-1)*h;
        }
    }
    else
    {
        x->ptr.p_double[0] = 0.5*(a+b);
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rdi
callq 0x253a5
movq %rbx, %rdi
callq 0x253a5
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x22733(%rip), %rsi     # 0x35c34
movq %r14, %rdx
callq 0x2510e
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25326
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25326
cmpq $0x2, %r12
jl 0x135e5
movq 0x28(%r15), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1fcb7(%rip), %xmm0    # 0x33208
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
leaq -0x1(%r12), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x8(%rsp), %xmm1
subsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movl $0x1, %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
movq 0x28(%rbx), %rax
movsd -0x8(%rax,%r13,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1fc43(%rip), %xmm0    # 0x33208
mulsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x13582
jmp 0x1361d
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
mulsd 0x1fe8f(%rip), %xmm0    # 0x33488
movq 0x28(%r15), %rax
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1fbf3(%rip), %xmm0    # 0x33208
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::taskgenint1dcheb1(double, double, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void taskgenint1dcheb1(double a,
     double b,
     ae_int_t n,
     /* Real    */ ae_vector* x,
     /* Real    */ ae_vector* y,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(x);
    ae_vector_clear(y);

    ae_assert(n>=1, "TaskGenInterpolation1DCheb1: N<1!", _state);
    ae_vector_set_length(x, n, _state);
    ae_vector_set_length(y, n, _state);
    if( n>1 )
    {
        for(i=0; i<=n-1; i++)
        {
            x->ptr.p_double[i] = 0.5*(b+a)+0.5*(b-a)*ae_cos(ae_pi*(2*i+1)/(2*n), _state);
            if( i==0 )
            {
                y->ptr.p_double[i] = 2*ae_randomreal(_state)-1;
            }
            else
            {
                y->ptr.p_double[i] = y->ptr.p_double[i-1]+(2*ae_randomreal(_state)-1)*(x->ptr.p_double[i]-x->ptr.p_double[i-1]);
            }
        }
    }
    else
    {
        x->ptr.p_double[0] = 0.5*(a+b);
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x253a5
movq %rbx, %rdi
callq 0x253a5
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x225e8(%rip), %rsi     # 0x35c57
movq %r14, %rdx
callq 0x2510e
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25326
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25326
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm0
movapd %xmm2, %xmm1
addsd %xmm0, %xmm1
cmpq $0x2, %r12
jl 0x1379a
subsd %xmm2, %xmm0
mulsd 0x1fdcc(%rip), %xmm0    # 0x33488
movsd %xmm0, 0x8(%rsp)
leaq (%r12,%r12), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x1, %r13d
mulsd 0x1fda6(%rip), %xmm1    # 0x33488
movsd %xmm1, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x1fd99(%rip), %xmm0    # 0x33490
divsd 0x18(%rsp), %xmm0
movq %r14, %rdi
callq 0x25f64
mulsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, -0x4(%rax,%r13,4)
cmpq $0x1, %r13
jne 0x1373f
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1fad3(%rip), %xmm0    # 0x33208
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x1378b
movq 0x28(%rbx), %rax
movsd -0xc(%rax,%r13,4), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1faa4(%rip), %xmm0    # 0x33208
movq 0x28(%r15), %rax
movsd -0x4(%rax,%r13,4), %xmm1
subsd -0xc(%rax,%r13,4), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%rsp), %xmm1
movq 0x28(%rbx), %rax
movsd %xmm1, -0x4(%rax,%r13,4)
addq $0x2, %r13
decq %r12
jne 0x136e7
jmp 0x137c6
mulsd 0x1fce6(%rip), %xmm1    # 0x33488
movq 0x28(%r15), %rax
movsd %xmm1, (%rax)
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1fa4a(%rip), %xmm0    # 0x33208
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::taskgenint1dcheb2(double, double, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void taskgenint1dcheb2(double a,
     double b,
     ae_int_t n,
     /* Real    */ ae_vector* x,
     /* Real    */ ae_vector* y,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(x);
    ae_vector_clear(y);

    ae_assert(n>=1, "TaskGenInterpolation1DCheb2: N<1!", _state);
    ae_vector_set_length(x, n, _state);
    ae_vector_set_length(y, n, _state);
    if( n>1 )
    {
        for(i=0; i<=n-1; i++)
        {
            x->ptr.p_double[i] = 0.5*(b+a)+0.5*(b-a)*ae_cos(ae_pi*i/(n-1), _state);
            if( i==0 )
            {
                y->ptr.p_double[i] = 2*ae_randomreal(_state)-1;
            }
            else
            {
                y->ptr.p_double[i] = y->ptr.p_double[i-1]+(2*ae_randomreal(_state)-1)*(x->ptr.p_double[i]-x->ptr.p_double[i-1]);
            }
        }
    }
    else
    {
        x->ptr.p_double[0] = 0.5*(a+b);
        y->ptr.p_double[0] = 2*ae_randomreal(_state)-1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdi
callq 0x253a5
movq %rbx, %rdi
callq 0x253a5
xorl %edi, %edi
testq %r12, %r12
setg %dil
leaq 0x22461(%rip), %rsi     # 0x35c79
movq %r14, %rdx
callq 0x2510e
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25326
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25326
cmpq $0x2, %r12
jl 0x1393c
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
movsd (%rsp), %xmm2
addsd %xmm2, %xmm0
subsd %xmm1, %xmm2
mulsd 0x1fc23(%rip), %xmm2    # 0x33488
movsd %xmm2, (%rsp)
leaq -0x1(%r12), %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x10(%rsp)
xorl %r13d, %r13d
mulsd 0x1fc00(%rip), %xmm0    # 0x33488
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x1fbf2(%rip), %xmm0    # 0x33490
divsd 0x10(%rsp), %xmm0
movq %r14, %rdi
callq 0x25f64
mulsd (%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movq 0x28(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
testq %r13, %r13
je 0x13912
movq 0x28(%rbx), %rax
movsd -0x8(%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1f91d(%rip), %xmm0    # 0x33208
movq 0x28(%r15), %rax
movsd (%rax,%r13,8), %xmm1
subsd -0x8(%rax,%r13,8), %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rsp), %xmm1
movq 0x28(%rbx), %rax
movsd %xmm1, (%rax,%r13,8)
jmp 0x1392e
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1f8e2(%rip), %xmm0    # 0x33208
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
incq %r13
cmpq %r13, %r12
jne 0x1388e
jmp 0x13973
movsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
mulsd 0x1fb39(%rip), %xmm0    # 0x33488
movq 0x28(%r15), %rax
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x25eea
addsd %xmm0, %xmm0
addsd 0x1f89d(%rip), %xmm0    # 0x33208
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::aredistinct(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool aredistinct(/* Real    */ ae_vector* x,
     ae_int_t n,
     ae_state *_state)
{
    double a;
    double b;
    ae_int_t i;
    ae_bool nonsorted;
    ae_bool result;


    ae_assert(n>=1, "APSERVAreDistinct: internal error (N<1)", _state);
    if( n==1 )
    {
        
        /*
         * everything is alright, it is up to caller to decide whether it
         * can interpolate something with just one point
         */
        result = ae_true;
        return result;
    }
    a = x->ptr.p_double[0];
    b = x->ptr.p_double[0];
    nonsorted = ae_false;
    for(i=1; i<=n-1; i++)
    {
        a = ae_minreal(a, x->ptr.p_double[i], _state);
        b = ae_maxreal(b, x->ptr.p_double[i], _state);
        nonsorted = nonsorted||ae_fp_greater_eq(x->ptr.p_double[i-1],x->ptr.p_double[i]);
    }
    ae_assert(!nonsorted, "APSERVAreDistinct: internal error (not sorted)", _state);
    for(i=1; i<=n-1; i++)
    {
        if( ae_fp_eq((x->ptr.p_double[i]-a)/(b-a)+1,(x->ptr.p_double[i-1]-a)/(b-a)+1) )
        {
            result = ae_false;
            return result;
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
testq %rsi, %rsi
setg %dil
leaq 0x222f5(%rip), %rsi     # 0x35c9b
callq 0x2510e
movb $0x1, %bpl
cmpq $0x1, %rbx
je 0x13ae4
jle 0x13ad0
movq 0x28(%r14), %rax
movsd (%rax), %xmm0
movl $0x1, %r12d
xorl %ebp, %ebp
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r14), %rax
movsd (%rax,%r12,8), %xmm1
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
callq 0x25ee1
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r14), %rax
movsd (%rax,%r12,8), %xmm1
movsd (%rsp), %xmm0
movq %r15, %rdi
callq 0x25edc
movsd %xmm0, (%rsp)
testb $0x1, %bpl
movb $0x1, %bpl
jne 0x13a34
movq 0x28(%r14), %rax
movsd -0x8(%rax,%r12,8), %xmm0
movsd (%rax,%r12,8), %xmm1
callq 0x25c15
movl %eax, %ebp
incq %r12
cmpq %r12, %rbx
jne 0x139d9
xorb $0x1, %bpl
movzbl %bpl, %edi
leaq 0x22278(%rip), %rsi     # 0x35cc3
movq %r15, %rdx
callq 0x2510e
movb $0x1, %bpl
cmpq $0x2, %rbx
jl 0x13ae4
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
addq $-0x2, %rbx
xorl %r15d, %r15d
movq 0x28(%r14), %rax
movsd (%rax,%r15,8), %xmm1
movsd 0x8(%rax,%r15,8), %xmm0
movsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm0
movsd (%rsp), %xmm2
divsd %xmm2, %xmm0
movsd 0x1f73d(%rip), %xmm4    # 0x331e0
addsd %xmm4, %xmm0
subsd %xmm3, %xmm1
divsd %xmm2, %xmm1
addsd %xmm4, %xmm1
callq 0x25b75
movl %eax, %ebp
testb %al, %al
jne 0x13aca
leaq 0x1(%r15), %rax
cmpq %r15, %rbx
movq %rax, %r15
jne 0x13a77
xorb $0x1, %bpl
jmp 0x13ae4
leaq 0x221ec(%rip), %rsi     # 0x35cc3
movl $0x1, %edi
movq %r15, %rdx
callq 0x2510e
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::rmatrixresize(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
void rmatrixresize(/* Real    */ ae_matrix* x,
     ae_int_t m,
     ae_int_t n,
     ae_state *_state)
{
    ae_frame _frame_block;
    ae_matrix oldx;
    ae_int_t i;
    ae_int_t j;
    ae_int_t m2;
    ae_int_t n2;

    ae_frame_make(_state, &_frame_block);
    ae_matrix_init(&oldx, 0, 0, DT_REAL, _state, ae_true);

    m2 = x->rows;
    n2 = x->cols;
    ae_swap_matrices(x, &oldx);
    ae_matrix_set_length(x, m, n, _state);
    for(i=0; i<=m-1; i++)
    {
        for(j=0; j<=n-1; j++)
        {
            if( i<m2&&j<n2 )
            {
                x->ptr.pp_double[i][j] = oldx.ptr.pp_double[i][j];
            }
            else
            {
                x->ptr.pp_double[i][j] = 0.0;
            }
        }
    }
    ae_frame_leave(_state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsp), %rsi
movq %rcx, %rdi
callq 0x25055
movq %rsp, %rdi
movl $0x3, %ecx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x2541c
movq (%r12), %rbp
movq 0x8(%r12), %r13
movq %r12, %rdi
movq %rsp, %rsi
callq 0x257f0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x256d1
testq %r15, %r15
jle 0x13bd2
xorl %eax, %eax
testq %r14, %r14
jle 0x13bca
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cmpq %rbp, %rax
jge 0x13bb4
cmpq %r13, %rcx
jge 0x13bb4
movq 0x38(%rsp), %rdx
movq (%rdx,%rax,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq 0x38(%r12), %rdx
movq (%rdx,%rax,8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x13b99
incq %rax
cmpq %r15, %rax
jne 0x13b92
movq %rbx, %rdi
callq 0x24ff2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::isfinitevector(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool isfinitevector(/* Real    */ ae_vector* x,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteVector: internal error (N<0)", _state);
    for(i=0; i<=n-1; i++)
    {
        if( !ae_isfinite(x->ptr.p_double[i], _state) )
        {
            result = ae_false;
            return result;
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x220e8(%rip), %rsi     # 0x35cf2
callq 0x2510e
testq %rbx, %rbx
jle 0x13c58
movq 0x28(%r15), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x25d2d
testb %al, %al
je 0x13c5c
movl $0x1, %ecx
movq %rcx, %r12
cmpq %rcx, %rbx
je 0x13c50
movq 0x28(%r15), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
callq 0x25d2d
leaq 0x1(%r12), %rcx
testb %al, %al
jne 0x13c2d
cmpq %rbx, %r12
setge %al
jmp 0x13c5e
movb $0x1, %al
jmp 0x13c5e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::isfinitecvector(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool isfinitecvector(/* Complex */ ae_vector* z,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteCVector: internal error (N<0)", _state);
    for(i=0; i<=n-1; i++)
    {
        if( !ae_isfinite(z->ptr.p_complex[i].x, _state)||!ae_isfinite(z->ptr.p_complex[i].y, _state) )
        {
            result = ae_false;
            return result;
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x2208f(%rip), %rsi     # 0x35d1d
callq 0x2510e
testq %r14, %r14
jle 0x13cf7
movq 0x28(%r15), %rax
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x13cfc
movl $0x1, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x28(%r15), %rax
movsd 0x8(%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x13cfe
cmpq %r14, %r12
setge %bpl
je 0x13cfe
movq 0x28(%r15), %rax
movsd 0x10(%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x25d2d
addq $0x10, %r13
incq %r12
testb %al, %al
jne 0x13cb7
jmp 0x13cfe
movb $0x1, %bpl
jmp 0x13cfe
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apservisfinitematrix(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool apservisfinitematrix(/* Real    */ ae_matrix* x,
     ae_int_t m,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteMatrix: internal error (N<0)", _state);
    ae_assert(m>=0, "APSERVIsFiniteMatrix: internal error (M<0)", _state);
    for(i=0; i<=m-1; i++)
    {
        for(j=0; j<=n-1; j++)
        {
            if( !ae_isfinite(x->ptr.pp_double[i][j], _state) )
            {
                result = ae_false;
                return result;
            }
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %edi, %edi
testq %rdx, %rdx
setns %dil
leaq 0x2200f(%rip), %rsi     # 0x35d49
movq %rcx, %rdx
callq 0x2510e
xorl %edi, %edi
testq %r15, %r15
setns %dil
leaq 0x22022(%rip), %rsi     # 0x35d74
movq %rbx, %rdx
callq 0x2510e
movq %r15, (%rsp)
testq %r15, %r15
jle 0x13da2
xorl %r13d, %r13d
xorl %ebp, %ebp
testq %r14, %r14
jle 0x13d93
xorl %r15d, %r15d
movq 0x38(%r12), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x13da5
incq %r15
cmpq %r15, %r14
jne 0x13d70
incq %rbp
cmpq (%rsp), %rbp
setge %r13b
jne 0x13d68
jmp 0x13da5
movb $0x1, %r13b
andb $0x1, %r13b
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apservisfinitecmatrix(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool apservisfinitecmatrix(/* Complex */ ae_matrix* x,
     ae_int_t m,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteCMatrix: internal error (N<0)", _state);
    ae_assert(m>=0, "APSERVIsFiniteCMatrix: internal error (M<0)", _state);
    for(i=0; i<=m-1; i++)
    {
        for(j=0; j<=n-1; j++)
        {
            if( !ae_isfinite(x->ptr.pp_complex[i][j].x, _state)||!ae_isfinite(x->ptr.pp_complex[i][j].y, _state) )
            {
                result = ae_false;
                return result;
            }
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %edi, %edi
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
setns %dil
leaq 0x21fb8(%rip), %rsi     # 0x35d9f
movq %rcx, %rdx
callq 0x2510e
xorl %edi, %edi
testq %r14, %r14
setns %dil
leaq 0x21fcc(%rip), %rsi     # 0x35dcb
movq %rbx, %rdx
callq 0x2510e
movq %r14, 0x10(%rsp)
testq %r14, %r14
jle 0x13e76
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq $0x0, 0x8(%rsp)
jle 0x13e66
xorl %r15d, %r15d
movq 0x8(%rsp), %r14
movq 0x38(%r12), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r15), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x13e79
movq 0x38(%r12), %rax
movq (%rax,%rbp,8), %rax
movsd 0x8(%rax,%r15), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x13e79
addq $0x10, %r15
decq %r14
jne 0x13e26
incq %rbp
cmpq 0x10(%rsp), %rbp
setge %r13b
jne 0x13e16
jmp 0x13e79
movb $0x1, %r13b
andb $0x1, %r13b
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::isfinitertrmatrix(alglib_impl::ae_matrix*, long, bool, alglib_impl::ae_state*)
ae_bool isfinitertrmatrix(/* Real    */ ae_matrix* x,
     ae_int_t n,
     ae_bool isupper,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j1;
    ae_int_t j2;
    ae_int_t j;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteRTRMatrix: internal error (N<0)", _state);
    for(i=0; i<=n-1; i++)
    {
        if( isupper )
        {
            j1 = i;
            j2 = n-1;
        }
        else
        {
            j1 = 0;
            j2 = i;
        }
        for(j=j1; j<=j2; j++)
        {
            if( !ae_isfinite(x->ptr.pp_double[i][j], _state) )
            {
                result = ae_false;
                return result;
            }
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, 0x4(%rsp)
movq %rsi, %r13
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x21f3d(%rip), %rsi     # 0x35df7
movq %rcx, %rdx
callq 0x2510e
testq %r13, %r13
jle 0x13f30
leaq -0x1(%r13), %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %r13, 0x8(%rsp)
cmpb $0x0, 0x4(%rsp)
movl $0x0, %r13d
cmovneq %r14, %r13
movq %r14, %rbp
cmovneq 0x10(%rsp), %rbp
cmpq %rbp, %r13
jg 0x13f1d
incq %rbp
movq 0x38(%r15), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x13f33
incq %r13
cmpq %r13, %rbp
jne 0x13efb
incq %r14
movq 0x8(%rsp), %r13
cmpq %r13, %r14
setge %r12b
jne 0x13edb
jmp 0x13f33
movb $0x1, %r12b
andb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apservisfinitectrmatrix(alglib_impl::ae_matrix*, long, bool, alglib_impl::ae_state*)
ae_bool apservisfinitectrmatrix(/* Complex */ ae_matrix* x,
     ae_int_t n,
     ae_bool isupper,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j1;
    ae_int_t j2;
    ae_int_t j;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteCTRMatrix: internal error (N<0)", _state);
    for(i=0; i<=n-1; i++)
    {
        if( isupper )
        {
            j1 = i;
            j2 = n-1;
        }
        else
        {
            j1 = 0;
            j2 = i;
        }
        for(j=j1; j<=j2; j++)
        {
            if( !ae_isfinite(x->ptr.pp_complex[i][j].x, _state)||!ae_isfinite(x->ptr.pp_complex[i][j].y, _state) )
            {
                result = ae_false;
                return result;
            }
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, 0x4(%rsp)
movq %rsi, %r13
movq %rdi, %r15
xorl %edi, %edi
testq %rsi, %rsi
setns %dil
leaq 0x21eb1(%rip), %rsi     # 0x35e25
movq %rcx, %rdx
callq 0x2510e
testq %r13, %r13
jle 0x14014
leaq -0x1(%r13), %rax
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %r13, 0x10(%rsp)
movq %rax, 0x8(%rsp)
cmpb $0x0, 0x4(%rsp)
movl $0x0, %r13d
cmovneq %r14, %r13
movq %r14, %rbp
cmovneq %rax, %rbp
cmpq %rbp, %r13
jg 0x13ffc
subq %r13, %rbp
incq %rbp
shlq $0x4, %r13
movq 0x38(%r15), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x14017
movq 0x38(%r15), %rax
movq (%rax,%r14,8), %rax
movsd 0x8(%rax,%r13), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
je 0x14017
addq $0x10, %r13
decq %rbp
jne 0x13fbe
incq %r14
movq 0x10(%rsp), %r13
cmpq %r13, %r14
setge %r12b
movq 0x8(%rsp), %rax
jne 0x13f99
jmp 0x14017
movb $0x1, %r12b
andb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apservisfiniteornanmatrix(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool apservisfiniteornanmatrix(/* Real    */ ae_matrix* x,
     ae_int_t m,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_bool result;


    ae_assert(n>=0, "APSERVIsFiniteOrNaNMatrix: internal error (N<0)", _state);
    ae_assert(m>=0, "APSERVIsFiniteOrNaNMatrix: internal error (M<0)", _state);
    for(i=0; i<=m-1; i++)
    {
        for(j=0; j<=n-1; j++)
        {
            if( !(ae_isfinite(x->ptr.pp_double[i][j], _state)||ae_isnan(x->ptr.pp_double[i][j], _state)) )
            {
                result = ae_false;
                return result;
            }
        }
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %edi, %edi
testq %rdx, %rdx
setns %dil
leaq 0x21dff(%rip), %rsi     # 0x35e53
movq %rcx, %rdx
callq 0x2510e
xorl %edi, %edi
testq %r15, %r15
setns %dil
leaq 0x21e17(%rip), %rsi     # 0x35e83
movq %rbx, %rdx
callq 0x2510e
movq %r15, (%rsp)
testq %r15, %r15
jle 0x140d7
xorl %r13d, %r13d
xorl %ebp, %ebp
testq %r14, %r14
jle 0x140c8
xorl %r15d, %r15d
movq 0x38(%r12), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x25d2d
testb %al, %al
jne 0x140c0
movq 0x38(%r12), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x25d4c
testb %al, %al
je 0x140da
incq %r15
cmpq %r15, %r14
jne 0x1408a
incq %rbp
cmpq (%rsp), %rbp
setge %r13b
jne 0x14082
jmp 0x140da
movb $0x1, %r13b
andb $0x1, %r13b
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::safepythag2(double, double, alglib_impl::ae_state*)
double safepythag2(double x, double y, ae_state *_state)
{
    double w;
    double xabs;
    double yabs;
    double z;
    double result;


    xabs = ae_fabs(x, _state);
    yabs = ae_fabs(y, _state);
    w = ae_maxreal(xabs, yabs, _state);
    z = ae_minreal(xabs, yabs, _state);
    if( ae_fp_eq(z,0) )
    {
        result = w;
    }
    else
    {
        result = w*ae_sqrt(1+ae_sqr(z/w, _state), _state);
    }
    return result;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd %xmm1, 0x8(%rsp)
callq 0x25e30
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e30
movaps %xmm0, %xmm1
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25edc
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rdi
callq 0x25ee1
xorpd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
callq 0x25b75
testb %al, %al
jne 0x1418f
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e43
addsd 0x1f069(%rip), %xmm0    # 0x331e0
movq %rbx, %rdi
callq 0x25e48
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::safepythag3(double, double, double, alglib_impl::ae_state*)
double safepythag3(double x, double y, double z, ae_state *_state)
{
    double w;
    double result;


    w = ae_maxreal(ae_fabs(x, _state), ae_maxreal(ae_fabs(y, _state), ae_fabs(z, _state), _state), _state);
    if( ae_fp_eq(w,0) )
    {
        result = 0;
        return result;
    }
    x = x/w;
    y = y/w;
    z = z/w;
    result = w*ae_sqrt(ae_sqr(x, _state)+ae_sqr(y, _state)+ae_sqr(z, _state), _state);
    return result;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x28(%rsp)
callq 0x25e30
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e30
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e30
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25edc
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25edc
xorpd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
callq 0x25b75
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x14296
movsd 0x28(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x18(%rsp), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
movq %rbx, %rdi
callq 0x25e43
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e43
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e43
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e48
mulsd 0x10(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::apperiodicmap(double*, double, double, double*, alglib_impl::ae_state*)
void apperiodicmap(double* x,
     double a,
     double b,
     double* k,
     ae_state *_state)
{

    *k = 0;

    ae_assert(ae_fp_less(a,b), "APPeriodicMap: internal error!", _state);
    *k = ae_ifloor((*x-a)/(b-a), _state);
    *x = *x-*k*(b-a);
    while(ae_fp_less(*x,a))
    {
        *x = *x+(b-a);
        *k = *k-1;
    }
    while(ae_fp_greater(*x,b))
    {
        *x = *x-(b-a);
        *k = *k+1;
    }
    *x = ae_maxreal(*x, a, _state);
    *x = ae_minreal(*x, b, _state);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq $0x0, (%rsi)
callq 0x25bb9
movzbl %al, %edi
leaq 0x219c8(%rip), %rsi     # 0x35eb3
movq %r14, %rdx
callq 0x2510e
movsd (%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
divsd %xmm2, %xmm0
movq %r14, %rdi
callq 0x25e8e
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd %xmm1, (%r15)
movsd (%rbx), %xmm0
mulsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movsd 0x8(%rsp), %xmm1
callq 0x25bb9
testb %al, %al
je 0x14591
movsd (%rbx), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
addsd 0x1eca2(%rip), %xmm0    # 0x33208
movsd %xmm0, (%r15)
movsd (%rbx), %xmm0
jmp 0x1453c
movsd (%rbx), %xmm0
subsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
addsd 0x1ec54(%rip), %xmm0    # 0x331e0
movsd %xmm0, (%r15)
movsd (%rbx), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x25bf9
testb %al, %al
jne 0x14571
movsd (%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
callq 0x25edc
movsd %xmm0, (%rbx)
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x25ee1
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::allocrealarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void allocrealarray(ae_serializer* s,
     /* Real    */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_alloc_entry(s);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_alloc_entry(s);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jns 0x146b4
movq (%rsi), %rbx
movq %r14, %rdi
callq 0x272f3
testq %rbx, %rbx
jle 0x146ce
movq %r14, %rdi
callq 0x272f3
decq %rbx
jne 0x146c1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::serializerealarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void serializerealarray(ae_serializer* s,
     /* Real    */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_serialize_int(s, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_serialize_double(s, v->ptr.p_double[i], _state);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
testq %rdx, %rdx
jns 0x146f3
movq (%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2749d
testq %r15, %r15
jle 0x14726
xorl %r13d, %r13d
movq 0x28(%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x27581
incq %r13
cmpq %r13, %r15
jne 0x14709
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::unserializerealarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void unserializerealarray(ae_serializer* s,
     /* Real    */ ae_vector* v,
     ae_state *_state)
{
    ae_int_t n;
    ae_int_t i;
    double t;

    ae_vector_clear(v);

    ae_serializer_unserialize_int(s, &n, _state);
    if( n==0 )
    {
        return;
    }
    ae_vector_set_length(v, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_unserialize_double(s, &t, _state);
        v->ptr.p_double[i] = t;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x253a5
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27680
movq (%r12), %rsi
testq %rsi, %rsi
je 0x147a9
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25326
cmpq $0x0, (%rsp)
jle 0x147a9
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2769f
movsd 0x8(%rsp), %xmm0
movq 0x28(%r14), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
cmpq (%rsp), %r13
jl 0x14782
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::allocintegerarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void allocintegerarray(ae_serializer* s,
     /* Integer */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_alloc_entry(s);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_alloc_entry(s);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jns 0x147c9
movq (%rsi), %rbx
movq %r14, %rdi
callq 0x272f3
testq %rbx, %rbx
jle 0x147e3
movq %r14, %rdi
callq 0x272f3
decq %rbx
jne 0x147d6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::serializeintegerarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void serializeintegerarray(ae_serializer* s,
     /* Integer */ ae_vector* v,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;


    if( n<0 )
    {
        n = v->cnt;
    }
    ae_serializer_serialize_int(s, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_serialize_int(s, v->ptr.p_int[i], _state);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
testq %rdx, %rdx
jns 0x14808
movq (%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2749d
testq %r15, %r15
jle 0x14839
xorl %r13d, %r13d
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x2749d
incq %r13
cmpq %r13, %r15
jne 0x1481e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::unserializeintegerarray(alglib_impl::ae_serializer*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void unserializeintegerarray(ae_serializer* s,
     /* Integer */ ae_vector* v,
     ae_state *_state)
{
    ae_int_t n;
    ae_int_t i;
    ae_int_t t;

    ae_vector_clear(v);

    ae_serializer_unserialize_int(s, &n, _state);
    if( n==0 )
    {
        return;
    }
    ae_vector_set_length(v, n, _state);
    for(i=0; i<=n-1; i++)
    {
        ae_serializer_unserialize_int(s, &t, _state);
        v->ptr.p_int[i] = t;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x253a5
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27680
movq (%r12), %rsi
testq %rsi, %rsi
je 0x148b9
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25326
cmpq $0x0, (%rsp)
jle 0x148b9
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27680
movq 0x8(%rsp), %rax
movq 0x28(%r14), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq (%rsp), %r13
jl 0x14895
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::allocrealmatrix(alglib_impl::ae_serializer*, alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
void allocrealmatrix(ae_serializer* s,
     /* Real    */ ae_matrix* v,
     ae_int_t n0,
     ae_int_t n1,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;


    if( n0<0 )
    {
        n0 = v->rows;
    }
    if( n1<0 )
    {
        n1 = v->cols;
    }
    ae_serializer_alloc_entry(s);
    ae_serializer_alloc_entry(s);
    for(i=0; i<=n0-1; i++)
    {
        for(j=0; j<=n1-1; j++)
        {
            ae_serializer_alloc_entry(s);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rdx, %rdx
jns 0x148e1
movq (%rsi), %r14
testq %rbx, %rbx
jns 0x148ea
movq 0x8(%rsi), %rbx
movq %r15, %rdi
callq 0x272f3
movq %r15, %rdi
callq 0x272f3
testq %r14, %r14
jle 0x1491f
xorl %r12d, %r12d
testq %rbx, %rbx
jle 0x14917
movq %rbx, %r13
movq %r15, %rdi
callq 0x272f3
decq %r13
jne 0x1490a
incq %r12
cmpq %r14, %r12
jne 0x14902
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::serializerealmatrix(alglib_impl::ae_serializer*, alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
void serializerealmatrix(ae_serializer* s,
     /* Real    */ ae_matrix* v,
     ae_int_t n0,
     ae_int_t n1,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;


    if( n0<0 )
    {
        n0 = v->rows;
    }
    if( n1<0 )
    {
        n1 = v->cols;
    }
    ae_serializer_serialize_int(s, n0, _state);
    ae_serializer_serialize_int(s, n1, _state);
    for(i=0; i<=n0-1; i++)
    {
        for(j=0; j<=n1-1; j++)
        {
            ae_serializer_serialize_double(s, v->ptr.pp_double[i][j], _state);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, (%rsp)
testq %rdx, %rdx
jns 0x14950
movq (%r15), %rax
movq %rax, (%rsp)
testq %r14, %r14
jns 0x14959
movq 0x8(%r15), %r14
movq %r13, %rdi
movq (%rsp), %r12
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2749d
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2749d
testq %r12, %r12
jle 0x149b2
xorl %ebp, %ebp
testq %r14, %r14
jle 0x149a9
xorl %r12d, %r12d
movq 0x38(%r15), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x27581
incq %r12
cmpq %r12, %r14
jne 0x14988
incq %rbp
cmpq (%rsp), %rbp
jne 0x14980
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::unserializerealmatrix(alglib_impl::ae_serializer*, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
void unserializerealmatrix(ae_serializer* s,
     /* Real    */ ae_matrix* v,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_int_t n0;
    ae_int_t n1;
    double t;

    ae_matrix_clear(v);

    ae_serializer_unserialize_int(s, &n0, _state);
    ae_serializer_unserialize_int(s, &n1, _state);
    if( n0==0||n1==0 )
    {
        return;
    }
    ae_matrix_set_length(v, n0, n1, _state);
    for(i=0; i<=n0-1; i++)
    {
        for(j=0; j<=n1-1; j++)
        {
            ae_serializer_unserialize_double(s, &t, _state);
            v->ptr.pp_double[i][j] = t;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x257b9
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27680
movq %rsp, %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x27680
movq (%r12), %rsi
testq %rsi, %rsi
sete %al
movq (%r13), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x14a7e
movq %r14, %rdi
movq %rbx, %rcx
callq 0x256d1
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
jle 0x14a7e
movq (%rsp), %rax
xorl %r13d, %r13d
leaq 0x10(%rsp), %r12
testq %rax, %rax
jle 0x14a76
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2769f
movsd 0x10(%rsp), %xmm0
movq 0x38(%r14), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movq (%rsp), %rax
cmpq %rax, %rbp
jl 0x14a44
movq 0x8(%rsp), %rcx
incq %r13
cmpq %rcx, %r13
jl 0x14a3d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copyintegerarray(alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void copyintegerarray(/* Integer */ ae_vector* src,
     /* Integer */ ae_vector* dst,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(dst);

    if( src->cnt>0 )
    {
        ae_vector_set_length(dst, src->cnt, _state);
        for(i=0; i<=src->cnt-1; i++)
        {
            dst->ptr.p_int[i] = src->ptr.p_int[i];
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x253a5
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x14ad6
movq %rbx, %rdi
movq %r15, %rdx
callq 0x25326
cmpq $0x0, (%r14)
jle 0x14ad6
xorl %eax, %eax
movq 0x28(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x28(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq (%r14), %rax
jl 0x14abe
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copyrealarray(alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void copyrealarray(/* Real    */ ae_vector* src,
     /* Real    */ ae_vector* dst,
     ae_state *_state)
{
    ae_int_t i;

    ae_vector_clear(dst);

    if( src->cnt>0 )
    {
        ae_vector_set_length(dst, src->cnt, _state);
        for(i=0; i<=src->cnt-1; i++)
        {
            dst->ptr.p_double[i] = src->ptr.p_double[i];
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x253a5
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x14b29
movq %rbx, %rdi
movq %r15, %rdx
callq 0x25326
movq (%r14), %rax
testq %rax, %rax
jle 0x14b29
xorl %ecx, %ecx
movq 0x28(%r14), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq 0x28(%rbx), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x14b0f
popq %rbx
popq %r14
popq %r15
retq