LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23b55
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x13ed6
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23add
movq (%r14), %rax
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
cmpq %rcx, %rax
je 0x13ed6
movq 0x28(%r14), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq 0x28(%rbx), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x13eba
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copyrealmatrix(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
void copyrealmatrix(/* Real    */ ae_matrix* src,
     /* Real    */ ae_matrix* dst,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;

    ae_matrix_clear(dst);

    if( src->rows>0&&src->cols>0 )
    {
        ae_matrix_set_length(dst, src->rows, src->cols, _state);
        for(i=0; i<=src->rows-1; i++)
        {
            for(j=0; j<=src->cols-1; j++)
            {
                dst->ptr.pp_double[i][j] = src->ptr.pp_double[i][j];
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x23eed
movq (%r14), %rsi
testq %rsi, %rsi
jle 0x13f59
movq 0x8(%r14), %rdx
testq %rdx, %rdx
jle 0x13f59
movq %rbx, %rdi
movq %r15, %rcx
callq 0x23e0a
movq (%r14), %rax
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x13f59
movq 0x8(%r14), %rsi
testq %rsi, %rsi
cmovleq %rcx, %rsi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x13f54
movq 0x38(%r14), %r8
movq (%r8,%rdx,8), %r8
movsd (%r8,%rdi,8), %xmm0
movq 0x38(%rbx), %r8
movq (%r8,%rdx,8), %r8
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
jmp 0x13f2e
incq %rdx
jmp 0x13f1c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_apbuffers_init(alglib_impl::apbuffers*, alglib_impl::ae_state*, bool)
ae_bool _apbuffers_init(apbuffers* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->ia0, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia1, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia2, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia3, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra0, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra1, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra2, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra3, 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
pushq $0x2
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x140cc
leaq 0x30(%r14), %rdi
movzbl %bpl, %ebp
pushq $0x2
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x140cc
leaq 0x60(%r14), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x140cc
leaq 0x90(%r14), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x140cc
leaq 0xc0(%r14), %rdi
pushq $0x3
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x140cc
leaq 0xf0(%r14), %rdi
pushq $0x3
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x140cc
leaq 0x120(%r14), %rdi
pushq $0x3
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x140cc
addq $0x150, %r14            # imm = 0x150
pushq $0x3
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x239a5
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_apbuffers_init_copy(alglib_impl::apbuffers*, alglib_impl::apbuffers*, alglib_impl::ae_state*, bool)
ae_bool _apbuffers_init_copy(apbuffers* dst, apbuffers* src, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init_copy(&dst->ia0, &src->ia0, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia1, &src->ia1, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia2, &src->ia2, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia3, &src->ia3, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra0, &src->ra0, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra1, &src->ra1, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra2, &src->ra2, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra3, &src->ra3, _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 0x23a2b
testb %al, %al
je 0x141b7
leaq 0x30(%r15), %rdi
leaq 0x30(%r14), %rsi
movzbl %bpl, %ebp
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x141b7
leaq 0x60(%r15), %rdi
leaq 0x60(%r14), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x141b7
movl $0x90, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x141b7
movl $0xc0, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x141b7
movl $0xf0, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x141b7
movl $0x120, %esi            # imm = 0x120
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x141b7
movl $0x150, %eax            # imm = 0x150
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 0x23a2b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_apbuffers_clear(alglib_impl::apbuffers*)
void _apbuffers_clear(apbuffers* p)
{
    ae_vector_clear(&p->ia0);
    ae_vector_clear(&p->ia1);
    ae_vector_clear(&p->ia2);
    ae_vector_clear(&p->ia3);
    ae_vector_clear(&p->ra0);
    ae_vector_clear(&p->ra1);
    ae_vector_clear(&p->ra2);
    ae_vector_clear(&p->ra3);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x23b55
leaq 0x30(%rbx), %rdi
callq 0x23b55
leaq 0x60(%rbx), %rdi
callq 0x23b55
leaq 0x90(%rbx), %rdi
callq 0x23b55
leaq 0xc0(%rbx), %rdi
callq 0x23b55
leaq 0xf0(%rbx), %rdi
callq 0x23b55
leaq 0x120(%rbx), %rdi
callq 0x23b55
addq $0x150, %rbx            # imm = 0x150
movq %rbx, %rdi
popq %rbx
jmp 0x23b55
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::tagsort(alglib_impl::ae_vector*, long, alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void tagsort(/* Real    */ ae_vector* a,
     ae_int_t n,
     /* Integer */ ae_vector* p1,
     /* Integer */ ae_vector* p2,
     ae_state *_state)
{
    ae_frame _frame_block;
    apbuffers buf;

    ae_frame_make(_state, &_frame_block);
    ae_vector_clear(p1);
    ae_vector_clear(p2);
    _apbuffers_init(&buf, _state, ae_true);

    tagsortbuf(a, n, p1, p2, &buf, _state);
    ae_frame_leave(_state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsp, %rsi
movq %r8, %rdi
callq 0x23815
movq %r15, %rdi
callq 0x23b55
movq %r14, %rdi
callq 0x23b55
leaq 0x18(%rsp), %rbp
pushq $0x1
popq %rdx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x13fe2
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbp, %r8
movq %rbx, %r9
callq 0x1429e
movq %rbx, %rdi
callq 0x237b6
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::tagsortfast(alglib_impl::ae_vector*, alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
void tagsortfast(/* Real    */ ae_vector* a,
     /* Real    */ ae_vector* bufa,
     ae_int_t n,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_bool isascending;
    ae_bool isdescending;
    double tmpr;


    
    /*
     * Special case
     */
    if( n<=1 )
    {
        return;
    }
    
    /*
     * Test for already sorted set
     */
    isascending = ae_true;
    isdescending = ae_true;
    for(i=1; i<=n-1; i++)
    {
        isascending = isascending&&a->ptr.p_double[i]>=a->ptr.p_double[i-1];
        isdescending = isdescending&&a->ptr.p_double[i]<=a->ptr.p_double[i-1];
    }
    if( isascending )
    {
        return;
    }
    if( isdescending )
    {
        for(i=0; i<=n-1; i++)
        {
            j = n-1-i;
            if( j<=i )
            {
                break;
            }
            tmpr = a->ptr.p_double[i];
            a->ptr.p_double[i] = a->ptr.p_double[j];
            a->ptr.p_double[j] = tmpr;
        }
        return;
    }
    
    /*
     * General case
     */
    if( bufa->cnt<n )
    {
        ae_vector_set_length(bufa, n, _state);
    }
    tsort_tagsortfastrec(a, bufa, 0, n-1, _state);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x2, %rdx
jl 0x14bb2
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rax
movb $0x1, %dil
movb $0x1, %sil
cmpq %rax, %rdx
je 0x14bac
testb $0x1, %dil
je 0x14b88
movq 0x28(%rbx), %rdi
movsd (%rdi,%rax,8), %xmm0
ucomisd -0x8(%rdi,%rax,8), %xmm0
setae %dil
jmp 0x14b8a
xorl %edi, %edi
testb $0x1, %sil
je 0x14ba5
movq 0x28(%rbx), %rsi
movsd -0x8(%rsi,%rax,8), %xmm0
ucomisd (%rsi,%rax,8), %xmm0
setae %sil
jmp 0x14ba7
xorl %esi, %esi
incq %rax
jmp 0x14b68
testb $0x1, %dil
je 0x14bb8
popq %rbx
popq %r14
popq %r15
retq
leaq -0x1(%rdx), %r15
testb $0x1, %sil
je 0x14bf5
xorl %eax, %eax
cmpq $-0x1, %r15
je 0x14bb2
cmpq %rax, %r15
jle 0x14bb2
movq 0x28(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd (%rcx,%r15,8), %xmm1
movsd %xmm1, (%rcx,%rax,8)
movq 0x28(%rbx), %rcx
movsd %xmm0, (%rcx,%r15,8)
incq %rax
decq %r15
jmp 0x14bc4
cmpq %rdx, (%r14)
jge 0x14c08
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x23add
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x14c1a
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::vectornorm2(alglib_impl::ae_vector*, long, long, alglib_impl::ae_state*)
double vectornorm2(/* Real    */ ae_vector* x,
     ae_int_t i1,
     ae_int_t i2,
     ae_state *_state)
{
    ae_int_t n;
    ae_int_t ix;
    double absxi;
    double scl;
    double ssq;
    double result;


    n = i2-i1+1;
    if( n<1 )
    {
        result = 0;
        return result;
    }
    if( n==1 )
    {
        result = ae_fabs(x->ptr.p_double[i1], _state);
        return result;
    }
    scl = 0;
    ssq = 1;
    for(ix=i1; ix<=i2; ix++)
    {
        if( ae_fp_neq(x->ptr.p_double[ix],0) )
        {
            absxi = ae_fabs(x->ptr.p_double[ix], _state);
            if( ae_fp_less(scl,absxi) )
            {
                ssq = 1+ssq*ae_sqr(scl/absxi, _state);
                scl = absxi;
            }
            else
            {
                ssq = ssq+ae_sqr(absxi/scl, _state);
            }
        }
    }
    result = scl*ae_sqrt(ssq, _state);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorpd %xmm0, %xmm0
cmpq %rsi, %rdx
jl 0x154b3
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
jne 0x153d6
movq 0x28(%r15), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2440c
movq %rsi, %r12
movsd 0x1ae17(%rip), %xmm1    # 0x301f8
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
cmpq %r14, %r12
jg 0x15498
movq 0x28(%r15), %rax
movsd (%rax,%r12,8), %xmm0
xorpd %xmm1, %xmm1
callq 0x24217
testb %al, %al
je 0x1548b
movq 0x28(%r15), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x2440c
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x24239
testb %al, %al
je 0x15468
movsd (%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2441f
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x1ad9e(%rip), %xmm1    # 0x301f8
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
jmp 0x15490
movsd 0x10(%rsp), %xmm0
divsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x2441f
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd (%rsp), %xmm0
incq %r12
jmp 0x153e7
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x24424
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::vectoridxabsmax(alglib_impl::ae_vector*, long, long, alglib_impl::ae_state*)
ae_int_t vectoridxabsmax(/* Real    */ ae_vector* x,
     ae_int_t i1,
     ae_int_t i2,
     ae_state *_state)
{
    ae_int_t i;
    double a;
    ae_int_t result;


    result = i1;
    a = ae_fabs(x->ptr.p_double[result], _state);
    for(i=i1+1; i<=i2; i++)
    {
        if( ae_fp_greater(ae_fabs(x->ptr.p_double[i], _state),ae_fabs(x->ptr.p_double[result], _state)) )
        {
            result = i;
        }
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x28(%rdi), %rax
movsd (%rax,%rsi,8), %xmm0
movq %rcx, %rdi
callq 0x2440c
movq %r15, %r13
cmpq %r14, %r15
jge 0x1553e
movq 0x28(%r12), %rax
movsd 0x8(%rax,%r15,8), %xmm0
incq %r15
movq %rbx, %rdi
callq 0x2440c
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r12), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x2440c
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x24279
movq %r15, %rcx
testb %al, %al
jne 0x15539
movq %r13, %rcx
movq %rcx, %r13
jmp 0x154ec
movq %r13, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::columnidxabsmax(alglib_impl::ae_matrix*, long, long, long, alglib_impl::ae_state*)
ae_int_t columnidxabsmax(/* Real    */ ae_matrix* x,
     ae_int_t i1,
     ae_int_t i2,
     ae_int_t j,
     ae_state *_state)
{
    ae_int_t i;
    double a;
    ae_int_t result;


    result = i1;
    a = ae_fabs(x->ptr.pp_double[result][j], _state);
    for(i=i1+1; i<=i2; i++)
    {
        if( ae_fp_greater(ae_fabs(x->ptr.pp_double[i][j], _state),ae_fabs(x->ptr.pp_double[result][j], _state)) )
        {
            result = i;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x38(%rdi), %rax
movq (%rax,%rsi,8), %rax
movsd (%rax,%rcx,8), %xmm0
movq %r8, %rdi
callq 0x2440c
movq %r12, %rbp
cmpq %r15, %r12
jge 0x155d7
movq 0x38(%r13), %rax
movq 0x8(%rax,%r12,8), %rax
incq %r12
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x2440c
movsd %xmm0, (%rsp)
movq 0x38(%r13), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x2440c
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x24279
movq %r12, %rcx
testb %al, %al
jne 0x155d2
movq %rbp, %rcx
movq %rcx, %rbp
jmp 0x15581
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::rowidxabsmax(alglib_impl::ae_matrix*, long, long, long, alglib_impl::ae_state*)
ae_int_t rowidxabsmax(/* Real    */ ae_matrix* x,
     ae_int_t j1,
     ae_int_t j2,
     ae_int_t i,
     ae_state *_state)
{
    ae_int_t j;
    double a;
    ae_int_t result;


    result = j1;
    a = ae_fabs(x->ptr.pp_double[i][result], _state);
    for(j=j1+1; j<=j2; j++)
    {
        if( ae_fp_greater(ae_fabs(x->ptr.pp_double[i][j], _state),ae_fabs(x->ptr.pp_double[i][result], _state)) )
        {
            result = j;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x38(%rdi), %rax
movq (%rax,%rcx,8), %rax
movsd (%rax,%rsi,8), %xmm0
movq %r8, %rdi
callq 0x2440c
movq %r12, %rbp
cmpq %r15, %r12
jge 0x15670
movq 0x38(%r13), %rax
movq (%rax,%r14,8), %rax
movsd 0x8(%rax,%r12,8), %xmm0
incq %r12
movq %rbx, %rdi
callq 0x2440c
movsd %xmm0, (%rsp)
movq 0x38(%r13), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x2440c
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x24279
movq %r12, %rcx
testb %al, %al
jne 0x1566b
movq %rbp, %rcx
movq %rcx, %rbp
jmp 0x1561b
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::upperhessenberg1norm(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
double upperhessenberg1norm(/* Real    */ ae_matrix* a,
     ae_int_t i1,
     ae_int_t i2,
     ae_int_t j1,
     ae_int_t j2,
     /* Real    */ ae_vector* work,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    double result;


    ae_assert(i2-i1==j2-j1, "UpperHessenberg1Norm: I2-I1<>J2-J1!", _state);
    for(j=j1; j<=j2; j++)
    {
        work->ptr.p_double[j] = 0;
    }
    for(i=i1; i<=i2; i++)
    {
        for(j=ae_maxint(j1, j1+i-i1-1, _state); j<=j2; j++)
        {
            work->ptr.p_double[j] = work->ptr.p_double[j]+ae_fabs(a->ptr.pp_double[i][j], _state);
        }
    }
    result = 0;
    for(j=j1; j<=j2; j++)
    {
        result = ae_maxreal(result, work->ptr.p_double[j], _state);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %rbp
movq %rdi, %r13
movq 0x60(%rsp), %r12
movq %rdx, 0x18(%rsp)
movq %rdx, %rax
subq %rsi, %rax
movq %r8, %rcx
subq %r15, %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
leaq 0x1d7fd(%rip), %rsi     # 0x32ec2
movq %r12, %rdx
callq 0x238ca
movq %r15, %rax
cmpq %r14, %rax
jg 0x156e3
movq 0x28(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x156d0
movq %rbp, %rax
notq %rax
addq %r15, %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
cmpq 0x18(%rsp), %rbp
jg 0x1575e
movq 0x8(%rsp), %rax
leaq (%rax,%rbp), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x244a0
movq %rax, %r15
cmpq %r14, %r15
jg 0x15754
movq 0x28(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x38(%r13), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %r12, %rdi
callq 0x2440c
addsd 0x20(%rsp), %xmm0
movq 0x28(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x15714
incq %rbp
movq 0x10(%rsp), %r15
jmp 0x156f6
xorps %xmm0, %xmm0
cmpq %r14, %r15
jg 0x1577d
movq 0x28(%rbx), %rax
movsd (%rax,%r15,8), %xmm1
movq %r12, %rdi
callq 0x244b6
incq %r15
jmp 0x15761
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copymatrix(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_state*)
void copymatrix(/* Real    */ ae_matrix* a,
     ae_int_t is1,
     ae_int_t is2,
     ae_int_t js1,
     ae_int_t js2,
     /* Real    */ ae_matrix* b,
     ae_int_t id1,
     ae_int_t id2,
     ae_int_t jd1,
     ae_int_t jd2,
     ae_state *_state)
{
    ae_int_t isrc;
    ae_int_t idst;


    if( is1>is2||js1>js2 )
    {
        return;
    }
    ae_assert(is2-is1==id2-id1, "CopyMatrix: different sizes!", _state);
    ae_assert(js2-js1==jd2-jd1, "CopyMatrix: different sizes!", _state);
    for(isrc=is1; isrc<=is2; isrc++)
    {
        idst = isrc-is1+id1;
        ae_v_move(&b->ptr.pp_double[idst][jd1], 1, &a->ptr.pp_double[isrc][js1], 1, ae_v_len(jd1,jd2));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %rbp
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdx, %rax
subq %rsi, %rax
setl %sil
movq %rcx, 0x8(%rsp)
subq %rcx, %rbp
setl %dl
orb %sil, %dl
je 0x157d8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x80(%rsp), %r13
movq 0x78(%rsp), %rbx
movq 0x70(%rsp), %r14
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %r15
subq %r15, %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
leaq 0x1d6df(%rip), %rsi     # 0x32ee6
movq %r13, %rdx
callq 0x238ca
movq %rbx, %rax
subq %r14, %rax
xorl %edi, %edi
cmpq %rax, %rbp
sete %dil
leaq 0x1d6c1(%rip), %rsi     # 0x32ee6
movq %r13, %rdx
callq 0x238ca
leaq (,%r14,8), %r14
shlq $0x3, 0x8(%rsp)
pushq $0x1
popq %rbp
cmpq 0x20(%rsp), %r12
jg 0x157c9
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax,%r15,8), %rbx
addq %r14, %rbx
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax,%r12,8), %r13
addq 0x8(%rsp), %r13
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x26b4d
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x2675e
incq %r12
incq %r15
jmp 0x1583e
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::inplacetranspose(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void inplacetranspose(/* Real    */ ae_matrix* a,
     ae_int_t i1,
     ae_int_t i2,
     ae_int_t j1,
     ae_int_t j2,
     /* Real    */ ae_vector* work,
     ae_state *_state)
{
    ae_int_t i;
    ae_int_t j;
    ae_int_t ips;
    ae_int_t jps;
    ae_int_t l;


    if( i1>i2||j1>j2 )
    {
        return;
    }
    ae_assert(i1-i2==j1-j2, "InplaceTranspose error: incorrect array size!", _state);
    for(i=i1; i<=i2-1; i++)
    {
        j = j1+i-i1;
        ips = i+1;
        jps = j1+ips-i1;
        l = i2-i;
        ae_v_move(&work->ptr.p_double[1], 1, &a->ptr.pp_double[ips][j], a->stride, ae_v_len(1,l));
        ae_v_move(&a->ptr.pp_double[ips][j], a->stride, &a->ptr.pp_double[i][jps], 1, ae_v_len(ips,i2));
        ae_v_move(&a->ptr.pp_double[i][jps], 1, &work->ptr.p_double[1], 1, ae_v_len(jps,j2));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x30(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, %r14
movq %rsi, %rax
movq %rdx, 0x10(%rsp)
subq %rdx, %rax
setg %dl
movq %rcx, %rbx
movq %r8, 0x48(%rsp)
subq %r8, %rcx
setg %sil
orb %dl, %sil
je 0x158de
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%rsp), %rdx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
leaq 0x1d60d(%rip), %rsi     # 0x32f03
callq 0x238ca
movq 0x10(%rsp), %rsi
subq %r14, %rsi
leaq (,%rbx,8), %rax
movq %rax, 0x38(%rsp)
incq %rbx
movq %rbx, 0x28(%rsp)
leaq (,%r14,8), %rax
movq %rax, 0x18(%rsp)
incq %r14
movq %r14, 0x20(%rsp)
xorl %r13d, %r13d
movq %rsi, %rax
movq 0x38(%rsp), %r14
subq $0x1, %rax
jb 0x158cf
movq 0x30(%rsp), %rcx
movq 0x28(%rcx), %r12
addq $0x8, %r12
movq 0x40(%rsp), %r15
movq %rax, 0x50(%rsp)
movq 0x38(%r15), %rax
movq 0x18(%rsp), %rbp
addq %rbp, %rax
movq 0x8(%r13,%rax), %rbx
addq %r14, %rbx
addq %r13, %rbx
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rdi
callq 0x26b4d
movq %r12, %rdi
pushq $0x1
popq %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
movq %rax, %r8
callq 0x2675e
movq 0x38(%r15), %rax
addq %rbp, %rax
movq 0x8(%r13,%rax), %rbx
addq %r14, %rbx
addq %r13, %rbx
movq 0x10(%r15), %rcx
movq %rcx, 0x8(%rsp)
movq (%r13,%rax), %rax
addq %r14, %rax
leaq (%rax,%r13), %r12
addq $0x8, %r12
movq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x26b4d
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
pushq $0x1
popq %rcx
movq %rax, %r8
callq 0x2675e
movq 0x38(%r15), %rax
addq 0x18(%rsp), %rax
movq (%r13,%rax), %rax
addq %r14, %rax
leaq (%rax,%r13), %rbx
addq $0x8, %rbx
movq 0x30(%rsp), %rax
movq 0x28(%rax), %r15
addq $0x8, %r15
movq 0x28(%rsp), %r12
movq %r12, %rdi
movq 0x48(%rsp), %rsi
callq 0x26b4d
movq %rbx, %rdi
pushq $0x1
popq %rcx
movq %rcx, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0x2675e
movq 0x50(%rsp), %rax
addq $0x8, %r13
incq %r12
movq %r12, 0x28(%rsp)
incq %rbp
movq %rbp, 0x20(%rsp)
movq %rax, %rsi
jmp 0x15938
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::copyandtranspose(alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_matrix*, long, long, long, long, alglib_impl::ae_state*)
void copyandtranspose(/* Real    */ ae_matrix* a,
     ae_int_t is1,
     ae_int_t is2,
     ae_int_t js1,
     ae_int_t js2,
     /* Real    */ ae_matrix* b,
     ae_int_t id1,
     ae_int_t id2,
     ae_int_t jd1,
     ae_int_t jd2,
     ae_state *_state)
{
    ae_int_t isrc;
    ae_int_t jdst;


    if( is1>is2||js1>js2 )
    {
        return;
    }
    ae_assert(is2-is1==jd2-jd1, "CopyAndTranspose: different sizes!", _state);
    ae_assert(js2-js1==id2-id1, "CopyAndTranspose: different sizes!", _state);
    for(isrc=is1; isrc<=is2; isrc++)
    {
        jdst = isrc-is1+jd1;
        ae_v_move(&b->ptr.pp_double[id1][jdst], b->stride, &a->ptr.pp_double[isrc][js1], 1, ae_v_len(id1,id2));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdx, %rax
subq %rsi, %rax
setl %sil
movq %rcx, (%rsp)
subq %rcx, %r15
setl %dl
orb %sil, %dl
je 0x15a99
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r9, %rbx
movq 0x70(%rsp), %r13
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %rbp
movq 0x58(%rsp), %r14
subq %rbp, %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
leaq 0x1d46e(%rip), %rsi     # 0x32f31
movq %r13, %rdx
callq 0x238ca
movq %r14, %rax
subq 0x50(%rsp), %rax
xorl %edi, %edi
cmpq %rax, %r15
sete %dil
leaq 0x1d44e(%rip), %rsi     # 0x32f31
movq %r13, %rdx
callq 0x238ca
shlq $0x3, %rbp
shlq $0x3, (%rsp)
cmpq 0x10(%rsp), %r12
jg 0x15a8a
movq 0x10(%rbx), %r13
movq 0x38(%rbx), %rax
movq 0x50(%rsp), %rdi
movq (%rax,%rdi,8), %r15
addq %rbp, %r15
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax,%r12,8), %r14
addq (%rsp), %r14
movq 0x58(%rsp), %rsi
callq 0x26b4d
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
pushq $0x1
popq %rcx
movq %rax, %r8
callq 0x2675e
incq %r12
addq $0x8, %rbp
jmp 0x15af4
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::applyreflectionfromtheleft(alglib_impl::ae_matrix*, double, alglib_impl::ae_vector*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void applyreflectionfromtheleft(/* Real    */ ae_matrix* c,
     double tau,
     /* Real    */ ae_vector* v,
     ae_int_t m1,
     ae_int_t m2,
     ae_int_t n1,
     ae_int_t n2,
     /* Real    */ ae_vector* work,
     ae_state *_state)
{
    double t;
    ae_int_t i;
    ae_int_t vm;


    if( (ae_fp_eq(tau,0)||n1>n2)||m1>m2 )
    {
        return;
    }
    
    /*
     * w := C' * v
     */
    vm = m2-m1+1;
    for(i=n1; i<=n2; i++)
    {
        work->ptr.p_double[i] = 0;
    }
    for(i=m1; i<=m2; i++)
    {
        t = v->ptr.p_double[i+1-m1];
        ae_v_addd(&work->ptr.p_double[n1], 1, &c->ptr.pp_double[i][n1], 1, ae_v_len(n1,n2), t);
    }
    
    /*
     * C := C - tau * v * w'
     */
    for(i=m1; i<=m2; i++)
    {
        t = v->ptr.p_double[i-m1+1]*tau;
        ae_v_subd(&c->ptr.pp_double[i][n1], 1, &work->ptr.p_double[n1], 1, ae_v_len(n1,n2), t);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
xorps %xmm1, %xmm1
movsd %xmm0, 0x30(%rsp)
callq 0x241f5
movq %r14, 0x28(%rsp)
movq %r15, 0x10(%rsp)
cmpq %r14, %r15
jg 0x172d6
cmpq %rbx, (%rsp)
jg 0x172d6
testb %al, %al
jne 0x172d6
movq (%rsp), %rax
cmpq %rbx, %rax
jg 0x171d3
movq 0x70(%rsp), %rcx
movq 0x28(%rcx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x171bb
movq 0x10(%rsp), %rax
leaq (,%rax,8), %r15
xorl %r13d, %r13d
movq (%rsp), %rax
leaq (,%rax,8), %r12
movq 0x10(%rsp), %rax
addq %r13, %rax
cmpq 0x28(%rsp), %rax
jg 0x1725e
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movsd 0x8(%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq 0x28(%rax), %rbp
addq %r12, %rbp
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
addq %r15, %rax
movq (%rax,%r13,8), %r14
addq %r12, %r14
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x26b4d
movq %rbp, %rdi
pushq $0x1
popq %rcx
movq %rcx, %rsi
movq %r14, %rdx
movq %rax, %r8
movsd 0x8(%rsp), %xmm0
callq 0x269b8
incq %r13
jmp 0x171ef
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
addq %r13, %rax
cmpq 0x28(%rsp), %rax
jg 0x172d6
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movsd 0x8(%rax,%r13,8), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
addq %r15, %rax
movq (%rax,%r13,8), %r14
addq %r12, %r14
movq 0x70(%rsp), %rax
movq 0x28(%rax), %rbp
addq %r12, %rbp
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x26b4d
movq %r14, %rdi
pushq $0x1
popq %rcx
movq %rcx, %rsi
movq %rbp, %rdx
movq %rax, %r8
movsd 0x8(%rsp), %xmm0
callq 0x26afc
incq %r13
jmp 0x17261
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::applyreflectionfromtheright(alglib_impl::ae_matrix*, double, alglib_impl::ae_vector*, long, long, long, long, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void applyreflectionfromtheright(/* Real    */ ae_matrix* c,
     double tau,
     /* Real    */ ae_vector* v,
     ae_int_t m1,
     ae_int_t m2,
     ae_int_t n1,
     ae_int_t n2,
     /* Real    */ ae_vector* work,
     ae_state *_state)
{
    double t;
    ae_int_t i;
    ae_int_t vm;


    if( (ae_fp_eq(tau,0)||n1>n2)||m1>m2 )
    {
        return;
    }
    vm = n2-n1+1;
    for(i=m1; i<=m2; i++)
    {
        t = ae_v_dotproduct(&c->ptr.pp_double[i][n1], 1, &v->ptr.p_double[1], 1, ae_v_len(n1,n2));
        t = t*tau;
        ae_v_subd(&c->ptr.pp_double[i][n1], 1, &v->ptr.p_double[1], 1, ae_v_len(n1,n2), t);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
xorps %xmm1, %xmm1
movsd %xmm0, 0x28(%rsp)
callq 0x241f5
movq %rbx, 0x38(%rsp)
cmpq %rbx, %r14
jg 0x17401
movq (%rsp), %rcx
cmpq 0x8(%rsp), %rcx
jg 0x17401
testb %al, %al
jne 0x17401
movq (%rsp), %rax
leaq (,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %r12
movq 0x30(%rsp), %r15
movq 0x8(%rsp), %rbp
cmpq 0x38(%rsp), %r14
jg 0x17401
movq 0x38(%r12), %rax
movq (%rax,%r14,8), %rbx
addq 0x10(%rsp), %rbx
movq 0x28(%r15), %r13
addq $0x8, %r13
movq %r14, 0x18(%rsp)
movq (%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x26b4d
movq %rbx, %rdi
pushq $0x1
popq %rcx
movq %rcx, %rsi
movq %r13, %rdx
movq %rax, %r8
callq 0x2668d
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x38(%r12), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rbx
addq 0x10(%rsp), %rbx
movq 0x28(%r15), %r13
addq $0x8, %r13
movq %r14, %rdi
movq 0x18(%rsp), %r14
movq %rbp, %rsi
callq 0x26b4d
movq %rbx, %rdi
pushq $0x1
popq %rcx
movq %rcx, %rsi
movq %r13, %rdx
movq %rax, %r8
movsd 0x40(%rsp), %xmm0
callq 0x26afc
incq %r14
jmp 0x1735f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::upperhessenbergschurdecomposition(alglib_impl::ae_matrix*, long, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
ae_bool upperhessenbergschurdecomposition(/* Real    */ ae_matrix* h,
     ae_int_t n,
     /* Real    */ ae_matrix* s,
     ae_state *_state)
{
    ae_frame _frame_block;
    ae_vector wi;
    ae_vector wr;
    ae_int_t info;
    ae_bool result;

    ae_frame_make(_state, &_frame_block);
    ae_matrix_clear(s);
    ae_vector_init(&wi, 0, DT_REAL, _state, ae_true);
    ae_vector_init(&wr, 0, DT_REAL, _state, ae_true);

    internalschurdecomposition(h, n, 1, 2, &wr, &wi, s, &info, _state);
    result = info==0;
    ae_frame_leave(_state);
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r12
leaq 0x40(%rsp), %rsi
movq %rcx, %rdi
callq 0x23815
movq %r14, %rdi
callq 0x23eed
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rbp
pushq $0x1
popq %r13
xorl %esi, %esi
movq %rbp, %rdx
movq %rbx, %rcx
movl %r13d, %r8d
callq 0x239a5
leaq 0x58(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %rbx, %rcx
movl %r13d, %r8d
callq 0x239a5
subq $0x8, %rsp
leaq 0x10(%rsp), %r13
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %r8
leaq 0x18(%rsp), %r9
pushq %rbx
pushq %r13
pushq %r14
callq 0x19094
addq $0x20, %rsp
cmpq $0x0, (%r13)
sete %bpl
movq %rbx, %rdi
callq 0x237b6
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::safesolve_cbasicsolveandupdate(alglib_impl::ae_complex, alglib_impl::ae_complex, double, double, double, double*, alglib_impl::ae_complex*, alglib_impl::ae_state*)
static ae_bool safesolve_cbasicsolveandupdate(ae_complex alpha,
     ae_complex beta,
     double lnmax,
     double bnorm,
     double maxgrowth,
     double* xnorm,
     ae_complex* x,
     ae_state *_state)
{
    double v;
    ae_bool result;

    x->x = 0;
    x->y = 0;

    result = ae_false;
    if( ae_c_eq_d(alpha,0) )
    {
        return result;
    }
    if( ae_c_neq_d(beta,0) )
    {
        
        /*
         * alpha*x[i]=beta
         */
        v = ae_log(ae_c_abs(beta, _state), _state)-ae_log(ae_c_abs(alpha, _state), _state);
        if( ae_fp_greater(v,lnmax) )
        {
            return result;
        }
        *x = ae_c_div(beta,alpha);
    }
    else
    {
        
        /*
         * alpha*x[i]=0
         */
        *x = ae_complex_from_d(0);
    }
    
    /*
     * update NrmX, test growth limit
     */
    *xnorm = ae_maxreal(*xnorm, ae_c_abs(*x, _state), _state);
    if( ae_fp_greater(*xnorm,maxgrowth*bnorm) )
    {
        return result;
    }
    result = ae_true;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd %xmm6, 0x30(%rsp)
movsd %xmm5, 0x38(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
xorps %xmm2, %xmm2
movups %xmm2, (%rsi)
xorps %xmm2, %xmm2
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
callq 0x25a3c
testb %al, %al
je 0x1d519
xorl %eax, %eax
jmp 0x1d5f3
xorps %xmm2, %xmm2
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x25a80
testb %al, %al
je 0x1d5a8
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movq %r14, %rdi
callq 0x2589c
movq %r14, %rdi
callq 0x2455f
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %r14, %rdi
callq 0x2589c
movq %r14, %rdi
callq 0x2455f
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x24279
testb %al, %al
jne 0x1d512
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
callq 0x259ab
jmp 0x1d5b0
xorps %xmm0, %xmm0
callq 0x25861
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movsd (%rbx), %xmm2
movsd %xmm2, (%rsp)
movq %r14, %rdi
callq 0x2589c
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %r14, %rdi
callq 0x244b6
movsd %xmm0, (%rbx)
movsd 0x38(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
callq 0x24279
xorb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::xdot(alglib_impl::ae_vector*, alglib_impl::ae_vector*, long, alglib_impl::ae_vector*, double*, double*, alglib_impl::ae_state*)
void xdot(/* Real    */ ae_vector* a,
     /* Real    */ ae_vector* b,
     ae_int_t n,
     /* Real    */ ae_vector* temp,
     double* r,
     double* rerr,
     ae_state *_state)
{
    ae_int_t i;
    double mx;
    double v;

    *r = 0;
    *rerr = 0;

    
    /*
     * special cases:
     * * N=0
     */
    if( n==0 )
    {
        *r = 0;
        *rerr = 0;
        return;
    }
    mx = 0;
    for(i=0; i<=n-1; i++)
    {
        v = a->ptr.p_double[i]*b->ptr.p_double[i];
        temp->ptr.p_double[i] = v;
        mx = ae_maxreal(mx, ae_fabs(v, _state), _state);
    }
    if( ae_fp_eq(mx,0) )
    {
        *r = 0;
        *rerr = 0;
        return;
    }
    xblas_xsum(temp, mx, n, r, rerr, _state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x60(%rsp), %r12
andq $0x0, (%r8)
andq $0x0, (%r9)
testq %rdx, %rdx
je 0x1e184
movq %rcx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
xorl %r14d, %r14d
testq %rdx, %rdx
movl $0x0, %r15d
movq %rdx, 0x20(%rsp)
cmovgq %rdx, %r15
xorps %xmm0, %xmm0
cmpq %r14, %r15
movsd %xmm0, 0x18(%rsp)
je 0x1e163
movq 0x28(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movq 0x28(%rbp), %rax
mulsd (%rax,%r14,8), %xmm0
movq 0x28(%r13), %rax
movsd %xmm0, (%rax,%r14,8)
movq %r12, %rdi
callq 0x2440c
movapd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
movq %r12, %rdi
callq 0x244b6
incq %r14
jmp 0x1e11b
xorpd %xmm1, %xmm1
callq 0x241f5
testb %al, %al
je 0x1e19b
movq 0x8(%rsp), %rax
andq $0x0, (%rax)
movq 0x10(%rsp), %rax
andq $0x0, (%rax)
jmp 0x1e18c
andq $0x0, (%r8)
andq $0x0, (%r9)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r12, %r8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e1c6
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::linminnormalized(alglib_impl::ae_vector*, double*, long, alglib_impl::ae_state*)
void linminnormalized(/* Real    */ ae_vector* d,
     double* stp,
     ae_int_t n,
     ae_state *_state)
{
    double mx;
    double s;
    ae_int_t i;


    
    /*
     * first, scale D to avoid underflow/overflow durng squaring
     */
    mx = 0;
    for(i=0; i<=n-1; i++)
    {
        mx = ae_maxreal(mx, ae_fabs(d->ptr.p_double[i], _state), _state);
    }
    if( ae_fp_eq(mx,0) )
    {
        return;
    }
    s = 1/mx;
    ae_v_muld(&d->ptr.p_double[0], 1, ae_v_len(0,n-1), s);
    *stp = *stp/s;
    
    /*
     * normalize D
     */
    s = ae_v_dotproduct(&d->ptr.p_double[0], 1, &d->ptr.p_double[0], 1, ae_v_len(0,n-1));
    s = 1/ae_sqrt(s, _state);
    ae_v_muld(&d->ptr.p_double[0], 1, ae_v_len(0,n-1), s);
    *stp = *stp/s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %r13d, %r13d
testq %rdx, %rdx
movl $0x0, %ebp
cmovgq %rdx, %rbp
xorpd %xmm0, %xmm0
cmpq %r13, %rbp
movsd %xmm0, 0x8(%rsp)
je 0x1e891
movq 0x28(%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq %r12, %rdi
callq 0x2440c
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movq %r12, %rdi
callq 0x244b6
incq %r13
jmp 0x1e85d
xorpd %xmm1, %xmm1
callq 0x241f5
testb %al, %al
jne 0x1e95d
decq %r14
movsd 0x1194b(%rip), %xmm0    # 0x301f8
movsd %xmm0, 0x10(%rsp)
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r15), %rbp
xorl %edi, %edi
movq %r14, %rsi
callq 0x26b4d
pushq $0x1
popq %r13
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movsd 0x8(%rsp), %xmm0
callq 0x26b08
movsd (%rbx), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movq 0x28(%r15), %rbp
xorl %edi, %edi
movq %r14, %rsi
callq 0x26b4d
movq %rbp, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x2668d
movq %r12, %rdi
callq 0x24424
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq 0x28(%r15), %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x26b4d
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
movsd 0x10(%rsp), %xmm0
callq 0x26b08
movsd (%rbx), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::armijocreate(long, alglib_impl::ae_vector*, double, alglib_impl::ae_vector*, double, double, long, alglib_impl::armijostate*, alglib_impl::ae_state*)
void armijocreate(ae_int_t n,
     /* Real    */ ae_vector* x,
     double f,
     /* Real    */ ae_vector* s,
     double stp,
     double stpmax,
     ae_int_t fmax,
     armijostate* state,
     ae_state *_state)
{


    if( state->x.cnt<n )
    {
        ae_vector_set_length(&state->x, n, _state);
    }
    if( state->xbase.cnt<n )
    {
        ae_vector_set_length(&state->xbase, n, _state);
    }
    if( state->s.cnt<n )
    {
        ae_vector_set_length(&state->s, n, _state);
    }
    state->stpmax = stpmax;
    state->fmax = fmax;
    state->stplen = stp;
    state->fcur = f;
    state->n = n;
    ae_v_move(&state->xbase.ptr.p_double[0], 1, &x->ptr.p_double[0], 1, ae_v_len(0,n-1));
    ae_v_move(&state->s.ptr.p_double[0], 1, &s->ptr.p_double[0], 1, ae_v_len(0,n-1));
    ae_vector_set_length(&state->rstate.ia, 0+1, _state);
    ae_vector_set_length(&state->rstate.ra, 0+1, _state);
    state->rstate.stage = -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %rbp
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r12
cmpq %rdi, 0x8(%r8)
jge 0x1fe7f
leaq 0x8(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
cmpq %r12, 0x48(%rbx)
jge 0x1fe94
leaq 0x48(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
cmpq %r12, 0x78(%rbx)
jge 0x1fea9
leaq 0x78(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23add
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xb8(%rbx)
movq %rbp, 0xc0(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0xa8(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0xb0(%rbx)
movq %r12, 0x40(%rbx)
movq 0x70(%rbx), %rbp
movq 0x28(%r13), %r15
decq %r12
xorl %edi, %edi
movq %r12, %rsi
callq 0x26b4d
pushq $0x1
popq %r13
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x2675e
movq 0xa0(%rbx), %r15
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rbp
xorl %edi, %edi
movq %r12, %rsi
callq 0x26b4d
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x2675e
leaq 0xe0(%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x23add
leaq 0x140(%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x23add
orl $-0x1, 0xd8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_linminstate_init_copy(alglib_impl::linminstate*, alglib_impl::linminstate*, alglib_impl::ae_state*, bool)
ae_bool _linminstate_init_copy(linminstate* dst, linminstate* src, ae_state *_state, ae_bool make_automatic)
{
    dst->brackt = src->brackt;
    dst->stage1 = src->stage1;
    dst->infoc = src->infoc;
    dst->dg = src->dg;
    dst->dgm = src->dgm;
    dst->dginit = src->dginit;
    dst->dgtest = src->dgtest;
    dst->dgx = src->dgx;
    dst->dgxm = src->dgxm;
    dst->dgy = src->dgy;
    dst->dgym = src->dgym;
    dst->finit = src->finit;
    dst->ftest1 = src->ftest1;
    dst->fm = src->fm;
    dst->fx = src->fx;
    dst->fxm = src->fxm;
    dst->fy = src->fy;
    dst->fym = src->fym;
    dst->stx = src->stx;
    dst->sty = src->sty;
    dst->stmin = src->stmin;
    dst->stmax = src->stmax;
    dst->width = src->width;
    dst->width1 = src->width1;
    dst->xtrapf = src->xtrapf;
    return ae_true;
}

// Assembly:
movb (%rsi), %al
movb %al, (%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movups 0x20(%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movups 0x30(%rsi), %xmm0
movups %xmm0, 0x30(%rdi)
movups 0x40(%rsi), %xmm0
movups %xmm0, 0x40(%rdi)
movups 0x50(%rsi), %xmm0
movups %xmm0, 0x50(%rdi)
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
movups 0x70(%rsi), %xmm0
movups %xmm0, 0x70(%rdi)
movups 0x80(%rsi), %xmm0
movups %xmm0, 0x80(%rdi)
movups 0x90(%rsi), %xmm0
movups %xmm0, 0x90(%rdi)
movups 0xa0(%rsi), %xmm0
movups %xmm0, 0xa0(%rdi)
movups 0xb0(%rsi), %xmm0
movups %xmm0, 0xb0(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_armijostate_init(alglib_impl::armijostate*, alglib_impl::ae_state*, bool)
ae_bool _armijostate_init(armijostate* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->x, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->xbase, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->s, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !_rcommstate_init(&p->rstate, _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
addq $0x8, %rdi
pushq $0x3
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x2046b
leaq 0x48(%r14), %rdi
movzbl %bpl, %ebp
pushq $0x3
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x2046b
leaq 0x78(%r14), %rdi
pushq $0x3
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x2046b
addq $0xd8, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x26b55
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq