LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_serialize_bool(alglib_impl::ae_serializer*, bool, alglib_impl::ae_state*)
void ae_serializer_serialize_bool(ae_serializer *serializer, ae_bool v, ae_state *state)
{
    char buf[AE_SER_ENTRY_LENGTH+2+1];
    const char *emsg = "ALGLIB: serialization integrity error";
    ae_int_t bytes_appended;
    
    /* prepare serialization, check consistency */
    ae_bool2str(v, buf, state);
    serializer->entries_saved++;
    if( serializer->entries_saved%AE_SER_ENTRIES_PER_ROW )
        strcat(buf, " ");
    else
        strcat(buf, "\r\n");
    bytes_appended = (ae_int_t)strlen(buf);
    if( serializer->bytes_written+bytes_appended > serializer->bytes_asked )
        ae_break(state, ERR_ASSERTION_FAILED, emsg);
    serializer->bytes_written += bytes_appended;
        
    /* append to buffer */
#ifdef AE_USE_CPP_SERIALIZATION
    if( serializer->mode==AE_SM_TO_CPPSTRING )
    {
        *(serializer->out_cppstr) += buf;
        return;
    }
#endif
    if( serializer->mode==AE_SM_TO_STRING )
    {
        strcat(serializer->out_str, buf);
        serializer->out_str += bytes_appended;
        return;
    }
    ae_break(state, ERR_ASSERTION_FAILED, emsg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %eax
orq $0x30, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rax, %rcx
movq %rsp, %rdi
movq %rcx, (%rdi)
movl %ecx, 0x7(%rdi)
movb $0x0, 0xb(%rdi)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
addq %rcx, %r15
callq 0x3110
movabsq $0x3333333333333333, %rcx # imm = 0x3333333333333333
addq %rsp, %rax
cmpq %rcx, %r15
jb 0x27bd8
movw $0x20, (%rax)
jmp 0x27be1
movb $0x0, 0x2(%rax)
movw $0xa0d, (%rax)          # imm = 0xA0D
movq %rsp, %rdi
callq 0x3110
movq %rax, %r15
movq 0x20(%rbx), %rax
addq %r15, %rax
cmpq 0x18(%rbx), %rax
jg 0x27c34
addq %r15, 0x20(%rbx)
movq (%rbx), %rax
cmpq $0xa, %rax
je 0x27c1a
cmpq $0xb, %rax
jne 0x27c34
movq 0x28(%rbx), %rdi
movq %rsp, %rsi
callq 0x3470
jmp 0x27c2a
movq 0x30(%rbx), %rdi
movq %rsp, %rsi
callq 0x3430
addq %r15, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xfbaf(%rip), %rdx      # 0x377ea
movq %r14, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_serialize_double(alglib_impl::ae_serializer*, double, alglib_impl::ae_state*)
void ae_serializer_serialize_double(ae_serializer *serializer, double v, ae_state *state)
{
    char buf[AE_SER_ENTRY_LENGTH+2+1];
    const char *emsg = "ALGLIB: serialization integrity error";
    ae_int_t bytes_appended;
    
    /* prepare serialization, check consistency */
    ae_double2str(v, buf, state);
    serializer->entries_saved++;
    if( serializer->entries_saved%AE_SER_ENTRIES_PER_ROW )
        strcat(buf, " ");
    else
        strcat(buf, "\r\n");
    bytes_appended = (ae_int_t)strlen(buf);
    if( serializer->bytes_written+bytes_appended > serializer->bytes_asked )
        ae_break(state, ERR_ASSERTION_FAILED, emsg);
    serializer->bytes_written += bytes_appended;
        
    /* append to buffer */
#ifdef AE_USE_CPP_SERIALIZATION
    if( serializer->mode==AE_SM_TO_CPPSTRING )
    {
        *(serializer->out_cppstr) += buf;
        return;
    }
#endif
    if( serializer->mode==AE_SM_TO_STRING )
    {
        strcat(serializer->out_str, buf);
        serializer->out_str += bytes_appended;
        return;
    }
    ae_break(state, ERR_ASSERTION_FAILED, emsg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa(%rsp), %r15
movq %r15, %rdi
callq 0x276a1
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %r12 # imm = 0x1999999999999999
addq %rcx, %r12
movq %r15, %rdi
callq 0x3110
movabsq $0x3333333333333333, %rcx # imm = 0x3333333333333333
addq %rsp, %rax
addq $0xa, %rax
cmpq %rcx, %r12
jb 0x27d95
movw $0x20, (%rax)
jmp 0x27d9e
movb $0x0, 0x2(%rax)
movw $0xa0d, (%rax)          # imm = 0xA0D
leaq 0xa(%rsp), %rdi
callq 0x3110
movq %rax, %r15
movq 0x20(%rbx), %rax
addq %r15, %rax
cmpq 0x18(%rbx), %rax
jg 0x27df9
addq %r15, 0x20(%rbx)
movq (%rbx), %rax
cmpq $0xa, %rax
je 0x27ddb
cmpq $0xb, %rax
jne 0x27df9
movq 0x28(%rbx), %rdi
leaq 0xa(%rsp), %rsi
callq 0x3470
jmp 0x27ded
movq 0x30(%rbx), %rdi
leaq 0xa(%rsp), %rsi
callq 0x3430
addq %r15, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf9ea(%rip), %rdx      # 0x377ea
movq %r14, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_abs(alglib_impl::ae_complex, alglib_impl::ae_state*)
double ae_c_abs(ae_complex z, ae_state *state)
{
    double w;
    double xabs;
    double yabs;
    double v;

    xabs = fabs(z.x);
    yabs = fabs(z.y);
    w = xabs>yabs ? xabs : yabs;
    v = xabs<yabs ? xabs : yabs;
    if( v==0 )
        return w;
    else
    {
        double t = v/w;
        return w*sqrt(1+t*t);
    }
}

// Assembly:
movapd 0xf1f2(%rip), %xmm2     # 0x370a0
andpd %xmm2, %xmm0
andpd %xmm2, %xmm1
movapd %xmm0, %xmm2
maxsd %xmm1, %xmm2
minsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x27ece
jnp 0x27f05
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd 0xc2c2(%rip), %xmm0     # 0x341a0
ucomisd %xmm1, %xmm0
jb 0x27eea
sqrtsd %xmm0, %xmm0
jmp 0x27f01
subq $0x18, %rsp
movapd %xmm2, (%rsp)
callq 0x31e0
movapd (%rsp), %xmm2
addq $0x18, %rsp
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_eq(alglib_impl::ae_complex, alglib_impl::ae_complex)
ae_bool ae_c_eq(ae_complex lhs,   ae_complex rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs.x;
    volatile double y1 = lhs.y;
    volatile double y2 = rhs.y;
    return x1==x2 && y1==y2;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm2, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm3, -0x20(%rsp)
movsd -0x8(%rsp), %xmm0
ucomisd -0x10(%rsp), %xmm0
jne 0x27f48
jp 0x27f48
movsd -0x18(%rsp), %xmm0
cmpeqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_neq(alglib_impl::ae_complex, alglib_impl::ae_complex)
ae_bool ae_c_neq(ae_complex lhs,  ae_complex rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs.x;
    volatile double y1 = lhs.y;
    volatile double y2 = rhs.y;
    return x1!=x2 || y1!=y2;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm2, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm3, -0x20(%rsp)
movsd -0x8(%rsp), %xmm0
movb $0x1, %al
ucomisd -0x10(%rsp), %xmm0
jne 0x27f75
jnp 0x27f76
retq
movsd -0x18(%rsp), %xmm0
cmpneqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_div(alglib_impl::ae_complex, alglib_impl::ae_complex)
ae_complex ae_c_div(ae_complex lhs,   ae_complex rhs)
{
    ae_complex result;
    double e;
    double f;
    if( fabs(rhs.y)<fabs(rhs.x) )
    {
        e = rhs.y/rhs.x;
        f = rhs.x+rhs.y*e;
        result.x = (lhs.x+lhs.y*e)/f;
        result.y = (lhs.y-lhs.x*e)/f;
    }
    else
    {
        e = rhs.x/rhs.y;
        f = rhs.y+rhs.x*e;
        result.x = (lhs.y+lhs.x*e)/f;
        result.y = (-lhs.x+lhs.y*e)/f;
    }
    return result;
}

// Assembly:
movapd %xmm1, %xmm4
movapd 0xf0d1(%rip), %xmm1     # 0x370a0
movapd %xmm3, %xmm5
andpd %xmm1, %xmm5
andpd %xmm2, %xmm1
ucomisd %xmm5, %xmm1
movapd 0xc1f9(%rip), %xmm1     # 0x341e0
xorpd %xmm0, %xmm1
jbe 0x2801b
movapd %xmm3, %xmm5
divsd %xmm2, %xmm5
mulsd %xmm5, %xmm3
addsd %xmm2, %xmm3
movapd %xmm4, %xmm2
mulsd %xmm5, %xmm2
addsd %xmm0, %xmm2
divsd %xmm3, %xmm2
mulsd %xmm5, %xmm1
addsd %xmm4, %xmm1
divsd %xmm3, %xmm1
jmp 0x2804b
movapd %xmm2, %xmm5
divsd %xmm3, %xmm5
mulsd %xmm5, %xmm2
addsd %xmm3, %xmm2
mulsd %xmm5, %xmm0
addsd %xmm4, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm4, %xmm5
addsd %xmm1, %xmm5
divsd %xmm2, %xmm5
movapd %xmm0, %xmm2
movapd %xmm5, %xmm1
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_eq_d(alglib_impl::ae_complex, double)
ae_bool ae_c_eq_d(ae_complex lhs,  double rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs;
    volatile double y1 = lhs.y;
    volatile double y2 = 0;
    return x1==x2 && y1==y2;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm2, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movsd -0x8(%rsp), %xmm0
ucomisd -0x10(%rsp), %xmm0
jne 0x28091
jp 0x28091
movsd -0x18(%rsp), %xmm0
cmpeqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_neq_d(alglib_impl::ae_complex, double)
ae_bool ae_c_neq_d(ae_complex lhs, double rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs;
    volatile double y1 = lhs.y;
    volatile double y2 = 0;
    return x1!=x2 || y1!=y2;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm2, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movsd -0x8(%rsp), %xmm0
movb $0x1, %al
ucomisd -0x10(%rsp), %xmm0
jne 0x280c1
jnp 0x280c2
retq
movsd -0x18(%rsp), %xmm0
cmpneqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_d_div(double, alglib_impl::ae_complex)
ae_complex ae_c_d_div(double lhs,   ae_complex rhs)
{
    ae_complex result;
    double e;
    double f;
    if( fabs(rhs.y)<fabs(rhs.x) )
    {
        e = rhs.y/rhs.x;
        f = rhs.x+rhs.y*e;
        result.x = lhs/f;
        result.y = -lhs*e/f;
    }
    else
    {
        e = rhs.x/rhs.y;
        f = rhs.y+rhs.x*e;
        result.x = lhs*e/f;
        result.y = -lhs/f;
    }
    return result;
}

// Assembly:
movapd %xmm0, %xmm3
movapd 0xef91(%rip), %xmm0     # 0x370a0
movapd %xmm2, %xmm4
andpd %xmm0, %xmm4
andpd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jbe 0x2814b
movapd %xmm2, %xmm4
divsd %xmm1, %xmm4
mulsd %xmm4, %xmm2
addsd %xmm1, %xmm2
movapd %xmm3, %xmm0
divsd %xmm2, %xmm0
xorpd 0xc09f(%rip), %xmm3     # 0x341e0
mulsd %xmm4, %xmm3
divsd %xmm2, %xmm3
jmp 0x2816f
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm0
divsd %xmm1, %xmm0
xorpd 0xc075(%rip), %xmm3     # 0x341e0
divsd %xmm1, %xmm3
movapd %xmm3, %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_cmove(alglib_impl::ae_complex*, long, alglib_impl::ae_complex const*, long, char const*, long)
void ae_v_cmove(ae_complex *vdst, ae_int_t stride_dst, const ae_complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n)
{
    ae_bool bconj = !((conj_src[0]=='N') || (conj_src[0]=='n'));
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        /*
         * general unoptimized case
         */
        if( bconj )
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            {
                vdst->x =  vsrc->x;
                vdst->y = -vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
                *vdst = *vsrc;
        }
    }
    else
    {
        /*
         * optimized case
         */
        if( bconj )
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
            {
                vdst->x =  vsrc->x;
                vdst->y = -vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
                *vdst = *vsrc;
        }
    }
}

// Assembly:
movb (%r8), %al
andb $-0x21, %al
movq %rsi, %r8
xorq $0x1, %r8
movq %rcx, %r10
xorq $0x1, %r10
orq %r8, %r10
je 0x2838d
cmpb $0x4e, %al
jne 0x283af
testq %r9, %r9
jle 0x2841b
shlq $0x4, %rsi
shlq $0x4, %rcx
movups (%rdx), %xmm0
movups %xmm0, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x28377
jmp 0x2841b
cmpb $0x4e, %al
jne 0x283ec
testq %r9, %r9
jle 0x2841b
xorl %eax, %eax
movups (%rdx,%rax), %xmm0
movups %xmm0, (%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x2839c
jmp 0x2841b
testq %r9, %r9
jle 0x2841b
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movaps 0xbe15(%rip), %xmm0     # 0x341e0
movsd -0x8(%rdx), %xmm1
movsd %xmm1, -0x8(%rdi)
movsd (%rdx), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x283cb
jmp 0x2841b
testq %r9, %r9
jle 0x2841b
xorl %eax, %eax
movaps 0xbde6(%rip), %xmm0     # 0x341e0
movsd (%rdx,%rax), %xmm1
movsd %xmm1, (%rdi,%rax)
movsd 0x8(%rdx,%rax), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x8(%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x283fa
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_cmoved(alglib_impl::ae_complex*, long, alglib_impl::ae_complex const*, long, char const*, long, double)
void ae_v_cmoved(ae_complex *vdst, ae_int_t stride_dst, const ae_complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, double alpha)
{
    ae_bool bconj = !((conj_src[0]=='N') || (conj_src[0]=='n'));
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        /*
         * general unoptimized case
         */
        if( bconj )
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            {
                vdst->x =  alpha*vsrc->x;
                vdst->y = -alpha*vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            {
                vdst->x = alpha*vsrc->x;
                vdst->y = alpha*vsrc->y;
            }
        }
    }
    else
    {
        /*
         * optimized case
         */
        if( bconj )
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
            {
                vdst->x =  alpha*vsrc->x;
                vdst->y = -alpha*vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
            {
                vdst->x = alpha*vsrc->x;
                vdst->y = alpha*vsrc->y;
            }
        }
    }
}

// Assembly:
movb (%r8), %al
andb $-0x21, %al
movq %rsi, %r8
xorq $0x1, %r8
movq %rcx, %r10
xorq $0x1, %r10
orq %r8, %r10
je 0x28589
cmpb $0x4e, %al
jne 0x285c4
testq %r9, %r9
jle 0x28646
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movsd -0x8(%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x8(%rdi)
movsd (%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x2855f
jmp 0x28646
cmpb $0x4e, %al
jne 0x2860c
testq %r9, %r9
jle 0x28646
xorl %eax, %eax
movsd (%rdx,%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax)
movsd 0x8(%rdx,%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x28598
jmp 0x28646
testq %r9, %r9
jle 0x28646
movapd 0xbc0f(%rip), %xmm1     # 0x341e0
xorpd %xmm0, %xmm1
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movsd -0x8(%rdx), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, -0x8(%rdi)
movsd (%rdx), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x285e5
jmp 0x28646
testq %r9, %r9
jle 0x28646
movapd 0xbbc7(%rip), %xmm1     # 0x341e0
xorpd %xmm0, %xmm1
xorl %eax, %eax
movsd (%rdx,%rax), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rdi,%rax)
movsd 0x8(%rdx,%rax), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x2861f
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_cmuld(alglib_impl::ae_complex*, long, long, double)
void ae_v_cmuld(ae_complex *vdst, ae_int_t stride_dst, ae_int_t n, double alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        /*
         * general unoptimized case
         */
        for(i=0; i<n; i++, vdst+=stride_dst)
        {
            vdst->x *= alpha;
            vdst->y *= alpha;
        }
    }
    else
    {
        /*
         * optimized case
         */
        for(i=0; i<n; i++, vdst++)
        {
            vdst->x *= alpha;
            vdst->y *= alpha;
        }
    }
}

// Assembly:
cmpq $0x1, %rsi
jne 0x28d18
testq %rdx, %rdx
jle 0x28d47
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
addq $0x10, %rdi
decq %rdx
jne 0x28cf3
jmp 0x28d47
testq %rdx, %rdx
jle 0x28d47
addq $0x8, %rdi
shlq $0x4, %rsi
movsd -0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x8(%rdi)
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
decq %rdx
jne 0x28d25
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_cmulc(alglib_impl::ae_complex*, long, long, alglib_impl::ae_complex)
void ae_v_cmulc(ae_complex *vdst, ae_int_t stride_dst, ae_int_t n, ae_complex alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        /*
         * general unoptimized case
         */
        double ax = alpha.x, ay = alpha.y;
        for(i=0; i<n; i++, vdst+=stride_dst)
        {
            double  dstx = vdst->x, dsty = vdst->y;
            vdst->x = ax*dstx-ay*dsty;
            vdst->y = ax*dsty+ay*dstx;
        }
    }
    else
    {
        /*
         * highly optimized case
         */
        double ax = alpha.x, ay = alpha.y;
        for(i=0; i<n; i++, vdst++)
        {
            double  dstx = vdst->x, dsty = vdst->y;
            vdst->x = ax*dstx-ay*dsty;
            vdst->y = ax*dsty+ay*dstx;
        }
    }
}

// Assembly:
cmpq $0x1, %rsi
jne 0x28d94
testq %rdx, %rdx
jle 0x28ddb
movsd (%rdi), %xmm2
movsd 0x8(%rdi), %xmm3
movapd %xmm3, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm5
mulsd %xmm2, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, (%rdi)
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rdi)
addq $0x10, %rdi
decq %rdx
jne 0x28d57
jmp 0x28ddb
testq %rdx, %rdx
jle 0x28ddb
addq $0x8, %rdi
shlq $0x4, %rsi
movsd -0x8(%rdi), %xmm2
movsd (%rdi), %xmm3
movapd %xmm3, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm5
mulsd %xmm2, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, -0x8(%rdi)
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rdi)
addq %rsi, %rdi
decq %rdx
jne 0x28da1
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_dotproduct(double const*, long, double const*, long, long)
double ae_v_dotproduct(const double *v0, ae_int_t stride0, const double *v1, ae_int_t stride1, ae_int_t n)
{
    double result = 0;
    ae_int_t i;
    if( stride0!=1 || stride1!=1 )
    {
        /*
         * slow general code
         */
        for(i=0; i<n; i++, v0+=stride0, v1+=stride1)
            result += (*v0)*(*v1);
    }
    else
    {
        /*
         * optimized code for stride=1
         */
        ae_int_t n4 = n/4;
        ae_int_t nleft = n%4;
        for(i=0; i<n4; i++, v0+=4, v1+=4)
            result += v0[0]*v1[0]+v0[1]*v1[1]+v0[2]*v1[2]+v0[3]*v1[3];
        for(i=0; i<nleft; i++, v0++, v1++)
            result += v0[0]*v1[0];
    }
    return result;
}

// Assembly:
movq %rsi, %rax
xorq $0x1, %rax
movq %rcx, %r9
xorq $0x1, %r9
orq %rax, %r9
je 0x28e20
testq %r8, %r8
jle 0x28ec9
shlq $0x3, %rsi
shlq $0x3, %rcx
xorpd %xmm0, %xmm0
movsd (%rdi), %xmm1
mulsd (%rdx), %xmm1
addsd %xmm1, %xmm0
addq %rsi, %rdi
addq %rcx, %rdx
decq %r8
jne 0x28e04
jmp 0x28ec8
leaq 0x3(%r8), %rsi
testq %r8, %r8
cmovnsq %r8, %rsi
movq %rsi, %rcx
andq $-0x4, %rcx
movq %r8, %rax
subq %rcx, %rax
xorpd %xmm0, %xmm0
cmpq $0x4, %r8
jl 0x28ea8
sarq $0x2, %rsi
movq %rsi, %r8
shlq $0x5, %r8
leaq (%rdi,%r8), %rcx
xorl %r9d, %r9d
movsd (%rdi,%r9), %xmm1
movsd 0x8(%rdi,%r9), %xmm2
mulsd 0x8(%rdx,%r9), %xmm2
mulsd (%rdx,%r9), %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%rdi,%r9), %xmm2
mulsd 0x10(%rdx,%r9), %xmm2
addsd %xmm1, %xmm2
movsd 0x18(%rdi,%r9), %xmm1
mulsd 0x18(%rdx,%r9), %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x20, %r9
decq %rsi
jne 0x28e54
addq %r8, %rdx
jmp 0x28eab
movq %rdi, %rcx
testq %rax, %rax
jle 0x28ec8
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x28eb2
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_move(double*, long, double const*, long, long)
void ae_v_move(double *vdst,  ae_int_t stride_dst, const double* vsrc,  ae_int_t stride_src, ae_int_t n)
{
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        /*
         * general unoptimized case
         */
        for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            *vdst = *vsrc;
    }
    else
    {
        /*
         * optimized case
         */
        ae_int_t n2 = n/2;
        for(i=0; i<n2; i++, vdst+=2, vsrc+=2)
        {
            vdst[0] = vsrc[0];
            vdst[1] = vsrc[1];
        }
        if( n%2!=0 )
            vdst[0] = vsrc[0];
    }
}

// Assembly:
movq %rsi, %rax
xorq $0x1, %rax
movq %rcx, %r9
xorq $0x1, %r9
orq %rax, %r9
je 0x28f01
testq %r8, %r8
jle 0x28f00
shlq $0x3, %rsi
shlq $0x3, %rcx
movsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r8
jne 0x28eed
retq
cmpq $0x2, %r8
jl 0x28f33
movq %r8, %rax
shrq $0x3f, %rax
addq %r8, %rax
sarq %rax
movsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x10, %rdi
addq $0x10, %rdx
decq %rax
jne 0x28f14
testb $0x1, %r8b
je 0x28f00
movsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_moved(double*, long, double const*, long, long, double)
void ae_v_moved(double *vdst,  ae_int_t stride_dst, const double* vsrc,  ae_int_t stride_src, ae_int_t n, double alpha)
{
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        /*
         * general unoptimized case
         */
        for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            *vdst = alpha*(*vsrc);
    }
    else
    {
        /*
         * optimized case
         */
        ae_int_t n2 = n/2;
        for(i=0; i<n2; i++, vdst+=2, vsrc+=2)
        {
            vdst[0] = alpha*vsrc[0];
            vdst[1] = alpha*vsrc[1];
        }
        if( n%2!=0 )
            vdst[0] = alpha*vsrc[0];
    }
}

// Assembly:
movq %rsi, %rax
xorq $0x1, %rax
movq %rcx, %r9
xorq $0x1, %r9
orq %rax, %r9
je 0x29009
testq %r8, %r8
jle 0x29008
shlq $0x3, %rsi
shlq $0x3, %rcx
movsd (%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r8
jne 0x28ff1
retq
cmpq $0x2, %r8
jl 0x29043
movq %r8, %rax
shrq $0x3f, %rax
addq %r8, %rax
sarq %rax
movsd (%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd 0x8(%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
addq $0x10, %rdi
addq $0x10, %rdx
decq %rax
jne 0x2901c
testb $0x1, %r8b
je 0x29008
mulsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_muld(double*, long, long, double)
void ae_v_muld(double *vdst,  ae_int_t stride_dst, ae_int_t n, double alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        /*
         * general unoptimized case
         */
        for(i=0; i<n; i++, vdst+=stride_dst)
            *vdst *= alpha;
    }
    else
    {
        /*
         * highly optimized case
         */
        for(i=0; i<n; i++, vdst++)
            *vdst *= alpha;
    }
}

// Assembly:
cmpq $0x1, %rsi
jne 0x29221
testq %rdx, %rdx
jle 0x2923e
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x29209
jmp 0x2923e
testq %rdx, %rdx
jle 0x2923e
shlq $0x3, %rsi
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
decq %rdx
jne 0x2922a
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_rcommstate_init(alglib_impl::rcommstate*, alglib_impl::ae_state*, bool)
ae_bool _rcommstate_init(rcommstate* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->ba, 0, DT_BOOL,    _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia, 0, DT_INT,     _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra, 0, DT_REAL,    _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ca, 0, DT_COMPLEX, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
xorl %r8d, %r8d
movq %r8, 0x38(%rdi)
movq $0x1, 0x40(%rdi)
leaq 0x48(%rdi), %rcx
testq %rsi, %rsi
setne %al
movq %r8, 0x58(%rdi)
movq 0x58(%rdi), %r8
andb %dl, %al
cmpb $0x1, %al
jne 0x2927b
movq 0x20(%rsi), %rdx
movq %rdx, (%rcx)
movq %rcx, 0x20(%rsi)
jmp 0x29282
movq $0x0, (%rcx)
leaq -0x3c5d(%rip), %rcx     # 0x2562c
movq %rcx, 0x50(%rdi)
movq 0x58(%rdi), %rdx
movq %rdx, 0x60(%rdi)
xorl %r8d, %r8d
movq %r8, 0x8(%rdi)
movq $0x2, 0x10(%rdi)
leaq 0x18(%rdi), %rdx
movq %r8, 0x28(%rdi)
movq 0x28(%rdi), %r8
testb %al, %al
je 0x292c1
movq 0x20(%rsi), %r8
movq %r8, (%rdx)
movq %rdx, 0x20(%rsi)
jmp 0x292c8
movq $0x0, (%rdx)
movq %rcx, 0x20(%rdi)
movq 0x28(%rdi), %rdx
movq %rdx, 0x30(%rdi)
xorl %r8d, %r8d
movq %r8, 0x68(%rdi)
movq $0x3, 0x70(%rdi)
leaq 0x78(%rdi), %rdx
movq %r8, 0x88(%rdi)
movq 0x88(%rdi), %r8
testb %al, %al
je 0x29306
movq 0x20(%rsi), %r8
movq %r8, (%rdx)
movq %rdx, 0x20(%rsi)
jmp 0x2930d
movq $0x0, (%rdx)
movq %rcx, 0x80(%rdi)
movq 0x88(%rdi), %rdx
movq %rdx, 0x90(%rdi)
xorl %r8d, %r8d
movq %r8, 0x98(%rdi)
movq $0x4, 0xa0(%rdi)
leaq 0xa8(%rdi), %rdx
movq %r8, 0xb8(%rdi)
movq 0xb8(%rdi), %r8
testb %al, %al
je 0x2935d
movq 0x20(%rsi), %rax
movq %rax, (%rdx)
movq %rdx, 0x20(%rsi)
jmp 0x29364
movq $0x0, (%rdx)
movq %rcx, 0xb0(%rdi)
movq 0xb8(%rdi), %rax
movq %rax, 0xc0(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_rcommstate_init_copy(alglib_impl::rcommstate*, alglib_impl::rcommstate*, alglib_impl::ae_state*, bool)
ae_bool _rcommstate_init_copy(rcommstate* dst, rcommstate* src, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init_copy(&dst->ba, &src->ba, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia, &src->ia, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra, &src->ra, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ca, &src->ca, _state, make_automatic) )
        return ae_false;
    dst->stage = src->stage;
    return ae_true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rdi
addq $0x38, %rsi
callq 0x2597e
testb %al, %al
je 0x293f2
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
movzbl %bpl, %ebp
movq %r15, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x293f2
leaq 0x68(%rbx), %rdi
leaq 0x68(%r14), %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x293f2
movl $0x98, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x2597e
testb %al, %al
je 0x293f2
movl (%r14), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x293f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_rcommstate_clear(alglib_impl::rcommstate*)
void _rcommstate_clear(rcommstate* p)
{
    ae_vector_clear(&p->ba);
    ae_vector_clear(&p->ia);
    ae_vector_clear(&p->ra);
    ae_vector_clear(&p->ca);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x38(%rdi)
cmpq $0x0, 0x58(%rdi)
je 0x2941c
movq 0x58(%rbx), %rdi
callq *0x50(%rbx)
xorl %eax, %eax
movq %rax, 0x58(%rbx)
leaq -0x3dfd(%rip), %r14     # 0x2562c
movq %r14, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movq %rax, 0x8(%rbx)
cmpq %rax, 0x28(%rbx)
je 0x29442
movq 0x28(%rbx), %rdi
callq *0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %r14, 0x20(%rbx)
movq %rax, 0x30(%rbx)
movq %rax, 0x68(%rbx)
cmpq %rax, 0x88(%rbx)
je 0x2946a
movq 0x88(%rbx), %rdi
callq *0x80(%rbx)
movq $0x0, 0x88(%rbx)
movq %r14, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
cmpq $0x0, 0xb8(%rbx)
je 0x2949d
movq 0xb8(%rbx), %rdi
callq *0xb0(%rbx)
xorl %eax, %eax
movq %rax, 0xb8(%rbx)
movq %r14, 0xb0(%rbx)
movq %rax, 0xc0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex::operator*=(alglib::complex const&)
alglib::complex& alglib::complex::operator*=(const alglib::complex& z)
{
    double t = x*z.x-y*z.y;
    y = x*z.y+y*z.x;
    x = t; 
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd (%rsi), %xmm2
movsd 0x8(%rsi), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm0
mulsd %xmm1, %xmm3
mulsd %xmm2, %xmm4
subsd %xmm3, %xmm4
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd %xmm4, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex::operator/=(alglib::complex const&)
alglib::complex& alglib::complex::operator/=(const alglib::complex& z)
{
    alglib::complex result;
    double e;
    double f;
    if( fabs(z.y)<fabs(z.x) )
    {
        e = z.y/z.x;
        f = z.x+z.y*e;
        result.x = (x+y*e)/f;
        result.y = (y-x*e)/f;
    }
    else
    {
        e = z.x/z.y;
        f = z.y+z.x*e;
        result.x = (y+x*e)/f;
        result.y = (-x+y*e)/f;
    }
    *this = result;
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm2
movapd 0xd7f2(%rip), %xmm0     # 0x370a0
movapd %xmm2, %xmm3
andpd %xmm0, %xmm3
andpd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jbe 0x298f7
movapd %xmm2, %xmm4
divsd %xmm1, %xmm4
mulsd %xmm4, %xmm2
addsd %xmm1, %xmm2
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movapd %xmm0, %xmm3
mulsd %xmm4, %xmm3
addsd %xmm1, %xmm3
divsd %xmm2, %xmm3
mulsd %xmm1, %xmm4
subsd %xmm4, %xmm0
divsd %xmm2, %xmm0
jmp 0x2992c
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm4
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm4, %xmm0
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd %xmm3, (%rax)
movsd %xmm0, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::operator==(alglib::complex const&, alglib::complex const&)
const bool alglib::operator==(const alglib::complex& lhs, const alglib::complex& rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs.x;
    volatile double y1 = lhs.y;
    volatile double y2 = rhs.y;
    return x1==x2 && y1==y2;
}

// Assembly:
movsd (%rdi), %xmm0
movsd %xmm0, -0x8(%rsp)
movsd (%rsi), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x8(%rdi), %xmm0
movsd %xmm0, -0x18(%rsp)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, -0x20(%rsp)
movsd -0x8(%rsp), %xmm0
ucomisd -0x10(%rsp), %xmm0
jne 0x2a180
jp 0x2a180
movsd -0x18(%rsp), %xmm0
cmpeqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::operator/(alglib::complex const&, alglib::complex const&)
const alglib::complex alglib::operator/(const alglib::complex& lhs, const alglib::complex& rhs)
{
    alglib::complex result;
    double e;
    double f;
    if( fabs(rhs.y)<fabs(rhs.x) )
    {
        e = rhs.y/rhs.x;
        f = rhs.x+rhs.y*e;
        result.x = (lhs.x+lhs.y*e)/f;
        result.y = (lhs.y-lhs.x*e)/f;
    }
    else
    {
        e = rhs.x/rhs.y;
        f = rhs.y+rhs.x*e;
        result.x = (lhs.y+lhs.x*e)/f;
        result.y = (-lhs.x+lhs.y*e)/f;
    }
    return result;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movsd (%rdx), %xmm1
movsd 0x8(%rdx), %xmm2
movapd 0xcd87(%rip), %xmm0     # 0x370a0
movapd %xmm2, %xmm3
andpd %xmm0, %xmm3
andpd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jbe 0x2a366
movapd %xmm2, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm0
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm1, %xmm4
divsd %xmm2, %xmm4
movsd %xmm4, (%rax)
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm0
divsd %xmm2, %xmm0
jmp 0x2a39f
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd (%rsi), %xmm2
movsd 0x8(%rsi), %xmm3
movapd %xmm2, %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
divsd %xmm1, %xmm4
movsd %xmm4, (%rax)
mulsd %xmm3, %xmm0
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::operator/(double const&, alglib::complex const&)
const alglib::complex alglib::operator/(const double& lhs, const alglib::complex& rhs)
{
    alglib::complex result;
    double e;
    double f;
    if( fabs(rhs.y)<fabs(rhs.x) )
    {
        e = rhs.y/rhs.x;
        f = rhs.x+rhs.y*e;
        result.x = lhs/f;
        result.y = -lhs*e/f;
    }
    else
    {
        e = rhs.x/rhs.y;
        f = rhs.y+rhs.x*e;
        result.x = lhs*e/f;
        result.y = -lhs/f;
    }
    return result;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movsd (%rdx), %xmm1
movsd 0x8(%rdx), %xmm2
movapd 0xcce1(%rip), %xmm0     # 0x370a0
movapd %xmm2, %xmm3
andpd %xmm0, %xmm3
andpd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
movsd (%rsi), %xmm0
jbe 0x2a403
movapd %xmm2, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movapd %xmm0, %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rax)
xorpd 0x9de7(%rip), %xmm0     # 0x341e0
mulsd %xmm3, %xmm0
divsd %xmm2, %xmm0
jmp 0x2a42b
movapd %xmm1, %xmm3
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm3
divsd %xmm1, %xmm3
movsd %xmm3, (%rax)
xorpd 0x9db9(%rip), %xmm0     # 0x341e0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::abscomplex(alglib::complex const&)
double alglib::abscomplex(const alglib::complex &z)
{
    double w;
    double xabs;
    double yabs;
    double v;

    xabs = fabs(z.x);
    yabs = fabs(z.y);
    w = xabs>yabs ? xabs : yabs;
    v = xabs<yabs ? xabs : yabs; 
    if( v==0 )
        return w;
    else
    {
        double t = v/w;
        return w*sqrt(1+t*t);
    }
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movapd 0xcc3c(%rip), %xmm2     # 0x370a0
andpd %xmm2, %xmm0
andpd %xmm2, %xmm1
movapd %xmm0, %xmm2
maxsd %xmm1, %xmm2
minsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2a484
jnp 0x2a4bb
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd 0x9d0c(%rip), %xmm0     # 0x341a0
ucomisd %xmm1, %xmm0
jb 0x2a4a0
sqrtsd %xmm0, %xmm0
jmp 0x2a4b7
subq $0x18, %rsp
movapd %xmm2, (%rsp)
callq 0x31e0
movapd (%rsp), %xmm2
addq $0x18, %rsp
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::vmove(alglib::complex*, long, alglib::complex const*, long, char const*, long)
void alglib::vmove(alglib::complex *vdst, ae_int_t stride_dst, const alglib::complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n)
{
    bool bconj = !((conj_src[0]=='N') || (conj_src[0]=='n'));
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        //
        // general unoptimized case
        //
        if( bconj )
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            {
                vdst->x =  vsrc->x;
                vdst->y = -vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
                *vdst = *vsrc;
        }
    }
    else
    {
        //
        // optimized case
        //
        if( bconj )
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
            {
                vdst->x =  vsrc->x;
                vdst->y = -vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
                *vdst = *vsrc;
        }
    }
}

// Assembly:
movb (%r8), %al
andb $-0x21, %al
movq %rsi, %r8
xorq $0x1, %r8
movq %rcx, %r10
xorq $0x1, %r10
orq %r8, %r10
je 0x2a947
cmpb $0x4e, %al
jne 0x2a977
testq %r9, %r9
jle 0x2a9e3
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movsd -0x8(%rdx), %xmm0
movsd %xmm0, -0x8(%rdi)
movsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x2a925
jmp 0x2a9e3
cmpb $0x4e, %al
jne 0x2a9b4
testq %r9, %r9
jle 0x2a9e3
xorl %eax, %eax
movsd (%rdx,%rax), %xmm0
movsd %xmm0, (%rdi,%rax)
movsd 0x8(%rdx,%rax), %xmm0
movsd %xmm0, 0x8(%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x2a956
jmp 0x2a9e3
testq %r9, %r9
jle 0x2a9e3
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movaps 0x984d(%rip), %xmm0     # 0x341e0
movsd -0x8(%rdx), %xmm1
movsd %xmm1, -0x8(%rdi)
movsd (%rdx), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x2a993
jmp 0x2a9e3
testq %r9, %r9
jle 0x2a9e3
xorl %eax, %eax
movaps 0x981e(%rip), %xmm0     # 0x341e0
movsd (%rdx,%rax), %xmm1
movsd %xmm1, (%rdi,%rax)
movsd 0x8(%rdx,%rax), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x8(%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x2a9c2
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::vmove(alglib::complex*, long, alglib::complex const*, long, char const*, long, double)
void alglib::vmove(alglib::complex *vdst, ae_int_t stride_dst, const alglib::complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, double alpha)
{
    bool bconj = !((conj_src[0]=='N') || (conj_src[0]=='n'));
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        //
        // general unoptimized case
        //
        if( bconj )
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            {
                vdst->x =  alpha*vsrc->x;
                vdst->y = -alpha*vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            {
                vdst->x = alpha*vsrc->x;
                vdst->y = alpha*vsrc->y;
            }
        }
    }
    else
    {
        //
        // optimized case
        //
        if( bconj )
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
            {
                vdst->x =  alpha*vsrc->x;
                vdst->y = -alpha*vsrc->y;
            }
        }
        else
        {
            for(i=0; i<n; i++, vdst++, vsrc++)
            {
                vdst->x = alpha*vsrc->x;
                vdst->y = alpha*vsrc->y;
            }
        }
    }
}

// Assembly:
movb (%r8), %al
andb $-0x21, %al
movq %rsi, %r8
xorq $0x1, %r8
movq %rcx, %r10
xorq $0x1, %r10
orq %r8, %r10
je 0x2ad32
cmpb $0x4e, %al
jne 0x2ad6d
testq %r9, %r9
jle 0x2adef
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movsd -0x8(%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x8(%rdi)
movsd (%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x2ad08
jmp 0x2adef
cmpb $0x4e, %al
jne 0x2adb5
testq %r9, %r9
jle 0x2adef
xorl %eax, %eax
movsd (%rdx,%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax)
movsd 0x8(%rdx,%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x2ad41
jmp 0x2adef
testq %r9, %r9
jle 0x2adef
movapd 0x9466(%rip), %xmm1     # 0x341e0
xorpd %xmm0, %xmm1
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movsd -0x8(%rdx), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, -0x8(%rdi)
movsd (%rdx), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x2ad8e
jmp 0x2adef
testq %r9, %r9
jle 0x2adef
movapd 0x941e(%rip), %xmm1     # 0x341e0
xorpd %xmm0, %xmm1
xorl %eax, %eax
movsd (%rdx,%rax), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rdi,%rax)
movsd 0x8(%rdx,%rax), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x2adc8
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::vmul(double*, long, long, double)
void alglib::vmul(double *vdst,  ae_int_t stride_dst, ae_int_t n, double alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        //
        // general unoptimized case
        //
        for(i=0; i<n; i++, vdst+=stride_dst)
            *vdst *= alpha;
    }
    else
    {
        //
        // optimized case
        //
        for(i=0; i<n; i++, vdst++)
            *vdst *= alpha;
    }
}

// Assembly:
cmpq $0x1, %rsi
jne 0x2b909
testq %rdx, %rdx
jle 0x2b926
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x2b8f1
jmp 0x2b926
testq %rdx, %rdx
jle 0x2b926
shlq $0x3, %rsi
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
decq %rdx
jne 0x2b912
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::vmul(alglib::complex*, long, long, alglib::complex)
void alglib::vmul(alglib::complex *vdst, ae_int_t stride_dst, ae_int_t n, alglib::complex alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        //
        // general unoptimized case
        //
        double ax = alpha.x, ay = alpha.y;
        for(i=0; i<n; i++, vdst+=stride_dst)
        {
            double  dstx = vdst->x, dsty = vdst->y;
            vdst->x = ax*dstx-ay*dsty;
            vdst->y = ax*dsty+ay*dstx;
        }
    }
    else
    {
        //
        // optimized case
        //
        double ax = alpha.x, ay = alpha.y;
        for(i=0; i<n; i++, vdst++)
        {
            double  dstx = vdst->x, dsty = vdst->y;
            vdst->x = ax*dstx-ay*dsty;
            vdst->y = ax*dsty+ay*dstx;
        }
    }
}

// Assembly:
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
cmpq $0x1, %rsi
jne 0x2ba2f
testq %rdx, %rdx
jle 0x2ba82
movapd 0x87f2(%rip), %xmm2     # 0x341e0
xorpd %xmm1, %xmm2
movsd (%rdi), %xmm3
movsd 0x8(%rdi), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
movapd %xmm0, %xmm6
mulsd %xmm3, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%rdi)
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, 0x8(%rdi)
addq $0x10, %rdi
decq %rdx
jne 0x2b9f2
jmp 0x2ba82
testq %rdx, %rdx
jle 0x2ba82
movapd 0x87a4(%rip), %xmm2     # 0x341e0
xorpd %xmm1, %xmm2
addq $0x8, %rdi
shlq $0x4, %rsi
movsd -0x8(%rdi), %xmm3
movsd (%rdi), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
movapd %xmm0, %xmm6
mulsd %xmm3, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, -0x8(%rdi)
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rdi)
addq %rsi, %rdi
decq %rdx
jne 0x2ba48
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_vector_wrapper::ae_vector_wrapper(alglib::ae_vector_wrapper const&)
alglib::ae_vector_wrapper::ae_vector_wrapper(const alglib::ae_vector_wrapper &rhs)
{
    if( rhs.p_vec!=NULL )
    {
        p_vec = &vec;
        if( !ae_vector_init_copy(p_vec, rhs.p_vec, NULL, ae_false) )
            throw alglib::ap_error("ALGLIB: malloc error!");
    }
    else
        p_vec = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x18043(%rip), %rax     # 0x43ba0
movq %rax, (%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x2bbb5
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2597e
testb %al, %al
jne 0x2bbbd
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xbcd0(%rip), %rsi      # 0x37867
movq %rax, %rdi
callq 0x2966e
leaq 0x17fda(%rip), %rsi     # 0x43b80
leaq -0x18329(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq $0x0, 0x8(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_vector_wrapper::operator=(alglib::ae_vector_wrapper const&)
const alglib::ae_vector_wrapper& alglib::ae_vector_wrapper::operator=(const alglib::ae_vector_wrapper &rhs)
{
    if( this==&rhs )
        return *this;
    if( p_vec==&vec )
        ae_vector_clear(p_vec);
    if( rhs.p_vec!=NULL )
    {
        p_vec = &vec;
        if( !ae_vector_init_copy(p_vec, rhs.p_vec, NULL, ae_false) )
            throw alglib::ap_error("ALGLIB: malloc error!");
    }
    else
        p_vec = NULL;
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2bc87
movq %rsi, %r14
movq 0x8(%rbx), %r12
leaq 0x10(%rbx), %r15
cmpq %r15, %r12
jne 0x2bc2e
movq $0x0, (%r12)
cmpq $0x0, 0x20(%r12)
je 0x2bc16
movq 0x20(%r12), %rdi
callq *0x18(%r12)
xorl %eax, %eax
movq %rax, 0x20(%r12)
leaq -0x65f8(%rip), %rcx     # 0x2562c
movq %rcx, 0x18(%r12)
movq %rax, 0x28(%r12)
cmpq $0x0, 0x8(%r14)
je 0x2bc7f
movq %r15, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2597e
testb %al, %al
jne 0x2bc87
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xbc06(%rip), %rsi      # 0x37867
movq %rax, %rdi
callq 0x2966e
leaq 0x17f10(%rip), %rsi     # 0x43b80
leaq -0x183f3(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_vector_wrapper::setlength(long)
void alglib::ae_vector_wrapper::setlength(ae_int_t iLen)
{
    if( p_vec==NULL )
        throw alglib::ap_error("ALGLIB: setlength() error, p_vec==NULL (array was not correctly initialized)");
    if( p_vec!=&vec )
        throw alglib::ap_error("ALGLIB: setlength() error, p_vec!=&vec (attempt to resize frozen array)");
    if( !ae_vector_set_length(p_vec, iLen, 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 0x2bcd6
addq $0x10, %rax
cmpq %rax, %rdi
jne 0x2bcf4
xorl %edx, %edx
callq 0x25a42
testb %al, %al
je 0x2bd12
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xbb93(%rip), %rsi      # 0x3787d
movq %rax, %rdi
callq 0x2966e
jmp 0x2bd2e
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xbbc2(%rip), %rsi      # 0x378ca
movq %rax, %rdi
callq 0x2966e
jmp 0x2bd2e
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xbbec(%rip), %rsi      # 0x37912
movq %rax, %rdi
callq 0x2966e
leaq 0x17e4b(%rip), %rsi     # 0x43b80
leaq -0x184b8(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
jmp 0x2bd48
jmp 0x2bd48
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop