LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::attach_to(alglib_impl::ae_matrix*)
void alglib::ae_matrix_wrapper::attach_to(alglib_impl::ae_matrix *ptr)
{
    if( ptr==&mat )
        throw alglib::ap_error("ALGLIB: attempt to attach matrix to itself");
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
    p_mat = ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x10(%rdi), %rax
cmpq %rsi, %rax
je 0x2cd0e
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq %rax, %r15
jne 0x2cd04
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
cmpq $0x0, 0x30(%r15)
je 0x2ccef
movq 0x30(%r15), %rdi
callq *0x28(%r15)
xorl %eax, %eax
movq %rax, 0x30(%r15)
leaq -0x7dd8(%rip), %rcx     # 0x24f24
movq %rcx, 0x28(%r15)
movq %rax, 0x38(%r15)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0x9ea7(%rip), %rsi      # 0x36bc9
movq %rax, %rdi
callq 0x28d64
leaq 0x15e4f(%rip), %rsi     # 0x42b80
leaq -0x19a76(%rip), %rdx    # 0x132c2
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::allocate_own(long, long, long)
void alglib::ae_matrix_wrapper::allocate_own(ae_int_t rows, ae_int_t cols, alglib_impl::ae_datatype datatype)
{
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
    p_mat = &mat;
    if( !ae_matrix_init(p_mat, rows, cols, datatype, NULL, false) )
        throw alglib::ap_error("ALGLIB: malloc error");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq 0x8(%rdi), %rbp
leaq 0x10(%rdi), %r12
cmpq %r12, %rbp
jne 0x2cdaa
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
cmpq $0x0, 0x30(%rbp)
je 0x2cd95
movq 0x30(%rbp), %rdi
callq *0x28(%rbp)
xorl %eax, %eax
movq %rax, 0x30(%rbp)
leaq -0x7e7e(%rip), %rcx     # 0x24f24
movq %rcx, 0x28(%rbp)
movq %rax, 0x38(%rbp)
movq %r12, 0x8(%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2541c
testb %al, %al
je 0x2cdd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0x9d02(%rip), %rsi      # 0x36aee
movq %rax, %rdi
callq 0x28d64
leaq 0x15d85(%rip), %rsi     # 0x42b80
leaq -0x19b40(%rip), %rdx    # 0x132c2
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_2d_array::boolean_2d_array(char const*)
alglib::boolean_2d_array::boolean_2d_array(const char *s)  
{
    std::vector< std::vector<const char*> > smat;
    size_t i, j;
    char *p = filter_spaces(s);
    try
    {
        str_matrix_create(p, &smat);
        if( smat.size()!=0 )
        {
            allocate_own((ae_int_t)(smat.size()), (ae_int_t)(smat[0].size()), alglib_impl::DT_BOOL);
            for(i=0; i<smat.size(); i++)
                for(j=0; j<smat[0].size(); j++)
                    operator()((ae_int_t)i,(ae_int_t)j) = parse_bool_delim(smat[i][j],",]");
        }
        else
            allocate_own(0, 0, alglib_impl::DT_BOOL);
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x15d9c(%rip), %rcx     # 0x42c60
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2b482
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2d03b
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
subq %rax, %rsi
je 0x2cfb1
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rsi
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x3, %rdx
movl $0x1, %ecx
movq %rbx, %rdi
callq 0x2cd54
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
cmpq %rax, %rdx
je 0x2cfc2
movq (%rax), %rcx
xorl %r13d, %r13d
leaq 0x9be8(%rip), %r15      # 0x36b2e
cmpq %rcx, 0x8(%rax)
je 0x2cf99
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r14d, %r14d
movq (%rax,%rbp,8), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2b65d
movq 0x8(%rbx), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%r13,8), %rcx
movb %al, (%rcx,%r14)
incq %r14
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0x2cf5a
movq 0x8(%rsp), %rdx
incq %r13
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
imulq %r12, %rsi
cmpq %rsi, %r13
jb 0x2cf46
jmp 0x2cfc2
movl $0x1, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2cd54
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2cfd5
movq -0x8(%rax), %rdi
callq 0x32e0
movq %rsp, %rdi
callq 0x328ba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2d01b
jmp 0x2cff3
movq %rax, %rdi
callq 0x3100
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2d00e
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq %rsp, %rdi
callq 0x328ba
movq %rbx, %rdi
callq 0x2c9e8
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_2d_array::setcontent(long, long, bool const*)
void alglib::boolean_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const bool *pContent )
{
    ae_int_t i, j;
    setlength(irows, icols);
    for(i=0; i<irows; i++)
        for(j=0; j<icols; j++)
            p_mat->ptr.pp_bool[i][j] = pContent[i*icols+j];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2cbb4
testq %r15, %r15
jle 0x2d29f
movq 0x8(%r12), %rax
xorl %ecx, %ecx
testq %r14, %r14
jle 0x2d294
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movq 0x38(%rax), %rdi
movq (%rdi,%rcx,8), %rdi
movb %sil, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %r14
jne 0x2d27c
incq %rcx
addq %r14, %rbx
cmpq %r15, %rcx
jne 0x2d275
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_2d_array::tostring[abi:cxx11]() const
std::string alglib::boolean_2d_array::tostring() const 
{
    std::string result;
    ae_int_t i;
    if( isempty() )
        return "[[]]";
    result = "[";
    for(i=0; i<rows(); i++)
    {
        if( i!=0 )
            result += ",";
        result += arraytostring(&operator()(i,0), cols());
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2d3a5
cmpq $0x0, (%rax)
je 0x2d3a5
cmpq $0x0, 0x8(%rax)
je 0x2d3a5
movq %rsi, %r14
movq %r15, 0x20(%rsp)
leaq 0x98f7(%rip), %rcx      # 0x36bf9
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
leaq 0x38(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
movq %rsp, %r12
xorl %ebx, %ebx
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2d334
movq (%rax), %rcx
jmp 0x2d336
xorl %ecx, %ecx
cmpq %rcx, %rbx
jge 0x2d3da
testq %rbx, %rbx
je 0x2d360
movq %r12, %rdi
leaq 0x98ad(%rip), %rsi      # 0x36bfb
callq 0x3470
movq 0x8(%r14), %rax
movq 0x38(%rax), %rcx
addq %r13, %rcx
jmp 0x2d364
movq 0x38(%rax), %rcx
movq (%rcx), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x2b89f
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d39c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %rbx
addq $0x8, %r13
jmp 0x2d326
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq 0x9841(%rip), %rsi      # 0x36bf4
leaq 0x983e(%rip), %rdx      # 0x36bf8
movq %r15, %rdi
callq 0x3290e
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2d420
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2d420
leaq 0x974e(%rip), %rsi      # 0x36b2f
movq %rsp, %rdi
callq 0x3470
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2d411
movq %rcx, (%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
jmp 0x2d417
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d454
jmp 0x2d454
jmp 0x2d454
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d457
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2d457
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2d472
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_2d_array::integer_2d_array(char const*)
alglib::integer_2d_array::integer_2d_array(const char *s)  
{
    std::vector< std::vector<const char*> > smat;
    size_t i, j;
    char *p = filter_spaces(s);
    try
    {
        str_matrix_create(p, &smat);
        if( smat.size()!=0 )
        {
            allocate_own((ae_int_t)(smat.size()), (ae_int_t)(smat[0].size()), alglib_impl::DT_INT);
            for(i=0; i<smat.size(); i++)
                for(j=0; j<smat[0].size(); j++)
                    operator()((ae_int_t)i,(ae_int_t)j) = parse_int_delim(smat[i][j],",]");
        }
        else
            allocate_own(0, 0, alglib_impl::DT_INT);
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x1576c(%rip), %rcx     # 0x42c80
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2b482
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2d03b
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
subq %rax, %rsi
je 0x2d601
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rsi
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x3, %rdx
movl $0x2, %ecx
movq %rbx, %rdi
callq 0x2cd54
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
cmpq %rax, %rdx
je 0x2d612
movq (%rax), %rcx
xorl %r13d, %r13d
leaq 0x9598(%rip), %r15      # 0x36b2e
cmpq %rcx, 0x8(%rax)
je 0x2d5e9
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r14d, %r14d
movq (%rax,%rbp,8), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2bb12
movq 0x8(%rbx), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0x2d5aa
movq 0x8(%rsp), %rdx
incq %r13
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
imulq %r12, %rsi
cmpq %rsi, %r13
jb 0x2d596
jmp 0x2d612
movl $0x2, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2cd54
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2d625
movq -0x8(%rax), %rdi
callq 0x32e0
movq %rsp, %rdi
callq 0x328ba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2d66b
jmp 0x2d643
movq %rax, %rdi
callq 0x3100
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2d65e
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq %rsp, %rdi
callq 0x328ba
movq %rbx, %rdi
callq 0x2c9e8
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_2d_array::setcontent(long, long, long const*)
void alglib::integer_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const ae_int_t *pContent )
{
    ae_int_t i, j;
    setlength(irows, icols);
    for(i=0; i<irows; i++)
        for(j=0; j<icols; j++)
            p_mat->ptr.pp_int[i][j] = pContent[i*icols+j];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2cbb4
testq %r15, %r15
jle 0x2d743
movq 0x8(%r12), %rax
leaq (,%r14,8), %rcx
xorl %edx, %edx
testq %r14, %r14
jle 0x2d738
xorl %esi, %esi
movq (%rbx,%rsi,8), %rdi
movq 0x38(%rax), %r8
movq (%r8,%rdx,8), %r8
movq %rdi, (%r8,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0x2d720
incq %rdx
addq %rcx, %rbx
cmpq %r15, %rdx
jne 0x2d719
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_2d_array::tostring[abi:cxx11]() const
std::string alglib::integer_2d_array::tostring() const 
{
    std::string result;
    ae_int_t i;
    if( isempty() )
        return "[[]]";
    result = "[";
    for(i=0; i<rows(); i++)
    {
        if( i!=0 )
            result += ",";
        result += arraytostring(&operator()(i,0), cols());
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2d849
cmpq $0x0, (%rax)
je 0x2d849
cmpq $0x0, 0x8(%rax)
je 0x2d849
movq %rsi, %r14
movq %r15, 0x20(%rsp)
leaq 0x9453(%rip), %rcx      # 0x36bf9
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
leaq 0x38(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
movq %rsp, %r12
xorl %ebx, %ebx
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2d7d8
movq (%rax), %rcx
jmp 0x2d7da
xorl %ecx, %ecx
cmpq %rcx, %rbx
jge 0x2d87e
testq %rbx, %rbx
je 0x2d804
movq %r12, %rdi
leaq 0x9409(%rip), %rsi      # 0x36bfb
callq 0x3470
movq 0x8(%r14), %rax
movq 0x38(%rax), %rcx
addq %r13, %rcx
jmp 0x2d808
movq 0x38(%rax), %rcx
movq (%rcx), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x2bd43
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d840
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %rbx
addq $0x8, %r13
jmp 0x2d7ca
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq 0x939d(%rip), %rsi      # 0x36bf4
leaq 0x939a(%rip), %rdx      # 0x36bf8
movq %r15, %rdi
callq 0x3290e
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2d8c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2d8c4
leaq 0x92aa(%rip), %rsi      # 0x36b2f
movq %rsp, %rdi
callq 0x3470
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2d8b5
movq %rcx, (%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
jmp 0x2d8bb
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d8f8
jmp 0x2d8f8
jmp 0x2d8f8
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d8fb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2d8fb
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2d916
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::real_2d_array::real_2d_array(char const*)
alglib::real_2d_array::real_2d_array(const char *s)  
{
    std::vector< std::vector<const char*> > smat;
    size_t i, j;
    char *p = filter_spaces(s);
    try
    {
        str_matrix_create(p, &smat);
        if( smat.size()!=0 )
        {
            allocate_own((ae_int_t)(smat.size()), (ae_int_t)(smat[0].size()), alglib_impl::DT_REAL);
            for(i=0; i<smat.size(); i++)
                for(j=0; j<smat[0].size(); j++)
                    operator()((ae_int_t)i,(ae_int_t)j) = parse_real_delim(smat[i][j],",]");
        }
        else
            allocate_own(0, 0, alglib_impl::DT_REAL);
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x152e8(%rip), %rcx     # 0x42ca0
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2b482
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2d03b
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
subq %rax, %rsi
je 0x2daa7
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rsi
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x3, %rdx
movl $0x3, %ecx
movq %rbx, %rdi
callq 0x2cd54
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
cmpq %rax, %rdx
je 0x2dab8
movq (%rax), %rcx
xorl %r13d, %r13d
leaq 0x90f4(%rip), %r15      # 0x36b2e
cmpq %rcx, 0x8(%rax)
je 0x2da8f
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r14d, %r14d
movq (%rax,%rbp,8), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2c002
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0x2da4e
movq 0x8(%rsp), %rdx
incq %r13
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
imulq %r12, %rsi
cmpq %rsi, %r13
jb 0x2da3a
jmp 0x2dab8
movl $0x3, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2cd54
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2dacb
movq -0x8(%rax), %rdi
callq 0x32e0
movq %rsp, %rdi
callq 0x328ba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2db11
jmp 0x2dae9
movq %rax, %rdi
callq 0x3100
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2db04
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq %rsp, %rdi
callq 0x328ba
movq %rbx, %rdi
callq 0x2c9e8
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::real_2d_array::setcontent(long, long, double const*)
void alglib::real_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const double *pContent )
{
    ae_int_t i, j;
    setlength(irows, icols);
    for(i=0; i<irows; i++)
        for(j=0; j<icols; j++)
            p_mat->ptr.pp_double[i][j] = pContent[i*icols+j];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2cbb4
testq %r15, %r15
jle 0x2dbeb
movq 0x8(%r12), %rax
leaq (,%r14,8), %rcx
xorl %edx, %edx
testq %r14, %r14
jle 0x2dbe0
xorl %esi, %esi
movsd (%rbx,%rsi,8), %xmm0
movq 0x38(%rax), %rdi
movq (%rdi,%rdx,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0x2dbc6
incq %rdx
addq %rcx, %rbx
cmpq %r15, %rdx
jne 0x2dbbf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::real_2d_array::tostring[abi:cxx11](int) const
std::string alglib::real_2d_array::tostring(int dps) const 
{
    std::string result;
    ae_int_t i;
    if( isempty() )
        return "[[]]";
    result = "[";
    for(i=0; i<rows(); i++)
    {
        if( i!=0 )
            result += ",";
        result += arraytostring(&operator()(i,0), cols(), dps);
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2dcf8
cmpq $0x0, (%rax)
je 0x2dcf8
cmpq $0x0, 0x8(%rax)
je 0x2dcf8
movl %edx, %ebp
movq %rsi, %r14
movq %r15, 0x40(%rsp)
leaq 0x8fa9(%rip), %rcx      # 0x36bf9
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
xorl %ebx, %ebx
leaq 0x20(%rsp), %r15
movq %rsp, %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2dc7d
movq (%rax), %rcx
jmp 0x2dc7f
xorl %ecx, %ecx
cmpq %rcx, %r13
jge 0x2dd2d
testq %r13, %r13
je 0x2dca9
movq %r12, %rdi
leaq 0x8f64(%rip), %rsi      # 0x36bfb
callq 0x3470
movq 0x8(%r14), %rax
movq 0x38(%rax), %rcx
addq %rbx, %rcx
jmp 0x2dcad
movq 0x38(%rax), %rcx
movq (%rcx), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0x2c165
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2dcec
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %r13
addq $0x8, %rbx
jmp 0x2dc6f
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq 0x8eee(%rip), %rsi      # 0x36bf4
leaq 0x8eeb(%rip), %rdx      # 0x36bf8
movq %r15, %rdi
callq 0x3290e
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2dd73
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2dd73
leaq 0x8dfb(%rip), %rsi      # 0x36b2f
movq %rsp, %rdi
callq 0x3470
movq 0x40(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2dd64
movq %rcx, (%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
jmp 0x2dd6a
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ddac
jmp 0x2ddac
jmp 0x2ddac
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2ddaf
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2ddaf
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2ddca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex_2d_array::complex_2d_array(char const*)
alglib::complex_2d_array::complex_2d_array(const char *s)  
{
    std::vector< std::vector<const char*> > smat;
    size_t i, j;
    char *p = filter_spaces(s);
    try
    {
        str_matrix_create(p, &smat);
        if( smat.size()!=0 )
        {
            allocate_own((ae_int_t)(smat.size()), (ae_int_t)(smat[0].size()), alglib_impl::DT_COMPLEX);
            for(i=0; i<smat.size(); i++)
                for(j=0; j<smat[0].size(); j++)
                    operator()((ae_int_t)i,(ae_int_t)j) = parse_complex_delim(smat[i][j],",]");
        }
        else
            allocate_own(0, 0, alglib_impl::DT_COMPLEX);
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x14e57(%rip), %rcx     # 0x42cc0
movq %rdi, 0x8(%rsp)
movq %rcx, (%rdi)
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rsi, %rdi
callq 0x2b482
leaq 0x10(%rsp), %rsi
movq %rax, 0x28(%rsp)
movq %rax, %rdi
callq 0x2d03b
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rsi
subq %rax, %rsi
je 0x2df89
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rsi
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x3, %rdx
movl $0x4, %ecx
movq 0x8(%rsp), %rdi
callq 0x2cd54
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
cmpq %rax, %rdx
je 0x2df9c
movq (%rax), %rcx
xorl %ebp, %ebp
leaq 0x8c38(%rip), %r15      # 0x36b2e
leaq 0x30(%rsp), %r12
cmpq %rcx, 0x8(%rax)
je 0x2df63
leaq (,%rbp,2), %r14
addq %rbp, %r14
xorl %r13d, %r13d
xorl %ebx, %ebx
movq (%rax,%r14,8), %rax
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x2c594
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq (%rax,%rbp,8), %rax
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rax,%r13)
incq %rbx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
addq $0x10, %r13
cmpq %rdx, %rbx
jb 0x2df11
movq 0x18(%rsp), %rdx
incq %rbp
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rsi
cmpq %rsi, %rbp
jb 0x2defb
jmp 0x2df9c
movl $0x4, %ecx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2cd54
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x2dfaf
movq -0x8(%rax), %rdi
callq 0x32e0
leaq 0x10(%rsp), %rdi
callq 0x328ba
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2dff7
jmp 0x2dfcf
movq %rax, %rdi
callq 0x3100
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x2dfea
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
leaq 0x10(%rsp), %rdi
callq 0x328ba
movq 0x8(%rsp), %rdi
callq 0x2c9e8
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex_2d_array::setcontent(long, long, alglib::complex const*)
void alglib::complex_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const alglib::complex *pContent )
{
    ae_int_t i, j;
    setlength(irows, icols);
    for(i=0; i<irows; i++)
        for(j=0; j<icols; j++)
        {
            p_mat->ptr.pp_complex[i][j].x = pContent[i*icols+j].x;
            p_mat->ptr.pp_complex[i][j].y = pContent[i*icols+j].y;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2cbb4
testq %r15, %r15
jle 0x2e0ee
movq 0x8(%r12), %rax
addq $0x8, %rbx
movq %r14, %rcx
shlq $0x4, %rcx
xorl %edx, %edx
testq %r14, %r14
jle 0x2e0e3
xorl %esi, %esi
movq %r14, %rdi
movsd -0x8(%rbx,%rsi), %xmm0
movq 0x38(%rax), %r8
movq (%r8,%rdx,8), %r8
movsd %xmm0, (%r8,%rsi)
movsd (%rbx,%rsi), %xmm0
movq 0x38(%rax), %r8
movq (%r8,%rdx,8), %r8
movsd %xmm0, 0x8(%r8,%rsi)
addq $0x10, %rsi
decq %rdi
jne 0x2e0b2
incq %rdx
addq %rcx, %rbx
cmpq %r15, %rdx
jne 0x2e0a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex_2d_array::tostring[abi:cxx11](int) const
std::string alglib::complex_2d_array::tostring(int dps) const 
{
    std::string result;
    ae_int_t i;
    if( isempty() )
        return "[[]]";
    result = "[";
    for(i=0; i<rows(); i++)
    {
        if( i!=0 )
            result += ",";
        result += arraytostring(&operator()(i,0), cols(), dps);
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2e1fa
cmpq $0x0, (%rax)
je 0x2e1fa
cmpq $0x0, 0x8(%rax)
je 0x2e1fa
movl %edx, %ebp
movq %rsi, %r14
movq %r15, 0x40(%rsp)
leaq 0x8aa7(%rip), %rcx      # 0x36bf9
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
xorl %ebx, %ebx
leaq 0x20(%rsp), %r15
movq %rsp, %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e17f
movq (%rax), %rcx
jmp 0x2e181
xorl %ecx, %ecx
cmpq %rcx, %r13
jge 0x2e22f
testq %r13, %r13
je 0x2e1ab
movq %r12, %rdi
leaq 0x8a62(%rip), %rsi      # 0x36bfb
callq 0x3470
movq 0x8(%r14), %rax
movq 0x38(%rax), %rcx
addq %rbx, %rcx
jmp 0x2e1af
movq 0x38(%rax), %rcx
movq (%rcx), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0x2c8bd
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2e1ee
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %r13
addq $0x8, %rbx
jmp 0x2e171
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq 0x89ec(%rip), %rsi      # 0x36bf4
leaq 0x89e9(%rip), %rdx      # 0x36bf8
movq %r15, %rdi
callq 0x3290e
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2e275
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2e275
leaq 0x88f9(%rip), %rsi      # 0x36b2f
movq %rsp, %rdi
callq 0x3470
movq 0x40(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2e266
movq %rcx, (%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
jmp 0x2e26c
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e2ae
jmp 0x2e2ae
jmp 0x2e2ae
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2e2b1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2e2b1
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2e2cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::my_stricmp(char const*, char const*)
alglib::ae_int_t alglib::my_stricmp(const char *s1, const char *s2)
{
    int c1, c2;
    
    //
    // handle special cases
    //
    if(s1==NULL && s2!=NULL)
        return -1;
    if(s1!=NULL && s2==NULL)
        return +1;
    if(s1==NULL && s2==NULL)
        return 0;

    //
    // compare
    //
    for (;;)
    {
        c1 = *s1;
        c2 = *s2;
        s1++;
        s2++;
        if( c1==0 )
            return c2==0 ? 0 : -1;
        if( c2==0 )
            return c1==0 ? 0 : +1;
        c1 = tolower(c1);
        c2 = tolower(c2);
        if( c1<c2 )
            return -1;
        if( c1>c2 )
            return +1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
setne %cl
movq $-0x1, %rbx
testb %cl, %al
jne 0x2e35b
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
sete %cl
testb %cl, %al
je 0x2e313
movl $0x1, %ebx
jmp 0x2e35b
movq %r15, %rax
orq %r14, %rax
jne 0x2e31f
xorl %ebx, %ebx
jmp 0x2e35b
xorl %r13d, %r13d
movsbl (%r15,%r13), %edi
movsbl (%r14,%r13), %ebp
testl %edi, %edi
je 0x2e353
testb %bpl, %bpl
je 0x2e30c
callq 0x3350
movl %eax, %r12d
movl %ebp, %edi
callq 0x3350
cmpl %eax, %r12d
jl 0x2e35b
incq %r13
cmpl %eax, %r12d
jle 0x2e322
jmp 0x2e30c
xorl %ebx, %ebx
negb %bpl
sbbq %rbx, %rbx
movq %rbx, %rax
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::randomreal()
double alglib::randomreal()
{
    int i1 = rand();
    int i2 = rand();
    while(i1==RAND_MAX)
        i1 =rand();
    while(i2==RAND_MAX)
        i2 =rand();
    double mx = RAND_MAX;
    return (i1+i2/mx)/mx;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x30b0
movl %eax, %ebx
callq 0x30b0
movl %eax, %ebp
cmpl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jne 0x2e744
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x2e736
movl %eax, %ebx
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0x2e75a
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x2e74c
movl %eax, %ebp
cvtsi2sd %ebx, %xmm1
cvtsi2sd %ebp, %xmm0
movsd 0x4a6e(%rip), %xmm2     # 0x331d8
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_cmv(long, long, double const*, double const*, alglib_impl::ae_complex*, double*, long, alglib_impl::ae_complex, alglib_impl::ae_complex)
void _ialglib_cmv(ae_int_t m, ae_int_t n, const double *a, const double *x, ae_complex *cy, double *dy, ae_int_t stride, ae_complex alpha, ae_complex beta)
{
    ae_int_t i, j;
    const double *pa, *parow, *pb;

    parow = a;
    for(i=0; i<m; i++)
    {
        double v0 = 0, v1 = 0;
        pa = parow;
        pb = x;
        for(j=0; j<n; j++)
        {
            v0 += pa[0]*pb[0];
            v1 += pa[0]*pb[1];
            v0 -= pa[1]*pb[1];
            v1 += pa[1]*pb[0];

            pa  += 2;
            pb  += 2;
        }
        if( cy!=NULL )
        {
            double tx = (beta.x*cy->x-beta.y*cy->y)+(alpha.x*v0-alpha.y*v1);
            double ty = (beta.x*cy->y+beta.y*cy->x)+(alpha.x*v1+alpha.y*v0);
            cy->x = tx;
            cy->y = ty;
            cy+=stride;
        }
        else
        {
            double tx = (beta.x*dy[0]-beta.y*dy[1])+(alpha.x*v0-alpha.y*v1);
            double ty = (beta.x*dy[1]+beta.y*dy[0])+(alpha.x*v1+alpha.y*v0);
            dy[0] = tx;
            dy[1] = ty;
            dy += 2*stride;
        }
        parow += 2*alglib_c_block;
    }
}

// Assembly:
testq %rdi, %rdi
jle 0x2efd1
pushq %rbx
movq 0x10(%rsp), %rax
shlq $0x4, %rax
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
xorl %r10d, %r10d
movapd 0x42c5(%rip), %xmm4     # 0x331b0
xorpd %xmm5, %xmm5
testq %rsi, %rsi
jle 0x2ef3d
xorl %r11d, %r11d
movq %rsi, %rbx
movupd (%rcx,%r11), %xmm6
movsd (%rdx,%r11), %xmm7
movsd 0x8(%rdx,%r11), %xmm8
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
mulpd %xmm6, %xmm7
shufpd $0x1, %xmm6, %xmm6      # xmm6 = xmm6[1,0]
addpd %xmm5, %xmm7
movapd %xmm8, %xmm5
xorpd %xmm4, %xmm5
unpcklpd %xmm8, %xmm5            # xmm5 = xmm5[0],xmm8[0]
mulpd %xmm6, %xmm5
addpd %xmm7, %xmm5
addq $0x10, %r11
decq %rbx
jne 0x2eefa
movapd %xmm5, %xmm6
unpckhpd %xmm5, %xmm6            # xmm6 = xmm6[1],xmm5[1]
xorpd %xmm4, %xmm6
unpcklpd %xmm5, %xmm6            # xmm6 = xmm6[0],xmm5[0]
mulpd %xmm1, %xmm6
mulpd %xmm0, %xmm5
addpd %xmm6, %xmm5
testq %r8, %r8
je 0x2ef8d
movupd (%r8), %xmm6
movapd %xmm6, %xmm7
unpckhpd %xmm6, %xmm7            # xmm7 = xmm7[1],xmm6[1]
xorpd %xmm4, %xmm7
unpcklpd %xmm6, %xmm7            # xmm7 = xmm7[0],xmm6[0]
mulpd %xmm3, %xmm7
mulpd %xmm2, %xmm6
addpd %xmm7, %xmm6
addpd %xmm6, %xmm5
movupd %xmm5, (%r8)
addq %rax, %r8
jmp 0x2efbd
movupd (%r9), %xmm6
movapd %xmm6, %xmm7
unpckhpd %xmm6, %xmm7            # xmm7 = xmm7[1],xmm6[1]
xorpd %xmm4, %xmm7
unpcklpd %xmm6, %xmm7            # xmm7 = xmm7[0],xmm6[0]
mulpd %xmm3, %xmm7
mulpd %xmm2, %xmm6
addpd %xmm7, %xmm6
addpd %xmm6, %xmm5
movupd %xmm5, (%r9)
addq %rax, %r9
xorl %r8d, %r8d
addq $0x180, %rdx            # imm = 0x180
incq %r10
cmpq %rdi, %r10
jne 0x2eeeb
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vzero(long, double*, long)
void _ialglib_vzero(ae_int_t n, double *p, ae_int_t stride)
{
    ae_int_t i;
    if( stride==1 )
    {
        for(i=0; i<n; i++,p++)
            *p = 0.0;
    }
    else
    {
        for(i=0; i<n; i++,p+=stride)
            *p = 0.0;
    }
}

// Assembly:
movq %rdi, %rax
cmpq $0x1, %rdx
jne 0x2eff1
testq %rax, %rax
jle 0x2f009
shlq $0x3, %rax
movq %rsi, %rdi
xorl %esi, %esi
movq %rax, %rdx
jmp 0x3170
testq %rax, %rax
jle 0x2f009
shlq $0x3, %rdx
movq $0x0, (%rsi)
addq %rdx, %rsi
decq %rax
jne 0x2effa
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vzero_complex(long, alglib_impl::ae_complex*, long)
void _ialglib_vzero_complex(ae_int_t n, ae_complex *p, ae_int_t stride)
{
    ae_int_t i;
    if( stride==1 )
    {
        for(i=0; i<n; i++,p++)
        {
            p->x = 0.0;
            p->y = 0.0;
        }
    }
    else
    {
        for(i=0; i<n; i++,p+=stride)
        {
            p->x = 0.0;
            p->y = 0.0;
        }
    }
}

// Assembly:
movq %rdi, %rax
cmpq $0x1, %rdx
jne 0x2f029
testq %rax, %rax
jle 0x2f040
shlq $0x4, %rax
movq %rsi, %rdi
xorl %esi, %esi
movq %rax, %rdx
jmp 0x3170
testq %rax, %rax
jle 0x2f040
shlq $0x4, %rdx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
addq %rdx, %rsi
decq %rax
jne 0x2f035
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vcopy(long, double const*, long, double*, long)
void _ialglib_vcopy(ae_int_t n, const double *a, ae_int_t stridea, double *b, ae_int_t strideb)
{
    ae_int_t i, n2;
    if( stridea==1 && strideb==1 )
    {
        n2 = n/2;
        for(i=n2; i!=0; i--, a+=2, b+=2)
        {
            b[0] = a[0];
            b[1] = a[1];
        }
        if( n%2!=0 )
            b[0] = a[0];
    }
    else
    {
        for(i=0; i<n; i++,a+=stridea,b+=strideb)
            *b = *a;
    }
}

// Assembly:
movq %rdx, %rax
xorq $0x1, %rax
movq %r8, %r9
xorq $0x1, %r9
orq %rax, %r9
jne 0x2f099
leaq 0x1(%rdi), %rax
cmpq $0x3, %rax
jb 0x2f08a
movq %rdi, %rax
shrq $0x3f, %rax
addq %rdi, %rax
sarq %rax
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rcx)
addq $0x10, %rsi
addq $0x10, %rcx
decq %rax
jne 0x2f06b
testb $0x1, %dil
je 0x2f0b9
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
retq
testq %rdi, %rdi
jle 0x2f0b9
shlq $0x3, %rdx
shlq $0x3, %r8
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
addq %rdx, %rsi
addq %r8, %rcx
decq %rdi
jne 0x2f0a6
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vcopy_complex(long, alglib_impl::ae_complex const*, long, double*, long, char const*)
void _ialglib_vcopy_complex(ae_int_t n, const ae_complex *a, ae_int_t stridea, double *b, ae_int_t strideb, const char *conj)
{
    ae_int_t i;

    /*
     * more general case
     */
    if( conj[0]=='N' || conj[0]=='n' )
    {
        for(i=0; i<n; i++,a+=stridea,b+=2*strideb)
        {
            b[0] = a->x;
            b[1] = a->y;
        }
    }
    else
    {
        for(i=0; i<n; i++,a+=stridea,b+=2*strideb)
        {
            b[0] = a->x;
            b[1] = -a->y;
        }
    }
}

// Assembly:
movzbl (%r9), %eax
orl $0x20, %eax
cmpl $0x6e, %eax
jne 0x2f0fa
testq %rdi, %rdi
jle 0x2f135
shlq $0x4, %r8
addq $0x8, %rsi
shlq $0x4, %rdx
addq $0x8, %rcx
movsd -0x8(%rsi), %xmm0
movsd %xmm0, -0x8(%rcx)
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
addq %rdx, %rsi
addq %r8, %rcx
decq %rdi
jne 0x2f0db
jmp 0x2f135
testq %rdi, %rdi
jle 0x2f135
shlq $0x4, %r8
addq $0x8, %rsi
shlq $0x4, %rdx
addq $0x8, %rcx
movaps 0x409a(%rip), %xmm0     # 0x331b0
movsd -0x8(%rsi), %xmm1
movsd %xmm1, -0x8(%rcx)
movsd (%rsi), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rcx)
addq %rdx, %rsi
addq %r8, %rcx
decq %rdi
jne 0x2f116
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vcopy_dcomplex(long, double const*, long, double*, long, char const*)
void _ialglib_vcopy_dcomplex(ae_int_t n, const double *a, ae_int_t stridea, double *b, ae_int_t strideb, const char *conj)
{
    ae_int_t i;

    /*
     * more general case
     */
    if( conj[0]=='N' || conj[0]=='n' )
    {
        for(i=0; i<n; i++,a+=2*stridea,b+=2*strideb)
        {
            b[0] = a[0];
            b[1] = a[1];
        }
    }
    else
    {
        for(i=0; i<n; i++,a+=2*stridea,b+=2*strideb)
        {
            b[0] = a[0];
            b[1] = -a[1];
        }
    }
}

// Assembly:
movzbl (%r9), %eax
orl $0x20, %eax
cmpl $0x6e, %eax
jne 0x2f176
testq %rdi, %rdi
jle 0x2f1b1
shlq $0x4, %rdx
shlq $0x4, %r8
addq $0x8, %rsi
addq $0x8, %rcx
movsd -0x8(%rsi), %xmm0
movsd %xmm0, -0x8(%rcx)
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
addq %rdx, %rsi
addq %r8, %rcx
decq %rdi
jne 0x2f157
jmp 0x2f1b1
testq %rdi, %rdi
jle 0x2f1b1
shlq $0x4, %rdx
shlq $0x4, %r8
addq $0x8, %rsi
addq $0x8, %rcx
movaps 0x401e(%rip), %xmm0     # 0x331b0
movsd -0x8(%rsi), %xmm1
movsd %xmm1, -0x8(%rcx)
movsd (%rsi), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rcx)
addq %rdx, %rsi
addq %r8, %rcx
decq %rdi
jne 0x2f192
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_mcopyblock(long, long, double const*, long, long, double*)
void _ialglib_mcopyblock(ae_int_t m, ae_int_t n, const double *a, ae_int_t op, ae_int_t stride, double *b)
{
    ae_int_t i, j, n2;
    const double *psrc;
    double *pdst;
    if( op==0 )
    {
        n2 = n/2;
        for(i=0,psrc=a; i<m; i++,a+=stride,b+=alglib_r_block,psrc=a)
        {
            for(j=0,pdst=b; j<n2; j++,pdst+=2,psrc+=2)
            {
                pdst[0] = psrc[0];
                pdst[1] = psrc[1];
            }
            if( n%2!=0 )
                pdst[0] = psrc[0];
        }
    }
    else
    {
        n2 = n/2;
        for(i=0,psrc=a; i<m; i++,a+=stride,b+=1,psrc=a)
        {
            for(j=0,pdst=b; j<n2; j++,pdst+=alglib_twice_r_block,psrc+=2)
            {
                pdst[0] = psrc[0];
                pdst[alglib_r_block] = psrc[1];
            }
            if( n%2!=0 )
                pdst[0] = psrc[0];
        }
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rax
shrq $0x3f, %rax
addq %rsi, %rax
sarq %rax
testq %rcx, %rcx
je 0x2f230
testq %rdi, %rdi
jle 0x2f292
xorl %ecx, %ecx
movq %rdx, %r11
movq %r9, %r10
cmpq $0x2, %rsi
jl 0x2f20e
movq %rax, %rbx
movq %r9, %r10
movq %rdx, %r11
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
movsd 0x8(%r11), %xmm0
movsd %xmm0, 0x100(%r10)
addq $0x200, %r10            # imm = 0x200
addq $0x10, %r11
decq %rbx
jne 0x2f1e5
testb $0x1, %sil
je 0x2f21e
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
leaq (%rdx,%r8,8), %rdx
addq $0x8, %r9
cmpq %rdi, %rcx
jne 0x2f1d0
jmp 0x2f292
testq %rdi, %rdi
jle 0x2f292
xorl %ecx, %ecx
movq %rdx, %r11
movq %r9, %r10
cmpq $0x2, %rsi
jl 0x2f26f
movq %rax, %rbx
movq %r9, %r10
movq %rdx, %r11
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
movsd 0x8(%r11), %xmm0
movsd %xmm0, 0x8(%r10)
addq $0x10, %r10
addq $0x10, %r11
decq %rbx
jne 0x2f24c
testb $0x1, %sil
je 0x2f27f
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
leaq (%rdx,%r8,8), %rdx
addq $0x100, %r9             # imm = 0x100
cmpq %rdi, %rcx
jne 0x2f237
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_mcopyunblock(long, long, double const*, long, double*, long)
void _ialglib_mcopyunblock(ae_int_t m, ae_int_t n, const double *a, ae_int_t op, double *b, ae_int_t stride)
{
    ae_int_t i, j, n2;
    const double *psrc;
    double *pdst;
    if( op==0 )
    {
        n2 = n/2;
        for(i=0,psrc=a; i<m; i++,a+=alglib_r_block,b+=stride,psrc=a)
        {
            for(j=0,pdst=b; j<n2; j++,pdst+=2,psrc+=2)
            {
                pdst[0] = psrc[0];
                pdst[1] = psrc[1];
            }
            if( n%2!=0 )
                pdst[0] = psrc[0];
        }
    }
    else
    {
        n2 = n/2;
        for(i=0,psrc=a; i<m; i++,a++,b+=stride,psrc=a)
        {
            for(j=0,pdst=b; j<n2; j++,pdst+=2,psrc+=alglib_twice_r_block)
            {
                pdst[0] = psrc[0];
                pdst[1] = psrc[alglib_r_block];
            }
            if( n%2!=0 )
                pdst[0] = psrc[0];
        }
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rax
shrq $0x3f, %rax
addq %rsi, %rax
sarq %rax
testq %rcx, %rcx
je 0x2f312
testq %rdi, %rdi
jle 0x2f374
xorl %ecx, %ecx
movq %rdx, %r11
movq %r8, %r10
cmpq $0x2, %rsi
jl 0x2f2f0
movq %rax, %rbx
movq %r8, %r10
movq %rdx, %r11
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
movsd 0x100(%r11), %xmm0
movsd %xmm0, 0x8(%r10)
addq $0x10, %r10
addq $0x200, %r11            # imm = 0x200
decq %rbx
jne 0x2f2c7
testb $0x1, %sil
je 0x2f300
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
addq $0x8, %rdx
leaq (%r8,%r9,8), %r8
cmpq %rdi, %rcx
jne 0x2f2b2
jmp 0x2f374
testq %rdi, %rdi
jle 0x2f374
xorl %ecx, %ecx
movq %rdx, %r11
movq %r8, %r10
cmpq $0x2, %rsi
jl 0x2f351
movq %rax, %rbx
movq %r8, %r10
movq %rdx, %r11
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
movsd 0x8(%r11), %xmm0
movsd %xmm0, 0x8(%r10)
addq $0x10, %r10
addq $0x10, %r11
decq %rbx
jne 0x2f32e
testb $0x1, %sil
je 0x2f361
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
addq $0x100, %rdx            # imm = 0x100
leaq (%r8,%r9,8), %r8
cmpq %rdi, %rcx
jne 0x2f319
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_cmatrixrank1(long, long, alglib_impl::ae_complex*, long, alglib_impl::ae_complex*, alglib_impl::ae_complex*)
ae_bool _ialglib_cmatrixrank1(ae_int_t m,
     ae_int_t n,
     ae_complex *_a,
     ae_int_t _a_stride,
     ae_complex *_u,
     ae_complex *_v)
{
    ae_complex *arow, *pu, *pv, *vtmp, *dst;
    ae_int_t n2 = n/2;
    ae_int_t i, j;

    /*
     * update pairs of rows
     */
    arow  = _a;
    pu    = _u;
    vtmp  = _v;
    for(i=0; i<m; i++, arow+=_a_stride, pu++)
    {
        /*
         * update by two
         */
        for(j=0,pv=vtmp, dst=arow; j<n2; j++, dst+=2, pv+=2)
        {
            double ux  = pu[0].x;
            double uy  = pu[0].y;
            double v0x = pv[0].x;
            double v0y = pv[0].y;
            double v1x = pv[1].x;
            double v1y = pv[1].y;
            dst[0].x += ux*v0x-uy*v0y;
            dst[0].y += ux*v0y+uy*v0x;
            dst[1].x += ux*v1x-uy*v1y;
            dst[1].y += ux*v1y+uy*v1x;
        }

        /*
         * final update
         */
        if( n%2!=0 )
        {
            double ux = pu[0].x;
            double uy = pu[0].y;
            double vx = pv[0].x;
            double vy = pv[0].y;
            dst[0].x += ux*vx-uy*vy;
            dst[0].y += ux*vy+uy*vx;
        }
    }
    return ae_true;
}

// Assembly:
testq %rdi, %rdi
jle 0x31674
pushq %r14
pushq %rbx
movq %rsi, %rax
shrq $0x3f, %rax
addq %rsi, %rax
sarq %rax
xorl %r10d, %r10d
movapd 0x1c24(%rip), %xmm0     # 0x331b0
shlq $0x4, %rcx
movq %rdx, %r11
movq %r9, %rbx
cmpq $0x2, %rsi
jl 0x3161a
movq %rax, %r14
movq %r9, %rbx
movq %rdx, %r11
movsd (%r8), %xmm1
movsd 0x8(%r8), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
movupd (%rbx), %xmm3
movupd 0x10(%rbx), %xmm4
movapd %xmm3, %xmm5
mulpd %xmm2, %xmm5
shufpd $0x1, %xmm5, %xmm5      # xmm5 = xmm5[1,0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm3
addpd %xmm5, %xmm3
movupd (%r11), %xmm5
addpd %xmm3, %xmm5
movupd 0x10(%r11), %xmm3
movupd %xmm5, (%r11)
mulpd %xmm4, %xmm2
shufpd $0x1, %xmm2, %xmm2      # xmm2 = xmm2[1,0]
mulpd %xmm4, %xmm1
addpd %xmm2, %xmm1
addpd %xmm3, %xmm1
movupd %xmm1, 0x10(%r11)
addq $0x20, %r11
addq $0x20, %rbx
decq %r14
jne 0x315a5
testb $0x1, %sil
je 0x3165e
movsd (%r8), %xmm1
movsd 0x8(%r8), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
movupd (%rbx), %xmm4
unpcklpd %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
shufpd $0x1, %xmm4, %xmm4      # xmm4 = xmm4[1,0]
mulpd %xmm3, %xmm4
addpd %xmm4, %xmm1
movupd (%r11), %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, (%r11)
incq %r10
addq %rcx, %rdx
addq $0x10, %r8
cmpq %rdi, %r10
jne 0x31590
popq %rbx
popq %r14
movb $0x1, %al
retq