LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::setlength(long, long)
void alglib::ae_matrix_wrapper::setlength(ae_int_t rows, ae_int_t cols)
{
    if( p_mat==NULL )
        throw alglib::ap_error("ALGLIB: setlength() error, p_mat==NULL (array was not correctly initialized)");
    if( p_mat!=&mat )
        throw alglib::ap_error("ALGLIB: setlength() error, p_mat!=&mat (attempt to resize frozen array)");
    if( !ae_matrix_set_length(p_mat, rows, cols, NULL) )
        throw alglib::ap_error("ALGLIB: malloc error");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2a338
addq $0x10, %rax
cmpq %rax, %rdi
jne 0x2a354
xorl %ecx, %ecx
callq 0x23e0a
testb %al, %al
je 0x2a370
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x977e(%rip), %rsi      # 0x33ac8
movq %rax, %rdi
callq 0x26d2a
jmp 0x2a38a
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x97af(%rip), %rsi      # 0x33b15
movq %rax, %rdi
callq 0x26d2a
jmp 0x2a38a
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x9700(%rip), %rsi      # 0x33a82
movq %rax, %rdi
callq 0x26d2a
leaq 0x167ef(%rip), %rsi     # 0x40b80
leaq -0x17c80(%rip), %rdx    # 0x12718
movq %rbx, %rdi
callq 0x33b0
jmp 0x2a3a4
jmp 0x2a3a4
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %rax
cmpq %rsi, %rax
je 0x2a433
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
cmpq %rax, %rdi
jne 0x2a427
callq 0x23eed
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x9718(%rip), %rsi      # 0x33b5d
movq %rax, %rdi
callq 0x26d2a
leaq 0x1672c(%rip), %rsi     # 0x40b80
leaq -0x17d43(%rip), %rdx    # 0x12718
movq %rbx, %rdi
callq 0x33b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq 0x8(%rdi), %rdi
leaq 0x10(%r13), %r12
cmpq %r12, %rdi
jne 0x2a49d
callq 0x23eed
movq %r12, 0x8(%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x23baa
testb %al, %al
je 0x2a4c6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x95aa(%rip), %rsi      # 0x33a82
movq %rax, %rdi
callq 0x26d2a
leaq 0x16699(%rip), %rsi     # 0x40b80
leaq -0x17dd6(%rip), %rdx    # 0x12718
movq %rbx, %rdi
callq 0x33b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0x166b6(%rip), %rax     # 0x40c60
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x28e29
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2a6de
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
je 0x2a668
pushq $0x18
popq %r12
cqto
idivq %r12
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x3, %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a476
movq (%rsp), %rcx
xorl %r13d, %r13d
leaq 0x94b1(%rip), %r15      # 0x33ac2
movq 0x8(%rsp), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x2a677
imulq $0x18, %r13, %rbp
xorl %r14d, %r14d
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %rax, %r14
jae 0x2a663
movq (%rcx,%rbp), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x28fe3
movq 0x8(%rbx), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%r13,8), %rcx
movb %al, (%rcx,%r14)
incq %r14
movq (%rsp), %rcx
jmp 0x2a62a
incq %r13
jmp 0x2a611
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a476
movq 0x20(%rsp), %rdi
callq 0x236f7
movq %rsp, %rdi
callq 0x2ee9c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2a6be
jmp 0x2a69f
movq %rax, %rdi
callq 0x30e0
movq 0x20(%rsp), %rdi
callq 0x236f7
callq 0x3330
movq %rax, %r14
callq 0x3380
movq %rsp, %rdi
callq 0x2ee9c
movq %rbx, %rdi
callq 0x2a1b8
movq %r14, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a30c
xorl %eax, %eax
testq %r14, %r14
movl $0x0, %ecx
cmovgq %r14, %rcx
testq %r15, %r15
cmovleq %rax, %r15
cmpq %r15, %rax
je 0x2a920
movq 0x8(%r12), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x2a918
movb (%rbx,%rsi), %dil
movq 0x38(%rdx), %r8
movq (%r8,%rax,8), %r8
movb %dil, (%r8,%rsi)
incq %rsi
jmp 0x2a8fe
incq %rax
addq %r14, %rbx
jmp 0x2a8f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsi, %rdi
callq 0x2a3da
testb %al, %al
je 0x2a976
leaq 0x9224(%rip), %rsi      # 0x33b88
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ee42
jmp 0x2aa43
leaq 0x9210(%rip), %rsi      # 0x33b8d
leaq 0x8(%rsp), %rdi
callq 0x3440
xorl %ebp, %ebp
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x91f5(%rip), %r13      # 0x33b8f
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2a9a8
movq (%rax), %rcx
jmp 0x2a9aa
xorl %ecx, %ecx
cmpq %rcx, %rbp
jge 0x2a9ef
testq %rbp, %rbp
je 0x2a9c3
movq %r12, %rdi
movq %r13, %rsi
callq 0x3430
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdx
movq 0x38(%rax), %rax
movq (%rax,%rbp,8), %rsi
movq %r15, %rdi
callq 0x29212
movq %r12, %rdi
movq %r15, %rsi
callq 0x3460
movq %r15, %rdi
callq 0x3100
incq %rbp
jmp 0x2a99a
leaq 0x90cd(%rip), %rsi      # 0x33ac3
leaq 0x8(%rsp), %rdi
callq 0x3430
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2aa24
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2aa2a
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3100
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2aa74
jmp 0x2aa74
jmp 0x2aa74
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x2aa77
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0x16162(%rip), %rax     # 0x40c80
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x28e29
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2a6de
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
je 0x2abdc
pushq $0x18
popq %r12
cqto
idivq %r12
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x3, %rdx
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a476
movq (%rsp), %rcx
xorl %r13d, %r13d
leaq 0x8f3d(%rip), %r15      # 0x33ac2
movq 0x8(%rsp), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x2abeb
imulq $0x18, %r13, %rbp
xorl %r14d, %r14d
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %rax, %r14
jae 0x2abd7
movq (%rcx,%rbp), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2942d
movq 0x8(%rbx), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
movq (%rsp), %rcx
jmp 0x2ab9e
incq %r13
jmp 0x2ab85
pushq $0x2
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a476
movq 0x20(%rsp), %rdi
callq 0x236f7
movq %rsp, %rdi
callq 0x2ee9c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2ac32
jmp 0x2ac13
movq %rax, %rdi
callq 0x30e0
movq 0x20(%rsp), %rdi
callq 0x236f7
callq 0x3330
movq %rax, %r14
callq 0x3380
movq %rsp, %rdi
callq 0x2ee9c
movq %rbx, %rdi
callq 0x2a1b8
movq %r14, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a30c
xorl %eax, %eax
testq %r14, %r14
movl $0x0, %ecx
cmovgq %r14, %rcx
testq %r15, %r15
cmovleq %rax, %r15
shlq $0x3, %r14
cmpq %r15, %rax
je 0x2ad10
movq 0x8(%r12), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x2ad08
movq (%rbx,%rsi,8), %rdi
movq 0x38(%rdx), %r8
movq (%r8,%rax,8), %r8
movq %rdi, (%r8,%rsi,8)
incq %rsi
jmp 0x2acee
incq %rax
addq %r14, %rbx
jmp 0x2ace2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsi, %rdi
callq 0x2a3da
testb %al, %al
je 0x2ad66
leaq 0x8e34(%rip), %rsi      # 0x33b88
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ee42
jmp 0x2ae33
leaq 0x8e20(%rip), %rsi      # 0x33b8d
leaq 0x8(%rsp), %rdi
callq 0x3440
xorl %ebp, %ebp
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x8e05(%rip), %r13      # 0x33b8f
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2ad98
movq (%rax), %rcx
jmp 0x2ad9a
xorl %ecx, %ecx
cmpq %rcx, %rbp
jge 0x2addf
testq %rbp, %rbp
je 0x2adb3
movq %r12, %rdi
movq %r13, %rsi
callq 0x3430
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdx
movq 0x38(%rax), %rax
movq (%rax,%rbp,8), %rsi
movq %r15, %rdi
callq 0x2964a
movq %r12, %rdi
movq %r15, %rsi
callq 0x3460
movq %r15, %rdi
callq 0x3100
incq %rbp
jmp 0x2ad8a
leaq 0x8cdd(%rip), %rsi      # 0x33ac3
leaq 0x8(%rsp), %rdi
callq 0x3430
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2ae14
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2ae1a
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3100
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ae64
jmp 0x2ae64
jmp 0x2ae64
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x2ae67
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0x15d92(%rip), %rax     # 0x40ca0
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x28e29
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2a6de
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
je 0x2afce
pushq $0x18
popq %r12
cqto
idivq %r12
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x3, %rdx
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a476
movq (%rsp), %rcx
xorl %r13d, %r13d
leaq 0x8b4d(%rip), %r15      # 0x33ac2
movq 0x8(%rsp), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x2afdd
imulq $0x18, %r13, %rbp
xorl %r14d, %r14d
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %rax, %r14
jae 0x2afc9
movq (%rcx,%rbp), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x298ab
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movq (%rsp), %rcx
jmp 0x2af8e
incq %r13
jmp 0x2af75
pushq $0x3
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a476
movq 0x20(%rsp), %rdi
callq 0x236f7
movq %rsp, %rdi
callq 0x2ee9c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2b024
jmp 0x2b005
movq %rax, %rdi
callq 0x30e0
movq 0x20(%rsp), %rdi
callq 0x236f7
callq 0x3330
movq %rax, %r14
callq 0x3380
movq %rsp, %rdi
callq 0x2ee9c
movq %rbx, %rdi
callq 0x2a1b8
movq %r14, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a30c
xorl %eax, %eax
testq %r14, %r14
movl $0x0, %ecx
cmovgq %r14, %rcx
testq %r15, %r15
cmovleq %rax, %r15
shlq $0x3, %r14
cmpq %r15, %rax
je 0x2b104
movq 0x8(%r12), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x2b0fc
movsd (%rbx,%rsi,8), %xmm0
movq 0x38(%rdx), %rdi
movq (%rdi,%rax,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0x2b0e0
incq %rax
addq %r14, %rbx
jmp 0x2b0d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsi, %rdi
callq 0x2a3da
testb %al, %al
je 0x2b15c
leaq 0x8a3e(%rip), %rsi      # 0x33b88
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ee42
jmp 0x2b22d
movq %rbx, 0x20(%rsp)
leaq 0x8a25(%rip), %rsi      # 0x33b8d
movq %rsp, %rdi
callq 0x3440
xorl %ebx, %ebx
leaq 0x28(%rsp), %r15
movq %rsp, %r12
leaq 0x8a0e(%rip), %r13      # 0x33b8f
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2b18f
movq (%rax), %rcx
jmp 0x2b191
xorl %ecx, %ecx
cmpq %rcx, %rbx
jge 0x2b1d8
testq %rbx, %rbx
je 0x2b1aa
movq %r12, %rdi
movq %r13, %rsi
callq 0x3430
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdx
movq 0x38(%rax), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
movl %ebp, %ecx
callq 0x29a0c
movq %r12, %rdi
movq %r15, %rsi
callq 0x3460
movq %r15, %rdi
callq 0x3100
incq %rbx
jmp 0x2b181
leaq 0x88e4(%rip), %rsi      # 0x33ac3
movq %rsp, %rdi
callq 0x3430
movq 0x20(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2b20f
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2b215
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdx, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rsp, %rdi
callq 0x3100
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b25c
jmp 0x2b25c
jmp 0x2b25c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x2b25f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rcx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0x159bc(%rip), %rax     # 0x40cc0
movq %rcx, 0x8(%rsp)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
callq 0x28e29
leaq 0x10(%rsp), %rsi
movq %rax, 0x28(%rsp)
movq %rax, %rdi
callq 0x2a6de
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rcx, %rax
je 0x2b3e9
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x3, %rdx
pushq $0x4
popq %rcx
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2a476
movq 0x10(%rsp), %rcx
xorl %ebp, %ebp
leaq 0x874d(%rip), %r15      # 0x33ac2
leaq 0x30(%rsp), %r12
movq 0x18(%rsp), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rax, %rbp
jae 0x2b3fa
imulq $0x18, %rbp, %r14
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %rax, %rbx
jae 0x2b3e4
movq (%rcx,%r14), %rax
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x29dc1
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), %rcx
addq $0x10, %r13
jmp 0x2b398
incq %rbp
jmp 0x2b37a
pushq $0x4
popq %rcx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a476
movq 0x28(%rsp), %rdi
callq 0x236f7
leaq 0x10(%rsp), %rdi
callq 0x2ee9c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2b443
jmp 0x2b424
movq %rax, %rdi
callq 0x30e0
movq 0x28(%rsp), %rdi
callq 0x236f7
callq 0x3330
movq %rax, %r14
callq 0x3380
leaq 0x10(%rsp), %rdi
callq 0x2ee9c
movq 0x8(%rsp), %rdi
callq 0x2a1b8
movq %r14, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a30c
xorl %eax, %eax
testq %r14, %r14
movl $0x0, %ecx
cmovgq %r14, %rcx
testq %r15, %r15
cmovleq %rax, %r15
addq $0x8, %rbx
shlq $0x4, %r14
cmpq %r15, %rax
je 0x2b543
movq 0x8(%r12), %rdx
xorl %esi, %esi
movq %rcx, %rdi
subq $0x1, %rdi
jb 0x2b53b
movsd -0x8(%rbx,%rsi), %xmm0
movq 0x38(%rdx), %r8
movq (%r8,%rax,8), %r8
movsd %xmm0, (%r8,%rsi)
movsd (%rbx,%rsi), %xmm0
movq 0x38(%rdx), %r8
movq (%r8,%rax,8), %r8
movsd %xmm0, 0x8(%r8,%rsi)
addq $0x10, %rsi
jmp 0x2b507
incq %rax
addq %r14, %rbx
jmp 0x2b4f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsi, %rdi
callq 0x2a3da
testb %al, %al
je 0x2b59c
leaq 0x85fe(%rip), %rsi      # 0x33b88
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ee42
jmp 0x2b66d
movq %rbx, 0x20(%rsp)
leaq 0x85e5(%rip), %rsi      # 0x33b8d
movq %rsp, %rdi
callq 0x3440
xorl %ebx, %ebx
leaq 0x28(%rsp), %r15
movq %rsp, %r12
leaq 0x85ce(%rip), %r13      # 0x33b8f
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2b5cf
movq (%rax), %rcx
jmp 0x2b5d1
xorl %ecx, %ecx
cmpq %rcx, %rbx
jge 0x2b618
testq %rbx, %rbx
je 0x2b5ea
movq %r12, %rdi
movq %r13, %rsi
callq 0x3430
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdx
movq 0x38(%rax), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
movl %ebp, %ecx
callq 0x2a0da
movq %r12, %rdi
movq %r15, %rsi
callq 0x3460
movq %r15, %rdi
callq 0x3100
incq %rbx
jmp 0x2b5c1
leaq 0x84a4(%rip), %rsi      # 0x33ac3
movq %rsp, %rdi
callq 0x3430
movq 0x20(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2b64f
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2b655
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdx, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rsp, %rdi
callq 0x3100
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b69c
jmp 0x2b69c
jmp 0x2b69c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x2b69f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %rbx
testb %cl, %al
jne 0x2b736
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
sete %cl
pushq $0x1
popq %rdx
testb %cl, %al
je 0x2b6eb
movq %rdx, %rbx
jmp 0x2b736
movq %r15, %rax
orq %r14, %rax
jne 0x2b6f7
xorl %ebx, %ebx
jmp 0x2b736
xorl %r13d, %r13d
movsbl (%r15,%r13), %edi
movsbl (%r14,%r13), %ebp
testl %edi, %edi
je 0x2b72e
testb %bpl, %bpl
je 0x2b729
callq 0x3320
movl %eax, %r12d
movl %ebp, %edi
callq 0x3320
cmpl %eax, %r12d
jl 0x2b736
incq %r13
cmpl %eax, %r12d
jle 0x2b6fa
pushq $0x1
popq %rbx
jmp 0x2b736
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_O2/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 0x30a0
movl %eax, %ebx
callq 0x30a0
movl %eax, %ebp
cmpl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jne 0x2badc
callq 0x30a0
movl %eax, %ebx
jmp 0x2bac4
callq 0x30a0
movl %eax, %ebp
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0x2bad5
cvtsi2sd %ebx, %xmm1
cvtsi2sd %ebp, %xmm0
movsd 0x46e4(%rip), %xmm2     # 0x301d8
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
cmpq $0x1, %rdx
jne 0x2c2e3
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2c2f6
andq $0x0, (%rsi,%rcx,8)
incq %rcx
jmp 0x2c2d4
shlq $0x3, %rdx
subq $0x1, %rax
jb 0x2c2f6
andq $0x0, (%rsi)
addq %rdx, %rsi
jmp 0x2c2e7
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
cmpq $0x1, %rdx
jne 0x2c318
xorps %xmm0, %xmm0
subq $0x1, %rax
jb 0x2c32d
movups %xmm0, (%rsi)
addq $0x10, %rsi
jmp 0x2c309
shlq $0x4, %rdx
xorps %xmm0, %xmm0
subq $0x1, %rax
jb 0x2c32d
movups %xmm0, (%rsi)
addq %rdx, %rsi
jmp 0x2c31f
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c371
pushq $0x2
popq %r8
movq %rdi, %rax
cqto
idivq %r8
xorl %edx, %edx
subq $0x1, %rax
jb 0x2c398
movsd (%rsi,%rdx), %xmm0
movsd %xmm0, (%rcx,%rdx)
movsd 0x8(%rsi,%rdx), %xmm0
movsd %xmm0, 0x8(%rcx,%rdx)
addq $0x10, %rdx
jmp 0x2c34f
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
shlq $0x3, %r8
shlq $0x3, %rdx
subq $0x1, %rax
jb 0x2c3a8
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
addq %r8, %rcx
addq %rdx, %rsi
jmp 0x2c382
testb $0x1, %dil
je 0x2c3a8
movsd (%rsi,%rdx), %xmm0
movsd %xmm0, (%rcx,%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
shlq $0x4, %r8
cmpl $0x6e, %eax
jne 0x2c3ee
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
addq $0x8, %rcx
addq $0x8, %rsi
shlq $0x4, %rdx
subq $0x1, %rax
jb 0x2c42c
movsd -0x8(%rsi), %xmm0
movsd %xmm0, -0x8(%rcx)
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
addq %r8, %rcx
addq %rdx, %rsi
jmp 0x2c3ce
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
addq $0x8, %rcx
addq $0x8, %rsi
shlq $0x4, %rdx
movaps 0x3da6(%rip), %xmm0     # 0x301b0
subq $0x1, %rax
jb 0x2c42c
movsd -0x8(%rsi), %xmm1
movsd %xmm1, -0x8(%rcx)
movsd (%rsi), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rcx)
addq %r8, %rcx
addq %rdx, %rsi
jmp 0x2c40a
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
shlq $0x4, %rdx
shlq $0x4, %r8
cmpl $0x6e, %eax
jne 0x2c472
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
addq $0x8, %rcx
addq $0x8, %rsi
subq $0x1, %rax
jb 0x2c4ac
movsd -0x8(%rsi), %xmm0
movsd %xmm0, -0x8(%rcx)
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
addq %r8, %rcx
addq %rdx, %rsi
jmp 0x2c452
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
addq $0x8, %rcx
addq $0x8, %rsi
movaps 0x3d26(%rip), %xmm0     # 0x301b0
subq $0x1, %rax
jb 0x2c4ac
movsd -0x8(%rsi), %xmm1
movsd %xmm1, -0x8(%rcx)
movsd (%rsi), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rcx)
addq %r8, %rcx
addq %rdx, %rsi
jmp 0x2c48a
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r10
movabsq $0x2, %r11
movq %rsi, %rax
cqto
idivq %r11
xorl %edx, %edx
testq %rax, %rax
cmovleq %rdx, %rax
testq %rdi, %rdi
cmovgq %rdi, %rdx
testq %rcx, %rcx
je 0x2c532
xorl %ecx, %ecx
cmpq %rdx, %rcx
je 0x2c589
movq %rax, %rbx
movq %r10, %rdi
movq %r9, %r11
subq $0x1, %rbx
jb 0x2c516
movsd (%rdi), %xmm0
movsd %xmm0, (%r11)
movsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x100(%r11)
addq $0x200, %r11            # imm = 0x200
addq $0x10, %rdi
jmp 0x2c4ec
testb $0x1, %sil
je 0x2c525
movsd (%rdi), %xmm0
movsd %xmm0, (%r11)
incq %rcx
leaq (%r10,%r8,8), %r10
addq $0x8, %r9
jmp 0x2c4da
shlq $0x3, %r8
xorl %ecx, %ecx
cmpq %rdx, %rcx
je 0x2c589
xorl %edi, %edi
movq %rax, %r11
subq $0x1, %r11
jb 0x2c568
movsd (%r10,%rdi), %xmm0
movsd %xmm0, (%r9,%rdi)
movsd 0x8(%r10,%rdi), %xmm0
movsd %xmm0, 0x8(%r9,%rdi)
addq $0x10, %rdi
jmp 0x2c542
testb $0x1, %sil
je 0x2c57a
movsd (%r10,%rdi), %xmm0
movsd %xmm0, (%r9,%rdi)
incq %rcx
addq $0x100, %r9             # imm = 0x100
addq %r8, %r10
jmp 0x2c538
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r10
movabsq $0x2, %r11
movq %rsi, %rax
cqto
idivq %r11
xorl %edx, %edx
testq %rax, %rax
cmovleq %rdx, %rax
testq %rdi, %rdi
cmovgq %rdi, %rdx
testq %rcx, %rcx
je 0x2c610
xorl %ecx, %ecx
cmpq %rdx, %rcx
je 0x2c667
movq %rax, %rbx
movq %r10, %rdi
movq %r8, %r11
subq $0x1, %rbx
jb 0x2c5f4
movsd (%rdi), %xmm0
movsd %xmm0, (%r11)
movsd 0x100(%rdi), %xmm0
movsd %xmm0, 0x8(%r11)
addq $0x10, %r11
addq $0x200, %rdi            # imm = 0x200
jmp 0x2c5ca
testb $0x1, %sil
je 0x2c603
movsd (%rdi), %xmm0
movsd %xmm0, (%r11)
incq %rcx
addq $0x8, %r10
leaq (%r8,%r9,8), %r8
jmp 0x2c5b8
shlq $0x3, %r9
xorl %ecx, %ecx
cmpq %rdx, %rcx
je 0x2c667
xorl %edi, %edi
movq %rax, %r11
subq $0x1, %r11
jb 0x2c646
movsd (%r10,%rdi), %xmm0
movsd %xmm0, (%r8,%rdi)
movsd 0x8(%r10,%rdi), %xmm0
movsd %xmm0, 0x8(%r8,%rdi)
addq $0x10, %rdi
jmp 0x2c620
testb $0x1, %sil
je 0x2c658
movsd (%r10,%rdi), %xmm0
movsd %xmm0, (%r8,%rdi)
incq %rcx
addq $0x100, %r10            # imm = 0x100
addq %r9, %r8
jmp 0x2c616
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdx, %r10
movabsq $0x2, %r11
movq %rsi, %rax
cqto
idivq %r11
xorl %edx, %edx
testq %rax, %rax
cmovleq %rdx, %rax
testq %rdi, %rdi
cmovleq %rdx, %rdi
shlq $0x4, %rcx
movapd 0x2443(%rip), %xmm0     # 0x301b0
cmpq %rdi, %rdx
je 0x2de4f
xorl %r11d, %r11d
movq %rax, %rbx
subq $0x1, %rbx
jb 0x2ddf8
movsd (%r8), %xmm1
movsd 0x8(%r8), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
movupd (%r9,%r11), %xmm3
movupd 0x10(%r9,%r11), %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 (%r10,%r11), %xmm5
addpd %xmm3, %xmm5
movupd 0x10(%r10,%r11), %xmm3
movupd %xmm5, (%r10,%r11)
mulpd %xmm4, %xmm2
shufpd $0x1, %xmm2, %xmm2      # xmm2 = xmm2[1,0]
mulpd %xmm4, %xmm1
addpd %xmm2, %xmm1
addpd %xmm3, %xmm1
movupd %xmm1, 0x10(%r10,%r11)
addq $0x20, %r11
jmp 0x2dd7c
testb $0x1, %sil
je 0x2de40
movsd (%r8), %xmm1
movsd 0x8(%r8), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
movupd (%r9,%r11), %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 (%r10,%r11), %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, (%r10,%r11)
incq %rdx
addq $0x10, %r8
addq %rcx, %r10
jmp 0x2dd6d
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_pack_n2(double*, double*, long, long, double*)
void _ialglib_pack_n2(
    double *col0,
    double *col1,
    ae_int_t n,
    ae_int_t src_stride,
    double *dst)
{
    ae_int_t n2, j, stride2;
    
    /*
     * handle special case
     */
    if( col1==NULL )
    {
        for(j=0; j<n; j++)
        {
            dst[0] = *col0;
            dst[1] = 0.0;
            col0 += src_stride;
            dst  += 2;
        }
        return;
    }

    /*
     * handle general case
     */
    n2 = n/2;
    stride2 = src_stride*2;
    for(j=0; j<n2; j++)
    {
        dst[0] = *col0;
        dst[1] = *col1;
        dst[2] = col0[src_stride];
        dst[3] = col1[src_stride];
        col0 += stride2;
        col1 += stride2;
        dst  += 4;
    }
    if( n%2 )
    {
        dst[0] = *col0;
        dst[1] = *col1;
    }
}

// Assembly:
movq %rdx, %r9
testq %rsi, %rsi
je 0x2e3f3
pushq $0x2
popq %r10
movq %r9, %rax
cqto
idivq %r10
xorl %edx, %edx
testq %rax, %rax
cmovgq %rax, %rdx
movq %rcx, %rax
shlq $0x4, %rax
subq $0x1, %rdx
jb 0x2e3d9
movsd (%rdi), %xmm0
movsd %xmm0, (%r8)
movsd (%rsi), %xmm0
movsd %xmm0, 0x8(%r8)
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, 0x10(%r8)
movsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, 0x18(%r8)
addq $0x20, %r8
addq %rax, %rsi
addq %rax, %rdi
jmp 0x2e39e
testb $0x1, %r9b
je 0x2e3f2
movsd (%rdi), %xmm0
movsd %xmm0, (%r8)
movsd (%rsi), %xmm0
movsd %xmm0, 0x8(%r8)
retq
xorl %eax, %eax
testq %r9, %r9
cmovgq %r9, %rax
shlq $0x3, %rcx
subq $0x1, %rax
jb 0x2e3f2
movsd (%rdi), %xmm0
movsd %xmm0, (%r8)
andq $0x0, 0x8(%r8)
addq $0x10, %r8
addq %rcx, %rdi
jmp 0x2e400
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_split_length(long, long, long*, long*)
static void x_split_length(ae_int_t n, ae_int_t nb, ae_int_t* n1, ae_int_t* n2)
{
    ae_int_t r;
    if( n<=nb )
    {
        *n1 = n;
        *n2 = 0;
    }
    else
    {
        if( n%nb!=0 )
        {
            *n2 = n%nb;
            *n1 = n-(*n2);
        }
        else
        {
            *n2 = n/2;
            *n1 = n-(*n2);
            if( *n1%nb==0 )
            {
                return;
            }
            r = nb-*n1%nb;
            *n1 = *n1+r;
            *n2 = *n2-r;
        }
    }
}

// Assembly:
movq %rdx, %rcx
cmpq $0x10, %rdi
jg 0x2e5eb
movq %rdi, (%rsi)
andq $0x0, (%rcx)
retq
movq %rdi, %rax
andq $0xf, %rax
je 0x2e608
movq %rax, (%rcx)
movabsq $0x7ffffffffffffff0, %rax # imm = 0x7FFFFFFFFFFFFFF0
andq %rax, %rdi
movq %rdi, (%rsi)
retq
movq %rdi, %rax
shrq %rax
movq %rax, (%rcx)
subq %rax, %rdi
movq %rdi, (%rsi)
pushq $0x10
popq %r8
movq %rdi, %rax
cqto
idivq %r8
testq %rdx, %rdx
je 0x2e634
subq %rdx, %r8
addq %r8, %rdi
movq %rdi, (%rsi)
subq %r8, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_safepythag2(double, double)
static double x_safepythag2(double x, double y)
{
    double w;
    double xabs;
    double yabs;
    double z;
    xabs = fabs(x);
    yabs = fabs(y);
    w = xabs>yabs ? xabs : yabs;
    z = xabs<yabs ? xabs : yabs;
    if( z==0 )
        return w;
    else
    {
        double t;
        t = z/w;
        return w*sqrt(1+t*t);
    }
}

// Assembly:
movapd %xmm0, %xmm2
movapd 0x4693(%rip), %xmm0     # 0x33210
andpd %xmm0, %xmm2
andpd %xmm0, %xmm1
movapd %xmm2, %xmm0
maxsd %xmm1, %xmm0
minsd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x2eb9e
jp 0x2eb9e
retq
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
addsd 0x164a(%rip), %xmm2     # 0x301f8
sqrtsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
retq