LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasegeneratecomplexfftplan(long, alglib_impl::ftplan*, alglib_impl::ae_state*)
void ftbasegeneratecomplexfftplan(ae_int_t n,
     ftplan* plan,
     ae_state *_state)
{
    ae_int_t planarraysize;
    ae_int_t plansize;
    ae_int_t precomputedsize;
    ae_int_t tmpmemsize;
    ae_int_t stackmemsize;
    ae_int_t stackptr;

    _ftplan_clear(plan);

    planarraysize = 1;
    plansize = 0;
    precomputedsize = 0;
    stackmemsize = 0;
    stackptr = 0;
    tmpmemsize = 2*n;
    ae_vector_set_length(&plan->plan, planarraysize, _state);
    ftbase_ftbasegenerateplanrec(n, ftbase_ftbasecffttask, plan, &plansize, &precomputedsize, &planarraysize, &tmpmemsize, &stackmemsize, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateComplexFFTPlan: stack ptr!", _state);
    ae_vector_set_length(&plan->stackbuf, ae_maxint(stackmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->tmpbuf, ae_maxint(tmpmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->precomputed, ae_maxint(precomputedsize, 1, _state), _state);
    stackptr = 0;
    ftbase_ftbaseprecomputeplanrec(plan, 0, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateComplexFFTPlan: stack ptr!", _state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x21d9c
leaq 0x10(%rsp), %rax
movq $0x1, (%rax)
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
movq %r13, (%rbp)
leaq 0x18(%rsp), %r15
movq %r13, (%r15)
movq %rsp, %rax
movq %r13, (%rax)
leaq (%r12,%r12), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25326
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbp, %rcx
movq %r15, %r8
leaq 0x10(%rsp), %r9
pushq %rbx
pushq %r13
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x20(%rsp), %rax
pushq %rax
callq 0x21dc7
addq $0x20, %rsp
leaq 0x1440f(%rip), %r12     # 0x360fe
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
leaq 0x90(%r14), %r13
movq %rsp, %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x25ec6
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25326
leaq 0x60(%r14), %r13
leaq 0x8(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x25ec6
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25326
leaq 0x30(%r14), %r13
movq (%r15), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x25ec6
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25326
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x22426
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
addq $0x28, %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::_ftplan_clear(alglib_impl::ftplan*)
void _ftplan_clear(ftplan* p)
{
    ae_vector_clear(&p->plan);
    ae_vector_clear(&p->precomputed);
    ae_vector_clear(&p->tmpbuf);
    ae_vector_clear(&p->stackbuf);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x253a5
leaq 0x30(%rbx), %rdi
callq 0x253a5
leaq 0x60(%rbx), %rdi
callq 0x253a5
addq $0x90, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x253a5
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasegeneraterealfhtplan(long, alglib_impl::ftplan*, alglib_impl::ae_state*)
void ftbasegeneraterealfhtplan(ae_int_t n, ftplan* plan, ae_state *_state)
{
    ae_int_t planarraysize;
    ae_int_t plansize;
    ae_int_t precomputedsize;
    ae_int_t tmpmemsize;
    ae_int_t stackmemsize;
    ae_int_t stackptr;

    _ftplan_clear(plan);

    planarraysize = 1;
    plansize = 0;
    precomputedsize = 0;
    stackmemsize = 0;
    stackptr = 0;
    tmpmemsize = n;
    ae_vector_set_length(&plan->plan, planarraysize, _state);
    ftbase_ftbasegenerateplanrec(n, ftbase_ftbaserfhttask, plan, &plansize, &precomputedsize, &planarraysize, &tmpmemsize, &stackmemsize, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateRealFHTPlan: stack ptr!", _state);
    ae_vector_set_length(&plan->stackbuf, ae_maxint(stackmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->tmpbuf, ae_maxint(tmpmemsize, 1, _state), _state);
    ae_vector_set_length(&plan->precomputed, ae_maxint(precomputedsize, 1, _state), _state);
    stackptr = 0;
    ftbase_ftbaseprecomputeplanrec(plan, 0, stackptr, _state);
    ae_assert(stackptr==0, "Internal error in FTBaseGenerateRealFHTPlan: stack ptr!", _state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x21d9c
leaq 0x10(%rsp), %rax
movq $0x1, (%rax)
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
movq %r13, (%rbp)
leaq 0x18(%rsp), %r15
movq %r13, (%r15)
movq %rsp, %rax
movq %r13, (%rax)
leaq 0x8(%rsp), %rax
movq %r12, (%rax)
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25326
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %rbp, %rcx
movq %r15, %r8
leaq 0x10(%rsp), %r9
pushq %rbx
pushq %r13
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x20(%rsp), %rax
pushq %rax
callq 0x21dc7
addq $0x20, %rsp
leaq 0x1379d(%rip), %r12     # 0x36171
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
leaq 0x90(%r14), %r13
movq %rsp, %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x25ec6
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25326
leaq 0x60(%r14), %r13
leaq 0x8(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x25ec6
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25326
leaq 0x30(%r14), %r13
movq (%r15), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x25ec6
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x25326
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x22426
movl $0x1, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2510e
addq $0x28, %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::ftbaseissmooth(long, alglib_impl::ae_state*)
ae_bool ftbaseissmooth(ae_int_t n, ae_state *_state)
{
    ae_int_t i;
    ae_bool result;


    for(i=2; i<=ftbase_ftbasemaxsmoothfactor; i++)
    {
        while(n%i==0)
        {
            n = n/i;
        }
    }
    result = n==1;
    return result;
}

// Assembly:
movl $0x2, %ecx
movq %rdi, %rax
cqto
idivq %rcx
testq %rdx, %rdx
jne 0x2430e
movq %rdi, %rax
cqto
idivq %rcx
movq %rax, %rdi
jmp 0x242f7
incq %rcx
cmpq $0x6, %rcx
jne 0x242f4
cmpq $0x1, %rdi
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbasefindsmooth(long, alglib_impl::ae_state*)
ae_int_t ftbasefindsmooth(ae_int_t n, ae_state *_state)
{
    ae_int_t best;
    ae_int_t result;


    best = 2;
    while(best<n)
    {
        best = 2*best;
    }
    ftbase_ftbasefindsmoothrec(n, 1, 2, &best, _state);
    result = best;
    return result;
}

// Assembly:
movq %rsi, %r8
movl $0x2, %ecx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rdi, %rax
jl 0x24327
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x2435a
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbase_ftbasefindsmoothrec(long, long, long, long*, alglib_impl::ae_state*)
static void ftbase_ftbasefindsmoothrec(ae_int_t n,
     ae_int_t seed,
     ae_int_t leastfactor,
     ae_int_t* best,
     ae_state *_state)
{


    ae_assert(ftbase_ftbasemaxsmoothfactor<=5, "FTBaseFindSmoothRec: internal error!", _state);
    if( seed>=n )
    {
        *best = ae_minint(*best, seed, _state);
        return;
    }
    if( leastfactor<=2 )
    {
        ftbase_ftbasefindsmoothrec(n, seed*2, 2, best, _state);
    }
    if( leastfactor<=3 )
    {
        ftbase_ftbasefindsmoothrec(n, seed*3, 3, best, _state);
    }
    if( leastfactor<=5 )
    {
        ftbase_ftbasefindsmoothrec(n, seed*5, 5, best, _state);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x11e55(%rip), %rsi     # 0x361d0
movl $0x1, %edi
movq %r8, %rdx
callq 0x2510e
cmpq %r12, %r15
jge 0x243ee
leaq 0x11e3c(%rip), %r13     # 0x361d0
cmpq $0x2, %rbp
jg 0x243b3
leaq (%r15,%r15), %rsi
movl $0x2, %edx
movq %r12, %rdi
movq %rbx, %rcx
movq %r14, %r8
callq 0x2435a
jmp 0x243b9
cmpq $0x3, %rbp
jne 0x243d0
leaq (%r15,%r15,2), %rsi
movl $0x3, %edx
movq %r12, %rdi
movq %rbx, %rcx
movq %r14, %r8
callq 0x2435a
leaq (%r15,%r15,4), %r15
movl $0x1, %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2510e
movl $0x5, %ebp
cmpq %r12, %r15
jl 0x24394
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x25ed1
movq %rax, (%rbx)
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::ftbasefindsmootheven(long, alglib_impl::ae_state*)
ae_int_t ftbasefindsmootheven(ae_int_t n, ae_state *_state)
{
    ae_int_t best;
    ae_int_t result;


    best = 2;
    while(best<n)
    {
        best = 2*best;
    }
    ftbase_ftbasefindsmoothrec(n, 2, 2, &best, _state);
    result = best;
    return result;
}

// Assembly:
movq %rsi, %r8
movl $0x2, %ecx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rdi, %rax
jl 0x24416
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x2, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x2435a
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_ftplan_init(alglib_impl::ftplan*, alglib_impl::ae_state*, bool)
ae_bool _ftplan_init(ftplan* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->plan, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->precomputed, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->tmpbuf, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->stackbuf, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x251ec
testb %al, %al
je 0x2453e
leaq 0x30(%r14), %rdi
movzbl %bpl, %ebp
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x251ec
testb %al, %al
je 0x2453e
leaq 0x60(%r14), %rdi
movl $0x3, %edx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x251ec
testb %al, %al
je 0x2453e
addq $0x90, %r14
movl $0x3, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x251ec
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_ftplan_init_copy(alglib_impl::ftplan*, alglib_impl::ftplan*, alglib_impl::ae_state*, bool)
ae_bool _ftplan_init_copy(ftplan* dst, ftplan* src, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init_copy(&dst->plan, &src->plan, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->precomputed, &src->precomputed, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->tmpbuf, &src->tmpbuf, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->stackbuf, &src->stackbuf, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x25262
testb %al, %al
je 0x245b5
leaq 0x30(%r15), %rdi
leaq 0x30(%r14), %rsi
movzbl %bpl, %ebp
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x25262
testb %al, %al
je 0x245b5
leaq 0x60(%r15), %rdi
leaq 0x60(%r14), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x25262
testb %al, %al
je 0x245b5
movl $0x90, %eax
addq %rax, %r15
addq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25262
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
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::nulog1p(double, alglib_impl::ae_state*)
double nulog1p(double x, ae_state *_state)
{
    double z;
    double lp;
    double lq;
    double result;


    z = 1.0+x;
    if( ae_fp_less(z,0.70710678118654752440)||ae_fp_greater(z,1.41421356237309504880) )
    {
        result = ae_log(z, _state);
        return result;
    }
    z = x*x;
    lp = 4.5270000862445199635215E-5;
    lp = lp*x+4.9854102823193375972212E-1;
    lp = lp*x+6.5787325942061044846969E0;
    lp = lp*x+2.9911919328553073277375E1;
    lp = lp*x+6.0949667980987787057556E1;
    lp = lp*x+5.7112963590585538103336E1;
    lp = lp*x+2.0039553499201281259648E1;
    lq = 1.0000000000000000000000E0;
    lq = lq*x+1.5062909083469192043167E1;
    lq = lq*x+8.3047565967967209469434E1;
    lq = lq*x+2.2176239823732856465394E2;
    lq = lq*x+3.0909872225312059774938E2;
    lq = lq*x+2.1642788614495947685003E2;
    lq = lq*x+6.0118660497603843919306E1;
    z = -0.5*z+x*(z*lp/lq);
    result = x+z;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xec0e(%rip), %xmm2     # 0x331e0
movsd %xmm0, 0x8(%rsp)
addsd %xmm0, %xmm2
movsd 0x11524(%rip), %xmm1    # 0x35b08
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
callq 0x25bb9
testb %al, %al
jne 0x2460c
movsd 0xf052(%rip), %xmm1     # 0x33650
movsd (%rsp), %xmm0
callq 0x25bf9
testb %al, %al
je 0x2461e
movsd (%rsp), %xmm0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x25f91
movsd 0x114ea(%rip), %xmm1    # 0x35b10
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm1
addsd 0x114e0(%rip), %xmm1    # 0x35b18
mulsd %xmm3, %xmm1
addsd 0x114dc(%rip), %xmm1    # 0x35b20
mulsd %xmm3, %xmm1
addsd 0x114d8(%rip), %xmm1    # 0x35b28
mulsd %xmm3, %xmm1
addsd 0x114d4(%rip), %xmm1    # 0x35b30
mulsd %xmm3, %xmm1
addsd 0x114d0(%rip), %xmm1    # 0x35b38
mulsd %xmm3, %xmm1
addsd 0x114cc(%rip), %xmm1    # 0x35b40
movsd 0x114cc(%rip), %xmm2    # 0x35b48
addsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
addsd 0x114c4(%rip), %xmm2    # 0x35b50
mulsd %xmm3, %xmm2
addsd 0x114c0(%rip), %xmm2    # 0x35b58
mulsd %xmm3, %xmm2
addsd 0x114bc(%rip), %xmm2    # 0x35b60
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm2
addsd 0x114b4(%rip), %xmm2    # 0x35b68
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm2
addsd 0x114ac(%rip), %xmm2    # 0x35b70
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
mulsd 0xedd4(%rip), %xmm0     # 0x334a8
mulsd %xmm3, %xmm1
addsd %xmm1, %xmm0
addsd %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::nuexpm1(double, alglib_impl::ae_state*)
double nuexpm1(double x, ae_state *_state)
{
    double r;
    double xx;
    double ep;
    double eq;
    double result;


    if( ae_fp_less(x,-0.5)||ae_fp_greater(x,0.5) )
    {
        result = ae_exp(x, _state)-1.0;
        return result;
    }
    xx = x*x;
    ep = 1.2617719307481059087798E-4;
    ep = ep*xx+3.0299440770744196129956E-2;
    ep = ep*xx+9.9999999999999999991025E-1;
    eq = 3.0019850513866445504159E-6;
    eq = eq*xx+2.5244834034968410419224E-3;
    eq = eq*xx+2.2726554820815502876593E-1;
    eq = eq*xx+2.0000000000000000000897E0;
    r = x*ep;
    r = r/(eq-r);
    result = r+r;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xedb2(%rip), %xmm1     # 0x334a8
movsd %xmm0, 0x8(%rsp)
callq 0x25bb9
testb %al, %al
jne 0x2471c
movsd 0xed7b(%rip), %xmm1     # 0x33488
movsd 0x8(%rsp), %xmm0
callq 0x25bf9
testb %al, %al
je 0x24734
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25f9b
addsd 0xead6(%rip), %xmm0     # 0x33208
jmp 0x2479e
movsd 0x8(%rsp), %xmm3
movapd %xmm3, %xmm1
mulsd %xmm3, %xmm1
movsd 0x1142e(%rip), %xmm0    # 0x35b78
mulsd %xmm1, %xmm0
addsd 0x1142a(%rip), %xmm0    # 0x35b80
mulsd %xmm1, %xmm0
addsd 0xea7e(%rip), %xmm0     # 0x331e0
movsd 0x1141e(%rip), %xmm2    # 0x35b88
mulsd %xmm1, %xmm2
addsd 0x1141a(%rip), %xmm2    # 0x35b90
mulsd %xmm1, %xmm2
addsd 0x11416(%rip), %xmm2    # 0x35b98
mulsd %xmm1, %xmm2
addsd 0xec72(%rip), %xmm2     # 0x33400
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm2
divsd %xmm2, %xmm0
addsd %xmm0, %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::nucosm1(double, alglib_impl::ae_state*)
double nucosm1(double x, ae_state *_state)
{
    double xx;
    double c;
    double result;


    if( ae_fp_less(x,-0.25*ae_pi)||ae_fp_greater(x,0.25*ae_pi) )
    {
        result = ae_cos(x, _state)-1;
        return result;
    }
    xx = x*x;
    c = 4.7377507964246204691685E-14;
    c = c*xx-1.1470284843425359765671E-11;
    c = c*xx+2.0876754287081521758361E-9;
    c = c*xx-2.7557319214999787979814E-7;
    c = c*xx+2.4801587301570552304991E-5;
    c = c*xx-1.3888888888888872993737E-3;
    c = c*xx+4.1666666666666666609054E-2;
    result = -0.5*xx+xx*xx*c;
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xf38c(%rip), %xmm1     # 0x33b40
movsd %xmm0, 0x8(%rsp)
callq 0x25bb9
testb %al, %al
jne 0x247da
movsd 0xf21d(%rip), %xmm1     # 0x339e8
movsd 0x8(%rsp), %xmm0
callq 0x25bf9
testb %al, %al
je 0x247f2
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25f64
addsd 0xea18(%rip), %xmm0     # 0x33208
jmp 0x24864
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x1139c(%rip), %xmm2    # 0x35ba0
mulsd %xmm0, %xmm2
addsd 0x11398(%rip), %xmm2    # 0x35ba8
mulsd %xmm0, %xmm2
addsd 0x11394(%rip), %xmm2    # 0x35bb0
mulsd %xmm0, %xmm2
addsd 0x11390(%rip), %xmm2    # 0x35bb8
mulsd %xmm0, %xmm2
addsd 0x1138c(%rip), %xmm2    # 0x35bc0
mulsd %xmm0, %xmm2
addsd 0x11388(%rip), %xmm2    # 0x35bc8
mulsd %xmm0, %xmm2
addsd 0x11384(%rip), %xmm2    # 0x35bd0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
mulsd 0xec48(%rip), %xmm0     # 0x334a8
addsd %xmm1, %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::xblas_xfastpow(double, long, alglib_impl::ae_state*)
static double xblas_xfastpow(double r, ae_int_t n, ae_state *_state)
{
    double result;


    result = 0;
    if( n>0 )
    {
        if( n%2==0 )
        {
            result = ae_sqr(xblas_xfastpow(r, n/2, _state), _state);
        }
        else
        {
            result = r*xblas_xfastpow(r, n-1, _state);
        }
        return result;
    }
    if( n==0 )
    {
        result = 1;
    }
    if( n<0 )
    {
        result = xblas_xfastpow(1/r, -n, _state);
    }
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
jle 0x248ae
testb $0x1, %dil
jne 0x24895
shrq %rdi
movq %rbx, %rsi
callq 0x2486a
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x25e43
decq %rdi
movq %rbx, %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x2486a
mulsd 0x8(%rsp), %xmm0
jmp 0x248b8
js 0x248be
movsd 0xe928(%rip), %xmm0     # 0x331e0
addq $0x10, %rsp
popq %rbx
retq
negq %rdi
movsd 0xe917(%rip), %xmm1     # 0x331e0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x24877
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_break(alglib_impl::ae_state*, alglib_impl::ae_error_type, char const*)
void ae_break(ae_state *state, ae_error_type error_type, const char *msg)
{
#ifndef AE_USE_CPP_ERROR_HANDLING
    if( state!=NULL )
    {
        ae_state_clear(state);
        state->last_error = error_type;
        state->error_msg = msg;
        if( state->break_jump!=NULL )
            longjmp(*(state->break_jump), 1);
        else
            abort();
    }
    else
        abort();
#else
    if( state!=NULL )
    {
        ae_state_clear(state);
        state->last_error = error_type;
        state->error_msg = msg;
    }
    throw error_type;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
testq %rdi, %rdi
je 0x24e31
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%r15), %rax
movq 0x10(%rax), %rax
cmpq $0x1, %rax
je 0x24e29
movq %r15, %rdi
callq 0x24ff2
jmp 0x24e11
movl %ebx, 0x40(%r15)
movq %r14, 0x48(%r15)
movl $0x4, %edi
callq 0x3140
movl %ebx, (%rax)
leaq 0x1dd2c(%rip), %rsi     # 0x42b70
movq %rax, %rdi
xorl %edx, %edx
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_malloc(unsigned long, alglib_impl::ae_state*)
void* ae_malloc(size_t size, ae_state *state)
{
    void *result;
    if( size==0 )
        return NULL;
    result = aligned_malloc(size,AE_DATA_ALIGN);
    if( result==NULL && state!=NULL)
        ae_break(state, ERR_OUT_OF_MEMORY, "ae_malloc(): out of memory");
    return result;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x24f20
movq %rsi, %rbx
movl $0x10, %esi
callq 0x24e78
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x24f22
leaq 0x11915(%rip), %rdx     # 0x36828
movq %rbx, %rdi
movl $0x1, %esi
callq 0x24dff
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_update_row_pointers(alglib_impl::ae_matrix*, void*)
void ae_matrix_update_row_pointers(ae_matrix *dst, void *storage)
{
    char *p_base;
    void **pp_ptr;
    ae_int_t i;
    if( dst->rows>0 && dst->cols>0 )
    {
        p_base = (char*)storage;
        pp_ptr = (void**)dst->data.ptr;
        dst->ptr.pp_void = pp_ptr;
        for(i=0; i<dst->rows; i++, p_base+=dst->stride*ae_sizeof(dst->datatype))
            pp_ptr[i] = p_base;
    }
    else
        dst->ptr.pp_void = NULL;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
jle 0x24f84
cmpq $0x0, 0x8(%rdi)
jle 0x24f84
movq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rdi
leaq -0x1(%rdi), %r8
xorl %r9d, %r9d
leaq 0x11da0(%rip), %r10     # 0x36d00
movq %rsi, (%rcx,%r9,8)
cmpq $0x3, %r8
ja 0x24f71
movq -0x8(%r10,%rdi,8), %r11
jmp 0x24f74
xorl %r11d, %r11d
imulq %rdx, %r11
incq %r9
addq %r11, %rsi
cmpq %r9, %rax
jne 0x24f60
retq
movq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_frame_leave(alglib_impl::ae_state*)
void ae_frame_leave(ae_state *state)
{
    while( state->p_top_block->ptr!=DYN_FRAME && state->p_top_block->ptr!=DYN_BOTTOM)
    {
        if( state->p_top_block->ptr!=NULL && state->p_top_block->deallocator!=NULL)
            ((ae_deallocator)(state->p_top_block->deallocator))(state->p_top_block->ptr);
        state->p_top_block = state->p_top_block->p_next;
    }
    state->p_top_block = state->p_top_block->p_next;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rax
cmpq $0x2, %rax
je 0x25048
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
cmpq $0x1, %rax
je 0x25048
movq 0x20(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x25037
movq 0x20(%rbx), %rax
cmpq $0x0, 0x8(%rax)
je 0x25037
movq 0x20(%rbx), %rax
movq 0x20(%rbx), %rcx
movq 0x10(%rcx), %rdi
callq *0x8(%rax)
movq 0x20(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x20(%rbx)
movq 0x20(%rbx), %rax
jmp 0x24ffa
movq 0x20(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_malloc(alglib_impl::ae_dyn_block*, long, alglib_impl::ae_state*, bool)
ae_bool ae_db_malloc(ae_dyn_block *block, ae_int_t size, ae_state *state, ae_bool make_automatic)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(size>=0, "ae_db_malloc(): negative size", state);
    if( size<0 )
        return ae_false;
    
    /* alloc */
    block->ptr = ae_malloc((size_t)size, state);
    if( block->ptr==NULL && size!=0 )
        return ae_false;
    if( make_automatic && state!=NULL )
        ae_db_attach(block, state);
    else
        block->p_next = NULL;
    block->deallocator = ae_free;
    return ae_true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x250ad
testq %r15, %r15
jns 0x250b2
leaq 0x117a3(%rip), %rdx     # 0x36843
movq %r14, %rdi
movl $0x3, %esi
callq 0x24dff
testq %r15, %r15
js 0x250cf
movq %r15, %rdi
movq %r14, %rsi
callq 0x24ee9
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rax
testq %r15, %r15
je 0x250d3
testq %rax, %rax
jne 0x250d3
xorl %eax, %eax
jmp 0x25103
testq %r14, %r14
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x250ef
movq 0x20(%r14), %rax
movq %rax, (%rbx)
movq %rbx, 0x20(%r14)
jmp 0x250f6
movq $0x0, (%rbx)
leaq -0x1d9(%rip), %rax      # 0x24f24
movq %rax, 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_realloc(alglib_impl::ae_dyn_block*, long, alglib_impl::ae_state*)
ae_bool ae_db_realloc(ae_dyn_block *block, ae_int_t size, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(size>=0, "ae_db_realloc(): negative size", state);
    if( size<0 )
        return ae_false;
    
    /* realloc */
    if( block->ptr!=NULL )
        ((ae_deallocator)block->deallocator)(block->ptr);
    block->ptr = ae_malloc((size_t)size, state);
    if( block->ptr==NULL && size!=0 )
        return ae_false;
    block->deallocator = ae_free;
    return ae_true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x25153
testq %r14, %r14
jns 0x25158
leaq 0x1171b(%rip), %rdx     # 0x36861
movq %r15, %rdi
movl $0x3, %esi
callq 0x24dff
testq %r14, %r14
js 0x25183
cmpq $0x0, 0x10(%rbx)
je 0x25166
movq 0x10(%rbx), %rdi
callq *0x8(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x24ee9
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rax
testq %r14, %r14
je 0x25187
testq %rax, %rax
jne 0x25187
xorl %eax, %eax
jmp 0x25194
leaq -0x26a(%rip), %rax      # 0x24f24
movq %rax, 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_free(alglib_impl::ae_dyn_block*)
void ae_db_free(ae_dyn_block *block)
{
    if( block->ptr!=NULL )
        ((ae_deallocator)block->deallocator)(block->ptr);
    block->ptr = NULL;
    block->deallocator = ae_free;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x251ac
movq 0x10(%rbx), %rdi
callq *0x8(%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x297(%rip), %rax      # 0x24f24
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_swap_matrices(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*)
void ae_db_swap(ae_dyn_block *block1, ae_dyn_block *block2)
{
    void (*deallocator)(void*) = NULL;
    void * volatile ptr;
    ptr = block1->ptr;
    deallocator = block1->deallocator;
    block1->ptr = block2->ptr;
    block1->deallocator = block2->deallocator;
    block2->ptr = ptr;
    block2->deallocator = deallocator;
}

// Assembly:
movq 0x30(%rdi), %rax
movq %rax, -0x8(%rsp)
movq 0x28(%rdi), %rax
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rdi)
movq -0x8(%rsp), %rcx
movq %rcx, 0x30(%rsi)
movq %rax, 0x28(%rsi)
movq 0x38(%rdi), %rax
movups (%rsi), %xmm0
movups (%rdi), %xmm1
movups 0x10(%rdi), %xmm2
movups %xmm0, (%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movq 0x38(%rsi), %rcx
movq %rcx, 0x38(%rdi)
movups %xmm1, (%rsi)
movups %xmm2, 0x10(%rsi)
movq %rax, 0x38(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_init(alglib_impl::ae_vector*, long, long, alglib_impl::ae_state*, bool)
ae_bool ae_vector_init(ae_vector *dst, ae_int_t size, ae_datatype datatype, ae_state *state, ae_bool make_automatic)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(size>=0, "ae_vector_init(): negative size", state);
    if( size<0 )
        return ae_false;

    /* init */
    dst->cnt = size;
    dst->datatype = datatype;
    if( !ae_db_malloc(&dst->data, size*ae_sizeof(datatype), state, make_automatic) )
        return ae_false;
    dst->ptr.p_ptr = dst->data.ptr;
    return ae_true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rcx, %rcx
je 0x2520e
testq %rsi, %rsi
jns 0x25213
leaq 0x1167f(%rip), %rdx     # 0x36880
movq %rcx, %rdi
movl $0x3, %esi
callq 0x24dff
testq %rsi, %rsi
js 0x2525e
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
leaq -0x1(%rdx), %rax
cmpq $0x3, %rax
ja 0x25236
leaq 0x11ad1(%rip), %rax     # 0x36d00
movq -0x8(%rax,%rdx,8), %rax
jmp 0x25238
xorl %eax, %eax
imulq %rsi, %rax
movzbl %r8b, %r8d
movq %rax, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x2507d
testb %al, %al
je 0x2525e
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
movb $0x1, %al
jmp 0x25260
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_init_copy(alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*, bool)
ae_bool ae_vector_init_copy(ae_vector *dst, ae_vector *src, ae_state *state, ae_bool make_automatic)
{
    if( !ae_vector_init(dst, src->cnt, src->datatype, state, make_automatic) )
        return ae_false;
    if( src->cnt!=0 )
        memcpy(dst->ptr.p_ptr, src->ptr.p_ptr, (size_t)(src->cnt*ae_sizeof(src->datatype)));
    return ae_true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x251ec
movl %eax, %ebx
testb %al, %al
je 0x252bc
movq (%r14), %rax
testq %rax, %rax
je 0x252bc
movq 0x28(%r15), %rdi
movq 0x8(%r14), %rcx
movq 0x28(%r14), %rsi
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
ja 0x252b1
leaq 0x11a56(%rip), %rdx     # 0x36d00
movq -0x8(%rdx,%rcx,8), %rdx
jmp 0x252b3
xorl %edx, %edx
imulq %rax, %rdx
callq 0x3200
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_set_length(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool ae_vector_set_length(ae_vector *dst, ae_int_t newsize, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(newsize>=0, "ae_vector_set_length(): negative size", state);
    if( newsize<0 )
        return ae_false;

    /* set length */
    if( dst->cnt==newsize )
        return ae_true;
    dst->cnt = newsize;
    if( !ae_db_realloc(&dst->data, newsize*ae_sizeof(dst->datatype), state) )
        return ae_false;
    dst->ptr.p_ptr = dst->data.ptr;
    return ae_true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdx, %rdx
je 0x2534e
testq %rsi, %rsi
jns 0x25353
leaq 0x11562(%rip), %rax     # 0x368a0
movq %rdx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x24dff
testq %rsi, %rsi
js 0x25399
movb $0x1, %bl
cmpq %rsi, (%r14)
je 0x2539b
movq %rsi, (%r14)
leaq 0x10(%r14), %rdi
movq 0x8(%r14), %rax
leaq -0x1(%rax), %rcx
cmpq $0x3, %rcx
ja 0x2537d
leaq 0x1198a(%rip), %rcx     # 0x36d00
movq -0x8(%rcx,%rax,8), %rax
jmp 0x2537f
xorl %eax, %eax
imulq %rsi, %rax
movq %rax, %rsi
callq 0x25127
testb %al, %al
je 0x25399
movq 0x20(%r14), %rax
movq %rax, 0x28(%r14)
jmp 0x2539b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init(alglib_impl::ae_matrix*, long, long, long, alglib_impl::ae_state*, bool)
ae_bool ae_matrix_init(ae_matrix *dst, ae_int_t rows, ae_int_t cols, ae_datatype datatype, ae_state *state, ae_bool make_automatic)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(rows>=0 && cols>=0, "ae_matrix_init(): negative length", state);
    if( rows<0 || cols<0 )
        return ae_false;

    /* if one of rows/cols is zero, another MUST be too */
    if( rows==0 || cols==0 )
    {
        rows = 0;
        cols = 0;
    }

    /* init */
    dst->rows = rows;
    dst->cols = cols;
    dst->stride = cols;
    while( dst->stride*ae_sizeof(datatype)%AE_DATA_ALIGN!=0 )
        dst->stride++;
    dst->datatype = datatype;
    if( !ae_db_malloc(&dst->data, dst->rows*((ae_int_t)sizeof(void*)+dst->stride*ae_sizeof(datatype))+AE_DATA_ALIGN-1, state, make_automatic) )
        return ae_false;
    ae_matrix_update_row_pointers(dst, ae_align((char*)dst->data.ptr+dst->rows*sizeof(void*),AE_DATA_ALIGN));
    return ae_true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %r8, %r8
sete %dil
movq %rdx, %rax
orq %rsi, %rax
setns %r10b
orb %dil, %r10b
je 0x254f5
testq %rax, %rax
js 0x254f1
testq %rsi, %rsi
movq %rdx, %r10
cmoveq %rsi, %r10
testq %rdx, %rdx
cmoveq %rdx, %rsi
movq %rsi, (%rbx)
movq %r10, 0x8(%rbx)
leaq -0x1(%rcx), %rdx
leaq 0x1189a(%rip), %rax     # 0x36d00
cmpq $0x3, %rdx
ja 0x25473
movq -0x8(%rax,%rcx,8), %rdi
jmp 0x25475
xorl %edi, %edi
imull %r10d, %edi
incq %r10
testb $0xf, %dil
jne 0x25466
decq %r10
movq %r10, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
cmpq $0x3, %rdx
ja 0x2549e
movq -0x8(%rax,%rcx,8), %rax
jmp 0x254a0
xorl %eax, %eax
imulq %r10, %rax
addq $0x8, %rax
imulq %rsi, %rax
addq $0xf, %rax
movzbl %r9b, %ecx
movq %rax, %rsi
movq %r8, %rdx
callq 0x2507d
testb %al, %al
je 0x254f1
movq (%rbx), %rax
shlq $0x3, %rax
addq 0x30(%rbx), %rax
movl %eax, %ecx
andl $0xf, %ecx
movl $0x10, %esi
subq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x24f33
movb $0x1, %al
jmp 0x254f3
xorl %eax, %eax
popq %rbx
retq
leaq 0x113ca(%rip), %rdx     # 0x368c6
movq %r8, %rdi
movl $0x3, %esi
callq 0x24dff
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init_copy(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*, alglib_impl::ae_state*, bool)
ae_bool ae_matrix_init_copy(ae_matrix *dst, ae_matrix *src, ae_state *state, ae_bool make_automatic)
{
    ae_int_t i;
    if( !ae_matrix_init(dst, src->rows, src->cols, src->datatype, state, make_automatic) )
        return ae_false;
    if( src->rows!=0 && src->cols!=0 )
    {
        if( dst->stride==src->stride )
            memcpy(dst->ptr.pp_void[0], src->ptr.pp_void[0], (size_t)(src->rows*src->stride*ae_sizeof(src->datatype)));
        else
            for(i=0; i<dst->rows; i++)
                memcpy(dst->ptr.pp_void[i], src->ptr.pp_void[i], (size_t)(dst->cols*ae_sizeof(dst->datatype)));
    }
    return ae_true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %r9d
movq %rdx, %r8
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
movq 0x18(%r14), %rcx
callq 0x2541c
movl %eax, %ebx
testb %al, %al
je 0x255dd
movq (%r14), %rax
testq %rax, %rax
je 0x255dd
cmpq $0x0, 0x8(%r14)
je 0x255dd
movq 0x10(%r15), %rdx
cmpq 0x10(%r14), %rdx
jne 0x25587
movq 0x38(%r15), %rcx
movq (%rcx), %rdi
movq 0x18(%r14), %rcx
movq 0x38(%r14), %rsi
movq (%rsi), %rsi
imulq %rax, %rdx
leaq -0x1(%rcx), %rax
cmpq $0x3, %rax
ja 0x255d2
leaq 0x11780(%rip), %rax     # 0x36d00
movq -0x8(%rax,%rcx,8), %rax
jmp 0x255d4
cmpq $0x0, (%r15)
jle 0x255dd
xorl %r12d, %r12d
leaq 0x11769(%rip), %r13     # 0x36d00
movq 0x18(%r15), %rax
leaq -0x1(%rax), %rcx
cmpq $0x3, %rcx
ja 0x255ac
movq -0x8(%r13,%rax,8), %rdx
jmp 0x255ae
xorl %edx, %edx
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rdi
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rsi
imulq 0x8(%r15), %rdx
callq 0x3200
incq %r12
cmpq (%r15), %r12
jl 0x25597
jmp 0x255dd
xorl %eax, %eax
imulq %rax, %rdx
callq 0x3200
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init_from_x(alglib_impl::ae_matrix*, alglib_impl::x_matrix*, alglib_impl::ae_state*, bool)
void ae_matrix_init_from_x(ae_matrix *dst, x_matrix *src, ae_state *state, ae_bool make_automatic)
{
    char *p_src_row;
    char *p_dst_row;
    ae_int_t row_size;
    ae_int_t i;
    ae_matrix_init(dst, (ae_int_t)src->rows, (ae_int_t)src->cols, (ae_datatype)src->datatype, state, make_automatic);
    if( src->rows!=0 && src->cols!=0 )
    {
        p_src_row = (char*)src->ptr;
        p_dst_row = (char*)(dst->ptr.pp_void[0]);
        row_size = ae_sizeof((ae_datatype)src->datatype)*(ae_int_t)src->cols;
        for(i=0; i<src->rows; i++, p_src_row+=src->stride*ae_sizeof((ae_datatype)src->datatype), p_dst_row+=dst->stride*ae_sizeof((ae_datatype)src->datatype))
            memcpy(p_dst_row, p_src_row, (size_t)(row_size));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r9d
movq %rdx, %r8
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
movq 0x18(%rbx), %rcx
callq 0x2541c
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x256c2
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x256c2
movq 0x18(%rbx), %rdx
leaq -0x1(%rdx), %rsi
cmpq $0x3, %rsi
ja 0x25645
leaq 0x116c2(%rip), %rsi     # 0x36d00
movq -0x8(%rsi,%rdx,8), %r15
jmp 0x25648
xorl %r15d, %r15d
testq %rcx, %rcx
jle 0x256c2
movq 0x38(%r14), %rcx
movq 0x30(%rbx), %r12
movq (%rcx), %r13
imulq %rax, %r15
xorl %ebp, %ebp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
movq 0x18(%rbx), %rcx
decq %rcx
cmpq $0x3, %rcx
ja 0x256b0
movq 0x10(%rbx), %rax
leaq 0x10bec(%rip), %rdx     # 0x36270
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq (%r12,%rax,8), %r12
movl $0x8, %eax
jmp 0x256b2
addq %rax, %r12
movl $0x1, %eax
jmp 0x256b2
shlq $0x4, %rax
addq %rax, %r12
movl $0x10, %eax
jmp 0x256b2
xorl %eax, %eax
imulq 0x10(%r14), %rax
incq %rbp
addq %rax, %r13
cmpq (%rbx), %rbp
jl 0x2565e
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/ap.cpp
// Function: alglib_impl::ae_matrix_set_length(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool ae_matrix_set_length(ae_matrix *dst, ae_int_t rows, ae_int_t cols, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(rows>=0 && cols>=0, "ae_matrix_set_length(): negative length", state);
    if( rows<0 || cols<0 )
        return ae_false;

    if( dst->rows==rows && dst->cols==cols )
        return ae_true;    
    dst->rows = rows;
    dst->cols = cols;
    dst->stride = cols;
    while( dst->stride*ae_sizeof(dst->datatype)%AE_DATA_ALIGN!=0 )
        dst->stride++;
    if( !ae_db_realloc(&dst->data, dst->rows*((ae_int_t)sizeof(void*)+dst->stride*ae_sizeof(dst->datatype))+AE_DATA_ALIGN-1, state) )
        return ae_false;
    ae_matrix_update_row_pointers(dst, ae_align((char*)dst->data.ptr+dst->rows*sizeof(void*),AE_DATA_ALIGN));
    return ae_true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rcx, %rcx
sete %dil
movq %rdx, %rax
orq %rsi, %rax
setns %r8b
orb %dil, %r8b
je 0x257a5
testq %rax, %rax
js 0x257a1
cmpq %rsi, (%rbx)
jne 0x25709
movb $0x1, %al
cmpq %rdx, 0x8(%rbx)
je 0x257a3
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
movq 0x18(%rbx), %rax
leaq -0x1(%rax), %r9
leaq 0x115e1(%rip), %r8      # 0x36d00
cmpq $0x3, %r9
ja 0x2572c
movq -0x8(%r8,%rax,8), %rdi
jmp 0x2572e
xorl %edi, %edi
imull %edx, %edi
incq %rdx
testb $0xf, %dil
jne 0x2571f
decq %rdx
movq %rdx, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
cmpq $0x3, %r9
ja 0x25752
movq -0x8(%r8,%rax,8), %rax
jmp 0x25754
xorl %eax, %eax
imulq %rdx, %rax
addq $0x8, %rax
imulq %rsi, %rax
addq $0xf, %rax
movq %rax, %rsi
movq %rcx, %rdx
callq 0x25127
testb %al, %al
je 0x257a1
movq (%rbx), %rax
shlq $0x3, %rax
addq 0x30(%rbx), %rax
movl %eax, %ecx
andl $0xf, %ecx
movl $0x10, %esi
subq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x24f33
movb $0x1, %al
jmp 0x257a3
xorl %eax, %eax
popq %rbx
retq
leaq 0x1113c(%rip), %rdx     # 0x368e8
movq %rcx, %rdi
movl $0x3, %esi
callq 0x24dff
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_clear(alglib_impl::ae_matrix*)
void ae_matrix_clear(ae_matrix *dst)
{
    dst->rows = 0;
    dst->cols = 0;
    dst->stride = 0;
    ae_db_free(&dst->data);
    dst->ptr.p_ptr = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x30(%rdi)
je 0x257d9
movq 0x30(%rbx), %rdi
callq *0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x30(%rbx)
leaq -0x8c2(%rip), %rcx      # 0x24f24
movq %rcx, 0x28(%rbx)
movq %rax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_set_vector(alglib_impl::x_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void ae_x_set_vector(x_vector *dst, ae_vector *src, ae_state *state)
{
    if( dst->cnt!=src->cnt || dst->datatype!=src->datatype )
    {
        if( dst->owner==OWN_AE )
            ae_free(dst->ptr);
        dst->ptr = ae_malloc((size_t)(src->cnt*ae_sizeof(src->datatype)), state);
        dst->last_action = ACT_NEW_LOCATION;
        dst->cnt = src->cnt;
        dst->datatype = src->datatype;
        dst->owner = OWN_AE;
    }
    else
        dst->last_action = ACT_SAME_LOCATION;
    if( src->cnt )
        memcpy(dst->ptr, src->ptr.p_ptr, (size_t)(src->cnt*ae_sizeof(src->datatype)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
jne 0x25873
movq 0x8(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x25873
leaq 0x18(%r14), %r12
jmp 0x258d7
cmpq $0x2, 0x10(%r14)
jne 0x2588f
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x2588f
movq -0x8(%rax), %rdi
callq 0x32e0
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
leaq -0x1(%rax), %rdx
cmpq $0x3, %rdx
ja 0x258ab
leaq 0x1145c(%rip), %rdx     # 0x36d00
movq -0x8(%rdx,%rax,8), %rdi
jmp 0x258ad
xorl %edi, %edi
imulq %rcx, %rdi
leaq 0x10(%r14), %r12
movq %r15, %rsi
callq 0x24ee9
movq %rax, 0x20(%r14)
movq $0x3, 0x18(%r14)
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%r14)
movq $0x2, (%r12)
testq %rax, %rax
je 0x25904
movq 0x20(%r14), %rdi
movq 0x28(%rbx), %rsi
leaq -0x1(%rdx), %rcx
cmpq $0x3, %rcx
ja 0x25910
leaq 0x11403(%rip), %rcx     # 0x36d00
movq -0x8(%rcx,%rdx,8), %rdx
jmp 0x25912
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %edx, %edx
imulq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3200
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_set_matrix(alglib_impl::x_matrix*, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
void ae_x_set_matrix(x_matrix *dst, ae_matrix *src, ae_state *state)
{
    char *p_src_row;
    char *p_dst_row;
    ae_int_t i;
    ae_int_t row_size;
    if( dst->rows!=src->rows || dst->cols!=src->cols || dst->datatype!=src->datatype )
    {
        if( dst->owner==OWN_AE )
            ae_free(dst->ptr);
        dst->rows = src->rows;
        dst->cols = src->cols;
        dst->stride = src->cols;
        dst->datatype = src->datatype;
        dst->ptr = ae_malloc((size_t)(dst->rows*((ae_int_t)dst->stride)*ae_sizeof(src->datatype)), state);
        dst->last_action = ACT_NEW_LOCATION;
        dst->owner = OWN_AE;
    }
    else
        dst->last_action = ACT_SAME_LOCATION;
    if( src->rows!=0 && src->cols!=0 )
    {
        p_src_row = (char*)(src->ptr.pp_void[0]);
        p_dst_row = (char*)dst->ptr;
        row_size = ae_sizeof(src->datatype)*src->cols;
        for(i=0; i<src->rows; i++, p_src_row+=src->stride*ae_sizeof(src->datatype), p_dst_row+=dst->stride*ae_sizeof(src->datatype))
            memcpy(p_dst_row, p_src_row, (size_t)(row_size));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
jne 0x25963
movq 0x8(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x25963
movq 0x18(%r14), %rdx
cmpq 0x18(%rbx), %rdx
jne 0x25963
movq $0x2, 0x28(%r14)
jmp 0x259d7
cmpq $0x2, 0x20(%r14)
jne 0x2597f
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x2597f
movq -0x8(%rax), %rdi
callq 0x32e0
movq (%rbx), %rcx
movq %rcx, (%r14)
movq 0x8(%rbx), %rdi
movq %rdi, 0x8(%r14)
movq %rdi, 0x10(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
imulq %rcx, %rdi
leaq -0x1(%rax), %rcx
cmpq $0x3, %rcx
ja 0x259b2
leaq 0x11355(%rip), %rcx     # 0x36d00
movq -0x8(%rcx,%rax,8), %rax
jmp 0x259b4
xorl %eax, %eax
imulq %rax, %rdi
movq %r15, %rsi
callq 0x24ee9
movq %rax, 0x30(%r14)
movq $0x3, 0x28(%r14)
movq $0x2, 0x20(%r14)
movq (%rbx), %rax
testq %rax, %rax
je 0x25a86
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x25a86
movq 0x18(%rbx), %rdx
leaq -0x1(%rdx), %rsi
cmpq $0x3, %rsi
ja 0x25a09
leaq 0x112fe(%rip), %rsi     # 0x36d00
movq -0x8(%rsi,%rdx,8), %r15
jmp 0x25a0c
xorl %r15d, %r15d
testq %rax, %rax
jle 0x25a86
movq 0x38(%rbx), %rax
movq (%rax), %r12
movq 0x30(%r14), %r13
imulq %rcx, %r15
xorl %ebp, %ebp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
movq 0x18(%rbx), %rcx
decq %rcx
cmpq $0x3, %rcx
ja 0x25a74
movq 0x10(%rbx), %rax
leaq 0x10838(%rip), %rdx     # 0x36280
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq (%r12,%rax,8), %r12
movl $0x8, %eax
jmp 0x25a76
addq %rax, %r12
movl $0x1, %eax
jmp 0x25a76
shlq $0x4, %rax
addq %rax, %r12
movl $0x10, %eax
jmp 0x25a76
xorl %eax, %eax
imulq 0x10(%r14), %rax
incq %rbp
addq %rax, %r13
cmpq (%rbx), %rbp
jl 0x25a22
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/ap.cpp
// Function: alglib_impl::ae_x_attach_to_vector(alglib_impl::x_vector*, alglib_impl::ae_vector*)
void ae_x_attach_to_vector(x_vector *dst, ae_vector *src)
{
    if( dst->owner==OWN_AE )
        ae_free(dst->ptr);
    dst->ptr = src->ptr.p_ptr;
    dst->last_action = ACT_NEW_LOCATION;
    dst->cnt = src->cnt;
    dst->datatype = src->datatype;
    dst->owner = OWN_CALLER;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x2, 0x10(%rdi)
jne 0x25ab8
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x25ab8
movq -0x8(%rax), %rdi
callq 0x32e0
movq 0x28(%r14), %rax
movq %rax, 0x20(%rbx)
movq $0x3, 0x18(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq