LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15662(%rip), %rcx     # 0x43ca0
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2c032
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2dca5
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
subq %rax, %rsi
je 0x2e729
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 0x2d9c2
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x2e73a
xorl %r13d, %r13d
leaq 0x9298(%rip), %r15      # 0x37952
movq (%rsp), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x2e70e
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r14d, %r14d
movq (%rax,%rbp,8), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2cbfa
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x2e6d5
movq 0x8(%rsp), %rax
subq (%rsp), %rax
incq %r13
sarq $0x3, %rax
imulq %r12, %rax
cmpq %rax, %r13
jb 0x2e6ba
jmp 0x2e73a
movl $0x3, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d9c2
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2e74d
movq -0x8(%rax), %rdi
callq 0x32e0
movq %rsp, %rdi
callq 0x33526
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2e793
jmp 0x2e76b
movq %rax, %rdi
callq 0x3100
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2e786
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq %rsp, %rdi
callq 0x33526
movq %rbx, %rdi
callq 0x2d654
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d820
testq %r15, %r15
jle 0x2e86d
movq 0x8(%r12), %rax
leaq (,%r14,8), %rcx
xorl %edx, %edx
testq %r14, %r14
jle 0x2e862
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 0x2e848
incq %rdx
addq %rcx, %rbx
cmpq %r15, %rdx
jne 0x2e841
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e971
cmpq $0x0, (%rax)
je 0x2e971
cmpq $0x0, 0x8(%rax)
je 0x2e971
movl %edx, %ebp
movq %rsi, %r14
movq %r15, 0x20(%rsp)
leaq 0x914b(%rip), %rcx      # 0x37a1d
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
leaq 0x38(%rsp), %r13
xorl %ebx, %ebx
leaq 0x28(%rsp), %r15
movq %rsp, %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e901
movq (%rax), %rax
jmp 0x2e903
xorl %eax, %eax
cmpq %rax, %rbx
jge 0x2e990
testq %rbx, %rbx
je 0x2e920
movq %r12, %rdi
leaq 0x9104(%rip), %rsi      # 0x37a1f
callq 0x3470
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e92f
movq 0x8(%rax), %rdx
jmp 0x2e931
xorl %edx, %edx
movq 0x38(%rax), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
movl %ebp, %ecx
callq 0x2cd67
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e96c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %rbx
jmp 0x2e8f3
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq 0x9099(%rip), %rsi      # 0x37a18
leaq 0x9096(%rip), %rdx      # 0x37a1c
movq %r15, %rdi
callq 0x33574
jmp 0x2e9e8
leaq 0x8fbc(%rip), %rsi      # 0x37953
movq %rsp, %rdi
callq 0x3470
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rbx
cmpq %rbx, %rcx
je 0x2e9c7
movq %rcx, (%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
jmp 0x2e9cd
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r15)
movq %rbx, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2e9fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ea32
jmp 0x2ea32
jmp 0x2ea32
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ea35
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2ea35
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2ea50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/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 0x151d1(%rip), %rcx     # 0x43cc0
movq %rdi, 0x8(%rsp)
movq %rcx, (%rdi)
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rsi, %rdi
callq 0x2c032
leaq 0x10(%rsp), %rsi
movq %rax, 0x30(%rsp)
movq %rax, %rdi
callq 0x2dca5
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rsi
subq %rax, %rsi
je 0x2ec1f
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 0x2d9c2
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2ec32
xorl %ebp, %ebp
leaq 0x8ddc(%rip), %r15      # 0x37952
leaq 0x38(%rsp), %r12
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x2ebf5
movl $0x8, %r14d
leaq (,%rbp,2), %r13
addq %rbp, %r13
xorl %ebx, %ebx
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x2d1e4
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq (%rax,%rbp,8), %rax
movsd 0x38(%rsp), %xmm0
movsd %xmm0, -0x8(%rax,%r14)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rax,%r14)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
incq %rbx
sarq $0x3, %rcx
addq $0x10, %r14
cmpq %rcx, %rbx
jb 0x2eb9c
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
incq %rbp
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %rbp
jb 0x2eb7b
jmp 0x2ec32
movl $0x4, %ecx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d9c2
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2ec45
movq -0x8(%rax), %rdi
callq 0x32e0
leaq 0x10(%rsp), %rdi
callq 0x33526
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2ec8d
jmp 0x2ec65
movq %rax, %rdi
callq 0x3100
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2ec80
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
leaq 0x10(%rsp), %rdi
callq 0x33526
movq 0x8(%rsp), %rdi
callq 0x2d654
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d820
testq %r15, %r15
jle 0x2ed84
movq 0x8(%r12), %rax
addq $0x8, %rbx
movq %r14, %rcx
shlq $0x4, %rcx
xorl %edx, %edx
testq %r14, %r14
jle 0x2ed79
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 0x2ed48
incq %rdx
addq %rcx, %rbx
cmpq %r15, %rdx
jne 0x2ed3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ee87
cmpq $0x0, (%rax)
je 0x2ee87
cmpq $0x0, 0x8(%rax)
je 0x2ee87
movl %edx, %ebp
movq %rsi, %r14
movq %r15, 0x20(%rsp)
leaq 0x8c35(%rip), %rcx      # 0x37a1d
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
leaq 0x38(%rsp), %r13
xorl %ebx, %ebx
leaq 0x28(%rsp), %r15
movq %rsp, %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2ee17
movq (%rax), %rax
jmp 0x2ee19
xorl %eax, %eax
cmpq %rax, %rbx
jge 0x2eea6
testq %rbx, %rbx
je 0x2ee36
movq %r12, %rdi
leaq 0x8bee(%rip), %rsi      # 0x37a1f
callq 0x3470
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2ee45
movq 0x8(%rax), %rdx
jmp 0x2ee47
xorl %edx, %edx
movq 0x38(%rax), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
movl %ebp, %ecx
callq 0x2d529
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ee82
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %rbx
jmp 0x2ee09
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq 0x8b83(%rip), %rsi      # 0x37a18
leaq 0x8b80(%rip), %rdx      # 0x37a1c
movq %r15, %rdi
callq 0x33574
jmp 0x2eefe
leaq 0x8aa6(%rip), %rsi      # 0x37953
movq %rsp, %rdi
callq 0x3470
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rbx
cmpq %rbx, %rcx
je 0x2eedd
movq %rcx, (%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
jmp 0x2eee3
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r15)
movq %rbx, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2ef14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ef48
jmp 0x2ef48
jmp 0x2ef48
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ef4b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2ef4b
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2ef66
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2eff5
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
sete %cl
testb %cl, %al
je 0x2efad
movl $0x1, %ebx
jmp 0x2eff5
movq %r15, %rax
orq %r14, %rax
jne 0x2efb9
xorl %ebx, %ebx
jmp 0x2eff5
xorl %r13d, %r13d
movsbl (%r15,%r13), %edi
movsbl (%r14,%r13), %ebp
testl %edi, %edi
je 0x2efed
testb %bpl, %bpl
je 0x2efa6
callq 0x3350
movl %eax, %r12d
movl %ebp, %edi
callq 0x3350
cmpl %eax, %r12d
jl 0x2eff5
incq %r13
cmpl %eax, %r12d
jle 0x2efbc
jmp 0x2efa6
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_O1/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 0x2f3be
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x2f3b0
movl %eax, %ebx
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0x2f3d4
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x2f3c6
movl %eax, %ebp
cvtsi2sd %ebx, %xmm1
cvtsi2sd %ebp, %xmm0
movsd 0x4db4(%rip), %xmm2     # 0x34198
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_mv_32(double const*, double const*, double*, long, double, double)
void _ialglib_mv_32(const double *a, const double *x, double *y, ae_int_t stride, double alpha, double beta)
{
    ae_int_t i, k;
    const double *pa0, *pa1, *pb;

    pa0 = a;
    pa1 = a+alglib_r_block;
    pb = x;
    for(i=0; i<16; i++)
    {
        double v0 = 0, v1 = 0;
        for(k=0; k<4; k++)
        {
            v0 += pa0[0]*pb[0];
            v1 += pa1[0]*pb[0];
            v0 += pa0[1]*pb[1];
            v1 += pa1[1]*pb[1];
            v0 += pa0[2]*pb[2];
            v1 += pa1[2]*pb[2];
            v0 += pa0[3]*pb[3];
            v1 += pa1[3]*pb[3];
            v0 += pa0[4]*pb[4];
            v1 += pa1[4]*pb[4];
            v0 += pa0[5]*pb[5];
            v1 += pa1[5]*pb[5];
            v0 += pa0[6]*pb[6];
            v1 += pa1[6]*pb[6];
            v0 += pa0[7]*pb[7];
            v1 += pa1[7]*pb[7];
            pa0 += 8;
            pa1 += 8;
            pb  += 8;
        }
        y[0] = beta*y[0]+alpha*v0;
        y[stride] = beta*y[stride]+alpha*v1;

        /*
         * now we've processed rows I and I+1,
         * pa0 and pa1 are pointing to rows I+1 and I+2.
         * move to I+2 and I+3.
         */
        pa0 += alglib_r_block;
        pa1 += alglib_r_block;
        pb = x;
        y+=2*stride;
    }
}

// Assembly:
movq %rcx, %rax
shlq $0x4, %rax
xorl %r8d, %r8d
xorpd %xmm2, %xmm2
xorl %r9d, %r9d
xorpd %xmm3, %xmm3
movsd (%rsi,%r9), %xmm4
movsd 0x8(%rsi,%r9), %xmm5
movsd (%rdi,%r9), %xmm6
mulsd %xmm4, %xmm6
mulsd 0x100(%rdi,%r9), %xmm4
addsd %xmm3, %xmm6
addsd %xmm2, %xmm4
movsd 0x8(%rdi,%r9), %xmm2
mulsd %xmm5, %xmm2
addsd %xmm6, %xmm2
mulsd 0x108(%rdi,%r9), %xmm5
addsd %xmm4, %xmm5
movsd 0x10(%rsi,%r9), %xmm3
movsd 0x10(%rdi,%r9), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm2, %xmm4
mulsd 0x110(%rdi,%r9), %xmm3
addsd %xmm5, %xmm3
movsd 0x18(%rsi,%r9), %xmm2
movsd 0x18(%rdi,%r9), %xmm5
mulsd %xmm2, %xmm5
mulsd 0x118(%rdi,%r9), %xmm2
addsd %xmm4, %xmm5
addsd %xmm3, %xmm2
movsd 0x20(%rsi,%r9), %xmm3
movsd 0x20(%rdi,%r9), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm5, %xmm4
mulsd 0x120(%rdi,%r9), %xmm3
addsd %xmm2, %xmm3
movsd 0x28(%rsi,%r9), %xmm2
movsd 0x28(%rdi,%r9), %xmm5
mulsd %xmm2, %xmm5
addsd %xmm4, %xmm5
mulsd 0x128(%rdi,%r9), %xmm2
addsd %xmm3, %xmm2
movsd 0x30(%rsi,%r9), %xmm4
movsd 0x30(%rdi,%r9), %xmm6
mulsd %xmm4, %xmm6
addsd %xmm5, %xmm6
mulsd 0x130(%rdi,%r9), %xmm4
addsd %xmm2, %xmm4
movsd 0x38(%rsi,%r9), %xmm2
movsd 0x38(%rdi,%r9), %xmm3
mulsd %xmm2, %xmm3
mulsd 0x138(%rdi,%r9), %xmm2
addsd %xmm6, %xmm3
addsd %xmm4, %xmm2
addq $0x40, %r9
cmpq $0x100, %r9             # imm = 0x100
jne 0x2f554
addq $0x200, %rdi            # imm = 0x200
mulsd %xmm0, %xmm3
movsd (%rdx), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rdx)
mulsd %xmm0, %xmm2
movsd (%rdx,%rcx,8), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rdx,%rcx,8)
addq %rax, %rdx
incq %r8
cmpq $0x10, %r8
jne 0x2f549
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fc7d
pushq %rbx
movq 0x10(%rsp), %rax
shlq $0x4, %rax
xorl %r10d, %r10d
testq %rsi, %rsi
jle 0x2fba9
xorpd %xmm5, %xmm5
xorl %r11d, %r11d
movq %rsi, %rbx
xorpd %xmm7, %xmm7
movsd (%rcx,%r11), %xmm8
movsd 0x8(%rcx,%r11), %xmm9
movsd (%rdx,%r11), %xmm10
movsd 0x8(%rdx,%r11), %xmm6
movapd %xmm10, %xmm4
mulsd %xmm8, %xmm4
addsd %xmm7, %xmm4
mulsd %xmm9, %xmm10
addsd %xmm5, %xmm10
mulsd %xmm6, %xmm9
subsd %xmm9, %xmm4
mulsd %xmm8, %xmm6
addsd %xmm10, %xmm6
addq $0x10, %r11
movapd %xmm6, %xmm5
movapd %xmm4, %xmm7
decq %rbx
jne 0x2fb50
jmp 0x2fbb1
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
movapd %xmm0, %xmm7
mulsd %xmm6, %xmm7
mulsd %xmm1, %xmm6
movapd %xmm0, %xmm5
mulsd %xmm4, %xmm5
subsd %xmm6, %xmm5
mulsd %xmm1, %xmm4
addsd %xmm7, %xmm4
testq %r8, %r8
je 0x2fc1f
movsd (%r8), %xmm6
movsd 0x8(%r8), %xmm7
movapd %xmm7, %xmm8
mulsd %xmm3, %xmm8
movapd %xmm2, %xmm9
mulsd %xmm6, %xmm9
subsd %xmm8, %xmm9
addsd %xmm9, %xmm5
mulsd %xmm3, %xmm6
mulsd %xmm2, %xmm7
addsd %xmm6, %xmm7
addsd %xmm7, %xmm4
movsd %xmm5, (%r8)
movsd %xmm4, 0x8(%r8)
addq %rax, %r8
jmp 0x2fc69
movsd (%r9), %xmm6
movsd 0x8(%r9), %xmm7
movapd %xmm7, %xmm8
mulsd %xmm3, %xmm8
movapd %xmm2, %xmm9
mulsd %xmm6, %xmm9
subsd %xmm8, %xmm9
addsd %xmm9, %xmm5
mulsd %xmm3, %xmm6
mulsd %xmm2, %xmm7
addsd %xmm6, %xmm7
addsd %xmm7, %xmm4
movsd %xmm5, (%r9)
movsd %xmm4, 0x8(%r9)
addq %rax, %r9
xorl %r8d, %r8d
addq $0x180, %rdx            # imm = 0x180
incq %r10
cmpq %rdi, %r10
jne 0x2fb3d
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fc9d
testq %rax, %rax
jle 0x2fcb5
shlq $0x3, %rax
movq %rsi, %rdi
xorl %esi, %esi
movq %rax, %rdx
jmp 0x3170
testq %rax, %rax
jle 0x2fcb5
shlq $0x3, %rdx
movq $0x0, (%rsi)
addq %rdx, %rsi
decq %rax
jne 0x2fca6
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fcd5
testq %rax, %rax
jle 0x2fcec
shlq $0x4, %rax
movq %rsi, %rdi
xorl %esi, %esi
movq %rax, %rdx
jmp 0x3170
testq %rax, %rax
jle 0x2fcec
shlq $0x4, %rdx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
addq %rdx, %rsi
decq %rax
jne 0x2fce1
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fd45
leaq 0x1(%rdi), %rax
cmpq $0x3, %rax
jb 0x2fd36
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 0x2fd17
testb $0x1, %dil
je 0x2fd65
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
retq
testq %rdi, %rdi
jle 0x2fd65
shlq $0x3, %rdx
shlq $0x3, %r8
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx)
addq %rdx, %rsi
addq %r8, %rcx
decq %rdi
jne 0x2fd52
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fda6
testq %rdi, %rdi
jle 0x2fde1
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 0x2fd87
jmp 0x2fde1
testq %rdi, %rdi
jle 0x2fde1
shlq $0x4, %r8
addq $0x8, %rsi
shlq $0x4, %rdx
addq $0x8, %rcx
movaps 0x441e(%rip), %xmm0     # 0x341e0
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 0x2fdc2
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fe22
testq %rdi, %rdi
jle 0x2fe5d
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 0x2fe03
jmp 0x2fe5d
testq %rdi, %rdi
jle 0x2fe5d
shlq $0x4, %rdx
shlq $0x4, %r8
addq $0x8, %rsi
addq $0x8, %rcx
movaps 0x43a2(%rip), %xmm0     # 0x341e0
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 0x2fe3e
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fedc
testq %rdi, %rdi
jle 0x2ff3e
xorl %ecx, %ecx
movq %rdx, %r11
movq %r9, %r10
cmpq $0x2, %rsi
jl 0x2feba
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 0x2fe91
testb $0x1, %sil
je 0x2feca
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
leaq (%rdx,%r8,8), %rdx
addq $0x8, %r9
cmpq %rdi, %rcx
jne 0x2fe7c
jmp 0x2ff3e
testq %rdi, %rdi
jle 0x2ff3e
xorl %ecx, %ecx
movq %rdx, %r11
movq %r9, %r10
cmpq $0x2, %rsi
jl 0x2ff1b
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 0x2fef8
testb $0x1, %sil
je 0x2ff2b
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
leaq (%rdx,%r8,8), %rdx
addq $0x100, %r9             # imm = 0x100
cmpq %rdi, %rcx
jne 0x2fee3
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ffbe
testq %rdi, %rdi
jle 0x30020
xorl %ecx, %ecx
movq %rdx, %r11
movq %r8, %r10
cmpq $0x2, %rsi
jl 0x2ff9c
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 0x2ff73
testb $0x1, %sil
je 0x2ffac
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
addq $0x8, %rdx
leaq (%r8,%r9,8), %r8
cmpq %rdi, %rcx
jne 0x2ff5e
jmp 0x30020
testq %rdi, %rdi
jle 0x30020
xorl %ecx, %ecx
movq %rdx, %r11
movq %r8, %r10
cmpq $0x2, %rsi
jl 0x2fffd
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 0x2ffda
testb $0x1, %sil
je 0x3000d
movsd (%r11), %xmm0
movsd %xmm0, (%r10)
incq %rcx
addq $0x100, %rdx            # imm = 0x100
leaq (%r8,%r9,8), %r8
cmpq %rdi, %rcx
jne 0x2ffc5
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x322c7
pushq %r14
pushq %rbx
movq %rsi, %rax
shrq $0x3f, %rax
addq %rsi, %rax
sarq %rax
xorl %r10d, %r10d
shlq $0x4, %rcx
movq %rdx, %r11
movq %r9, %rbx
cmpq $0x2, %rsi
jl 0x32265
movq %rax, %r14
movq %r9, %rbx
movq %rdx, %r11
movsd (%r8), %xmm0
movsd 0x8(%r8), %xmm1
movsd (%rbx), %xmm3
movsd 0x8(%rbx), %xmm4
movsd 0x10(%rbx), %xmm2
movapd %xmm0, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm6
mulsd %xmm3, %xmm6
subsd %xmm4, %xmm6
addsd (%r11), %xmm6
movsd 0x18(%rbx), %xmm4
movsd %xmm6, (%r11)
mulsd %xmm1, %xmm3
addsd %xmm5, %xmm3
addsd 0x8(%r11), %xmm3
movsd %xmm3, 0x8(%r11)
movapd %xmm0, %xmm3
mulsd %xmm4, %xmm0
mulsd %xmm1, %xmm4
mulsd %xmm2, %xmm3
subsd %xmm4, %xmm3
addsd 0x10(%r11), %xmm3
movsd %xmm3, 0x10(%r11)
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addsd 0x18(%r11), %xmm0
movsd %xmm0, 0x18(%r11)
addq $0x20, %r11
addq $0x20, %rbx
decq %r14
jne 0x321cc
testb $0x1, %sil
je 0x322b1
movsd (%r8), %xmm0
movsd 0x8(%r8), %xmm1
movsd (%rbx), %xmm2
movsd 0x8(%rbx), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm0
mulsd %xmm1, %xmm3
mulsd %xmm2, %xmm4
subsd %xmm3, %xmm4
addsd (%r11), %xmm4
movsd %xmm4, (%r11)
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addsd 0x8(%r11), %xmm0
movsd %xmm0, 0x8(%r11)
incq %r10
addq %rcx, %rdx
addq $0x10, %r8
cmpq %rdi, %r10
jne 0x321b3
popq %rbx
popq %r14
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/examples/format-traits-ex01.cxx
// Function: main
int main() {
    std::map<int, int> map;
        cxon::from_bytes<UQK>(map, R"({1: 2, 3: 4})");
    assert(map == (std::map<int, int> {{1, 2}, {3, 4}}));
    std::string str;
        cxon::to_bytes<UQK>(str, map);
    assert(str == R"({1:2,3:4})");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x80(%rsp), %r14
xorl %eax, %eax
movl %eax, (%r14)
movq %rax, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rax, 0x20(%r14)
leaq 0xd26(%rip), %rcx       # 0x3044
leaq 0x50(%rsp), %r15
movq %rcx, (%r15)
leaq 0x60(%rsp), %r12
movl %eax, (%r12)
callq 0x2080
movq %rax, %rbx
movq %rax, 0x8(%r12)
leaq 0xd0e(%rip), %rsi       # 0x3051
leaq 0x58(%rsp), %rax
movq %rsi, (%rax)
leaq 0x78(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq %r12, 0x38(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x2608
cmpl $0x0, 0x60(%rsp)
setne %cl
xorb %cl, %al
je 0x2499
movaps 0xc77(%rip), %xmm0      # 0x3010
leaq 0x60(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x50(%rsp), %r8
movl $0x2, %edx
callq 0x2530
movq 0xa0(%rsp), %rax
cmpq 0x48(%rsp), %rax
jne 0x247a
movq 0x90(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq %r14, %rsi
callq 0x2d16
testb %al, %al
je 0x247a
leaq 0x20(%rsp), %rdi
callq 0x25be
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x60(%rsp), %rdx
movl $0x0, (%rdx)
movq %rbx, 0x8(%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x2d82
cmpl $0x0, 0x60(%rsp)
setne %cl
xorb %cl, %al
je 0x24b8
leaq 0xc62(%rip), %rsi       # 0x30a0
leaq 0x20(%rsp), %rdi
callq 0x2060
testl %eax, %eax
jne 0x24d7
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x245f
callq 0x2100
leaq 0x78(%rsp), %rdi
callq 0x25be
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xbd0(%rip), %rdi       # 0x3051
leaq 0xbf6(%rip), %rsi       # 0x307e
leaq 0xc06(%rip), %rcx       # 0x3095
movl $0x11, %edx
callq 0x20a0
leaq 0xc20(%rip), %rdi       # 0x30c0
leaq 0xc26(%rip), %rsi       # 0x30cd
leaq 0xc34(%rip), %rcx       # 0x30e2
movl $0xbd, %edx
callq 0x20a0
leaq 0xc01(%rip), %rdi       # 0x30c0
leaq 0xc07(%rip), %rsi       # 0x30cd
leaq 0xdb8(%rip), %rcx       # 0x3285
movl $0xe6, %edx
callq 0x20a0
leaq 0xbcc(%rip), %rdi       # 0x30aa
leaq 0xb99(%rip), %rsi       # 0x307e
leaq 0xba9(%rip), %rcx       # 0x3095
movl $0x14, %edx
callq 0x20a0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x251e
callq 0x2100
jmp 0x251e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x25be
jmp 0x251e
jmp 0x251b
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x25be
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/getrandom.cpp
// Function: main
int main(int argc, char *argv[])
{
	char buf[256] = {0};
	ssize_t size;

	if (argc > 1)
	{
		size = getrandom(buf, 256, 0);
	}
	else
	{
		printf("Using /dev/random, may block add a parameter to use /dev/urandom\r\n");
		size = getrandom(buf, 256, GRND_RANDOM);
	}

	if (size > 0)
	{
		for (int i = 0; i < size; i++)
		{
			printf("%02X", (unsigned int)buf[i]);
		}
		printf("\r\n");
	}
	else
	{
		printf("getrandom() returned %d try again later\r\n", (int)size);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edi, %r14d
leaq -0x120(%rbp), %rdi
xorl %ebx, %ebx
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1050
cmpl $0x1, %r14d
jg 0x11ab
leaq 0xe92(%rip), %rdi       # 0x2033
callq 0x1060
movl $0x2, %ebx
leaq -0x120(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl %ebx, %edx
callq 0x1040
movq %rax, %rbx
testq %rax, %rax
jle 0x11f9
leaq 0xe37(%rip), %r14       # 0x2004
xorl %r15d, %r15d
movsbl -0x120(%rbp,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incq %r15
cmpq %r15, %rbx
jne 0x11d0
leaq 0xe81(%rip), %rdi       # 0x2073
callq 0x1060
jmp 0x1209
leaq 0xe09(%rip), %rdi       # 0x2009
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: table_rehash(table*)
void table_rehash(table *table) {
	uint32_t old_bins = table->bins;
	uint32_t i, mask, pos;
	entry **pe, *e;
	table->bins = old_bins == 0 ? 8 : old_bins * 2;
	mask = table->bins - 1;
	table->entries = (entry**)realloc(table->entries, table->bins*sizeof(entry*));
	memset(table->entries+old_bins, 0, sizeof(entry*)*(table->bins - old_bins));
	assert(table->entries != NULL);
	for (i = 0; i < old_bins; i++) {
		pe = &table->entries[i];
		while (*pe != NULL) {
			e = *pe;
			pos = e->hash & mask;
			if (pos != i) {
				*pe = e->next;
				e->next = table->entries[pos];
				table->entries[pos] = e;
			} else {
				pe = &e->next;
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %r15d
leal (%r15,%r15), %eax
testq %r15, %r15
movl $0x8, %r12d
cmovnel %eax, %r12d
movl %r12d, 0x4(%rdi)
movq 0x8(%rdi), %rdi
leaq (,%r12,8), %rsi
callq 0x2240
movq %rax, %r14
movq %rax, 0x8(%rbx)
leaq (%rax,%r15,8), %rdi
movl 0x4(%rbx), %edx
subl %r15d, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x20c0
testq %r14, %r14
je 0x2455
testq %r15, %r15
je 0x2449
decl %r12d
xorl %eax, %eax
movq 0x8(%rbx), %rdx
movq (%rdx,%rax,8), %rcx
testq %rcx, %rcx
je 0x2441
leaq (%rdx,%rax,8), %rdx
movl (%rcx), %esi
andl %r12d, %esi
cmpq %rsi, %rax
jne 0x2420
addq $0x8, %rcx
movq %rcx, %rdx
jmp 0x2439
movq 0x8(%rcx), %rdi
movq %rdi, (%rdx)
movq 0x8(%rbx), %rdi
movl %esi, %esi
movq (%rdi,%rsi,8), %r8
movq %r8, 0x8(%rcx)
movq %rcx, (%rdi,%rsi,8)
movq (%rdx), %rcx
testq %rcx, %rcx
jne 0x240d
incq %rax
cmpq %r15, %rax
jne 0x23fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1c05(%rip), %rdi      # 0x4061
leaq 0x1c15(%rip), %rsi      # 0x4078
leaq 0x1c1e(%rip), %rcx      # 0x4088
movl $0x26, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: table_insert(table*, char const*, unsigned long)
void table_insert(table *table, const char* str, size_t len) {
	uint64_t hash;
	uint32_t pos;
	entry* en;
	/* lets fill factor to be 3x, so it will be easier to get collisions */
	if (table->size == table->bins) {
		table_rehash(table);
	}
	hash = hashsum(str, len);
	pos = (uint32_t)hash & (table->bins - 1);
	en = table->entries[pos];
	while (en != NULL) {
		if (en->hash == hash && en->len == len && memcmp(en->str, str, len) == 0) {
			/* found match */
			return;
		}
		en = en->next;
	}
	en = (entry*)malloc(sizeof(entry) + len);
	en->hash = hash;
	en->next = table->entries[pos];
	en->len = len;
	memcpy(en->str, str, len);
	en->str[len] = 0;
	table->entries[pos] = en;
	table->size++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
jne 0x2497
movq %rbx, %rdi
callq 0x239c
movq 0x4cb2(%rip), %rdx      # 0x7150
cmpb $0x0, 0x4ce3(%rip)      # 0x7188
je 0x24bd
movl 0x4cab(%rip), %ecx      # 0x7158
movq %r15, %rdi
movq %r14, %rsi
callq 0x3151
movl %eax, %r12d
jmp 0x24d2
movq 0x4c94(%rip), %rcx      # 0x7158
movq %r15, %rdi
movq %r14, %rsi
callq 0x2feb
movq %rax, %r12
movl 0x4(%rbx), %ebp
decl %ebp
andl %r12d, %ebp
movq 0x8(%rbx), %rax
movq %rax, (%rsp)
movq (%rax,%rbp,8), %r13
testq %r13, %r13
je 0x2510
cmpq %r12, (%r13)
jne 0x250a
cmpq %r14, 0x18(%r13)
jne 0x250a
leaq 0x20(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
je 0x254a
movq 0x8(%r13), %r13
jmp 0x24e6
leaq 0x28(%r14), %rdi
callq 0x21d0
movq %rax, %r13
movq %r12, (%rax)
movq (%rsp), %r12
movq (%r12,%rbp,8), %rax
movq %rax, 0x8(%r13)
movq %r14, 0x18(%r13)
leaq 0x20(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2120
movb $0x0, 0x20(%r13,%r14)
movq %r13, (%r12,%rbp,8)
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: checksum_add(char const*, unsigned long)
void checksum_add(const char* p, size_t len) {
	size_t i;
	uint64_t h0 = 0x100, h1 = 0x200;
	for (i = 0; i < len; i++) {
		h0 += (uint8_t)p[i];
		h1 += (uint8_t)p[i];
		h0 *= 0x1234567;
		h1 *= 0xabcdef9;
		h0 = rotl(h0, 13);
		h1 = rotl(h1, 19);
	}
	checksum[0] ^= h0;
	checksum[1] ^= h1;
}

// Assembly:
testq %rsi, %rsi
je 0x2595
movl $0x100, %ecx            # imm = 0x100
movl $0x200, %eax            # imm = 0x200
xorl %edx, %edx
movzbl (%rdi,%rdx), %r8d
addq %r8, %rcx
addq %r8, %rax
imulq $0x1234567, %rcx, %rcx  # imm = 0x1234567
imulq $0xabcdef9, %rax, %rax  # imm = 0xABCDEF9
rolq $0xd, %rcx
rolq $0x13, %rax
incq %rdx
cmpq %rdx, %rsi
jne 0x256a
jmp 0x259f
movl $0x200, %eax            # imm = 0x200
movl $0x100, %ecx            # imm = 0x100
xorl %ecx, 0x4bdb(%rip)      # 0x7180
xorl %eax, 0x4bd9(%rip)      # 0x7184
retq
// File: /workspace/github_cpp_makefile_star2_O1/funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: dehexify(char*, long)
void dehexify(char* s, ssize_t len) {
	ssize_t i, j;
	for (i=0,j=0; i<len; i+=2, j++) {
		char c1 = s[i];
		char c2 = s[i+1];
		assert(c1 != -1 && c2 != -1);
		s[j] = (c1<<4) + c2;
	}
}

// Assembly:
testq %rsi, %rsi
jle 0x25de
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rdi,%rax), %dl
cmpb $-0x1, %dl
je 0x25df
movb 0x1(%rdi,%rax), %r8b
cmpb $-0x1, %r8b
je 0x25df
shlb $0x4, %dl
addb %r8b, %dl
movb %dl, (%rdi,%rcx)
addq $0x2, %rax
incq %rcx
cmpq %rsi, %rax
jl 0x25b6
retq
pushq %rax
leaq 0x1abc(%rip), %rdi      # 0x40a3
leaq 0x1a8a(%rip), %rsi      # 0x4078
leaq 0x1ac3(%rip), %rcx      # 0x40b8
movl $0x71, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/superblocks[P]superblocks/list-jkc.cpp
// Function: main
int main() {

	cout << "[JKC] Junkcoin - Superblock list" << endl << endl;
	cout << "BLOCK, REWARD" << endl;
	for (int nHeight = 0; nHeight <= list_length; nHeight++) {
		random::mt19937 gen(nHeight);
		random::uniform_int_distribution<> dist(1, 100000);
		int rand = dist(gen);
		if(rand > 99990) {
			cout << nHeight << ", 1000" << endl;
		} else if (rand < 1001) {
			cout << nHeight << ", 150" << endl;
		} 
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9d8, %rsp            # imm = 0x9D8
movq 0x2de1(%rip), %rbx      # 0x3fd8
leaq 0xe06(%rip), %rsi       # 0x2004
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1070
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq 0xdc2(%rip), %rsi       # 0x2025
movl $0xd, %edx
movq %rbx, %rdi
callq 0x1070
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
cmpl $0x0, 0x2dc2(%rip)      # 0x4060
js 0x135e
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq -0x9f8(%rbp), %r14
leaq -0x2c(%rbp), %r15
movq 0x2d1d(%rip), %r12      # 0x3fd8
incl %ebx
movl %ebx, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1372
movq %r14, %rdi
movl $0x1, %esi
movl $0x186a0, %edx          # imm = 0x186A0
callq 0x13fa
cmpl $0x18697, %eax          # imm = 0x18697
jl 0x1302
movq %r12, %rdi
movl %ebx, %esi
callq 0x1090
movq %rax, %r13
movl $0x6, %edx
movq %rax, %rdi
leaq 0xd33(%rip), %rsi       # 0x2033
jmp 0x1325
cmpl $0x3e8, %eax            # imm = 0x3E8
jg 0x1352
movq %r12, %rdi
movl %ebx, %esi
callq 0x1090
movq %rax, %r13
movl $0x5, %edx
movq %rax, %rdi
leaq 0xd15(%rip), %rsi       # 0x203a
callq 0x1070
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r13, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
cmpl 0x2d08(%rip), %ebx      # 0x4060
jl 0x12bb
xorl %eax, %eax
addq $0x9d8, %rsp            # imm = 0x9D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq