LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_set_vector(alglib_impl::x_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void ae_x_set_vector(x_vector *dst, ae_vector *src, ae_state *state)
{
    if( dst->cnt!=src->cnt || dst->datatype!=src->datatype )
    {
        if( dst->owner==OWN_AE )
            ae_free(dst->ptr);
        dst->ptr = ae_malloc((size_t)(src->cnt*ae_sizeof(src->datatype)), state);
        dst->last_action = ACT_NEW_LOCATION;
        dst->cnt = src->cnt;
        dst->datatype = src->datatype;
        dst->owner = OWN_AE;
    }
    else
        dst->last_action = ACT_SAME_LOCATION;
    if( src->cnt )
        memcpy(dst->ptr, src->ptr.p_ptr, (size_t)(src->cnt*ae_sizeof(src->datatype)));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq (%rsi), %r13
cmpq %r13, %r15
jne 0x23f8a
movq 0x8(%r14), %rdi
cmpq 0x8(%rbx), %rdi
jne 0x23f8a
leaq 0x18(%r14), %rbp
jmp 0x23fd3
cmpq $0x2, 0x10(%r14)
jne 0x23f9d
movq 0x20(%r14), %rdi
callq 0x236f7
movq (%rbx), %r13
leaq 0x10(%r14), %rbp
movq 0x8(%rbx), %rdi
callq 0x23758
imulq %rax, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x236c0
movq %rax, 0x20(%r14)
movq $0x3, 0x18(%r14)
movq (%rbx), %r15
movq %r15, (%r14)
movq 0x8(%rbx), %rdi
movq %rdi, 0x8(%r14)
movq $0x2, (%rbp)
testq %r15, %r15
je 0x2400d
movq 0x20(%r14), %r14
movq 0x28(%rbx), %rbx
callq 0x23758
imulq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_set_matrix(alglib_impl::x_matrix*, alglib_impl::ae_matrix*, alglib_impl::ae_state*)
void ae_x_set_matrix(x_matrix *dst, ae_matrix *src, ae_state *state)
{
    char *p_src_row;
    char *p_dst_row;
    ae_int_t i;
    ae_int_t row_size;
    if( dst->rows!=src->rows || dst->cols!=src->cols || dst->datatype!=src->datatype )
    {
        if( dst->owner==OWN_AE )
            ae_free(dst->ptr);
        dst->rows = src->rows;
        dst->cols = src->cols;
        dst->stride = src->cols;
        dst->datatype = src->datatype;
        dst->ptr = ae_malloc((size_t)(dst->rows*((ae_int_t)dst->stride)*ae_sizeof(src->datatype)), state);
        dst->last_action = ACT_NEW_LOCATION;
        dst->owner = OWN_AE;
    }
    else
        dst->last_action = ACT_SAME_LOCATION;
    if( src->rows!=0 && src->cols!=0 )
    {
        p_src_row = (char*)(src->ptr.pp_void[0]);
        p_dst_row = (char*)dst->ptr;
        row_size = ae_sizeof(src->datatype)*src->cols;
        for(i=0; i<src->rows; i++, p_src_row+=src->stride*ae_sizeof(src->datatype), p_dst_row+=dst->stride*ae_sizeof(src->datatype))
            memcpy(p_dst_row, p_src_row, (size_t)(row_size));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rbp
movq (%rsi), %rax
cmpq %rax, %rbp
movq %rdi, (%rsp)
jne 0x2405d
movq 0x8(%r14), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x2405d
movq 0x18(%r14), %rcx
cmpq 0x18(%rbx), %rcx
jne 0x2405d
movq $0x2, 0x28(%r14)
jmp 0x240b6
cmpq $0x2, 0x20(%r14)
jne 0x24070
movq 0x30(%r14), %rdi
callq 0x236f7
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %r12
movq %r12, 0x8(%r14)
movq %r12, 0x10(%r14)
movq 0x18(%rbx), %rdi
movq %rdi, 0x18(%r14)
imulq %rax, %r12
callq 0x23758
imulq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x236c0
movq %rax, 0x30(%r14)
movq $0x3, 0x28(%r14)
movq $0x2, 0x20(%r14)
movq (%rbx), %rbp
testq %rbp, %rbp
je 0x24121
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x24121
movq 0x18(%rbx), %rdi
movq 0x38(%rbx), %rax
movq (%rax), %r15
movq (%rsp), %rax
movq 0x30(%rax), %r12
callq 0x23758
movq %rax, %r13
imulq %r14, %r13
xorl %r14d, %r14d
cmpq %rbp, %r14
jge 0x24121
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x31d0
incq %r14
movq 0x10(%rbx), %rbp
movq 0x18(%rbx), %rdi
callq 0x23758
imulq %rax, %rbp
addq %rbp, %r15
movq (%rsp), %rcx
imulq 0x10(%rcx), %rax
addq %rax, %r12
movq (%rbx), %rbp
jmp 0x240e6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_attach_to_vector(alglib_impl::x_vector*, alglib_impl::ae_vector*)
void ae_x_attach_to_vector(x_vector *dst, ae_vector *src)
{
    if( dst->owner==OWN_AE )
        ae_free(dst->ptr);
    dst->ptr = src->ptr.p_ptr;
    dst->last_action = ACT_NEW_LOCATION;
    dst->cnt = src->cnt;
    dst->datatype = src->datatype;
    dst->owner = OWN_CALLER;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x2, 0x10(%rdi)
jne 0x2414a
movq 0x20(%rbx), %rdi
callq 0x236f7
movq 0x28(%r14), %rax
movq %rax, 0x20(%rbx)
movq $0x3, 0x18(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_attach_to_matrix(alglib_impl::x_matrix*, alglib_impl::ae_matrix*)
void ae_x_attach_to_matrix(x_matrix *dst, ae_matrix *src)
{
    if( dst->owner==OWN_AE )
            ae_free(dst->ptr);
    dst->rows = src->rows;
    dst->cols = src->cols;
    dst->stride = src->stride;
    dst->datatype = src->datatype;
    dst->ptr = &(src->ptr.pp_double[0][0]);
    dst->last_action = ACT_NEW_LOCATION;
    dst->owner = OWN_CALLER;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x2, 0x20(%rdi)
jne 0x2418b
movq 0x30(%rbx), %rdi
callq 0x236f7
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x38(%r14), %rax
movq (%rax), %rax
movq %rax, 0x30(%rbx)
movq $0x3, 0x28(%rbx)
movq $0x1, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_vector_clear(alglib_impl::x_vector*)
void x_vector_clear(x_vector *dst)
{
    if( dst->owner==OWN_AE )
        aligned_free(dst->ptr);
    dst->ptr = NULL;
    dst->cnt = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x2, 0x10(%rdi)
jne 0x241d2
movq 0x20(%rbx), %rdi
callq 0x236b1
andq $0x0, 0x20(%rbx)
andq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_randomreal(alglib_impl::ae_state*)
double ae_randomreal(ae_state *state)
{
    int i1 = rand();
    int i2 = rand();
    double mx;
    while(i1==RAND_MAX)
        i1 =rand();
    while(i2==RAND_MAX)
        i2 =rand();
    mx = RAND_MAX;
    return (i1+i2/mx)/mx;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x30a0
movl %eax, %ebx
callq 0x30a0
movl %eax, %ebp
cmpl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jne 0x244ed
callq 0x30a0
movl %eax, %ebx
jmp 0x244d5
callq 0x30a0
movl %eax, %ebp
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0x244e6
cvtsi2sd %ebx, %xmm1
cvtsi2sd %ebp, %xmm0
movsd 0xbcd3(%rip), %xmm2     # 0x301d8
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_is_symmetric(alglib_impl::x_matrix*)
ae_bool x_is_symmetric(x_matrix *a)
{
    double mx, err;
    ae_bool nonfinite;
    ae_state _alglib_env_state;
    if( a->datatype!=DT_REAL )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    ae_state_init(&_alglib_env_state);
    mx = 0;
    err = 0;
    nonfinite = ae_false;
    is_symmetric_rec_diag_stat(a, 0, (ae_int_t)a->rows, &nonfinite, &mx, &err, &_alglib_env_state);
    if( nonfinite )
        return ae_false;
    if( mx==0 )
        return ae_true;
    return err/mx<=1.0E-14;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpq $0x3, 0x18(%rdi)
jne 0x2460c
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq (%rdi), %r15
jne 0x2460c
movb $0x1, %bl
testq %r15, %r15
je 0x2460e
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
leaq 0x20(%rsp), %r8
andq $0x0, (%r8)
leaq 0x18(%rsp), %r9
andq $0x0, (%r9)
leaq 0x17(%rsp), %r12
movb $0x0, (%r12)
movq %rbx, (%rsp)
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2461c
cmpb $0x0, (%r12)
jne 0x2460e
movsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb $0x1, %bl
jne 0x245f1
jnp 0x2460e
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0xec2d(%rip), %xmm0     # 0x33230
ucomisd %xmm1, %xmm0
setae %bl
jmp 0x2460e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_is_hermitian(alglib_impl::x_matrix*)
ae_bool x_is_hermitian(x_matrix *a)
{
    double mx, err;
    ae_bool nonfinite;
    ae_state _alglib_env_state;
    if( a->datatype!=DT_COMPLEX )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    ae_state_init(&_alglib_env_state);
    mx = 0;
    err = 0;
    nonfinite = ae_false;
    is_hermitian_rec_diag_stat(a, 0, (ae_int_t)a->rows, &nonfinite, &mx, &err, &_alglib_env_state);
    if( nonfinite )
        return ae_false;
    if( mx==0 )
        return ae_true;
    return err/mx<=1.0E-14;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpq $0x4, 0x18(%rdi)
jne 0x248b2
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq (%rdi), %r15
jne 0x248b2
movb $0x1, %bl
testq %r15, %r15
je 0x248b4
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
leaq 0x20(%rsp), %r8
andq $0x0, (%r8)
leaq 0x18(%rsp), %r9
andq $0x0, (%r9)
leaq 0x17(%rsp), %r12
movb $0x0, (%r12)
movq %rbx, (%rsp)
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x248c2
cmpb $0x0, (%r12)
jne 0x248b4
movsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb $0x1, %bl
jne 0x24897
jnp 0x248b4
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0xe987(%rip), %xmm0     # 0x33230
ucomisd %xmm1, %xmm0
setae %bl
jmp 0x248b4
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_force_symmetric(alglib_impl::x_matrix*)
ae_bool x_force_symmetric(x_matrix *a)
{
    if( a->datatype!=DT_REAL )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    force_symmetric_rec_diag_stat(a, 0, (ae_int_t)a->rows);
    return ae_true;
}

// Assembly:
pushq %rbx
cmpq $0x3, 0x18(%rdi)
jne 0x24c1b
movq 0x8(%rdi), %rdx
cmpq (%rdi), %rdx
jne 0x24c1b
movb $0x1, %bl
testq %rdx, %rdx
je 0x24c1d
xorl %esi, %esi
callq 0x24c21
jmp 0x24c1d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::force_symmetric_rec_diag_stat(alglib_impl::x_matrix*, long, long)
static void force_symmetric_rec_diag_stat(x_matrix *a, ae_int_t offset, ae_int_t len)
{
    double *p, *prow, *pcol;
    ae_int_t i, j;
    
    /* try to split problem into two smaller ones */
    if( len>x_nb )
    {
        ae_int_t n1, n2;
        x_split_length(len, x_nb, &n1, &n2);
        force_symmetric_rec_diag_stat(a, offset, n1);
        force_symmetric_rec_diag_stat(a, offset+n1, n2);
        force_symmetric_rec_off_stat(a, offset+n1, offset, n2, n1);
        return;
    }
    
    /* base case */
    p = (double*)(a->ptr)+offset*a->stride+offset;
    for(i=0; i<len; i++)
    {
        pcol = p+i;
        prow = p+i*a->stride;
        for(j=0; j<i; j++,pcol+=a->stride,prow++)
            *pcol = *prow;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x10, %rdx
jle 0x24c99
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %rdx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2e5da
movq (%r15), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x24c21
leaq (%r15,%rbx), %r13
movq (%r12), %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x24c21
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x2ebb7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x10(%r14), %rax
movq %rax, %rcx
imulq %rbx, %rcx
shlq $0x3, %rcx
addq 0x30(%r14), %rcx
leaq (%rcx,%rbx,8), %rcx
xorl %esi, %esi
testq %rdx, %rdx
cmovleq %rsi, %rdx
shlq $0x3, %rax
movq %rcx, %rdi
cmpq %rdx, %rsi
je 0x24c8b
movq %rcx, %r8
xorl %r9d, %r9d
cmpq %r9, %rsi
je 0x24ce3
movsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8)
incq %r9
addq %rax, %r8
jmp 0x24ccb
incq %rsi
addq %rax, %rdi
addq $0x8, %rcx
jmp 0x24cc0
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_force_hermitian(alglib_impl::x_matrix*)
ae_bool x_force_hermitian(x_matrix *a)
{
    if( a->datatype!=DT_COMPLEX )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    force_hermitian_rec_diag_stat(a, 0, (ae_int_t)a->rows);
    return ae_true;
}

// Assembly:
pushq %rbx
cmpq $0x4, 0x18(%rdi)
jne 0x24d10
movq 0x8(%rdi), %rdx
cmpq (%rdi), %rdx
jne 0x24d10
movb $0x1, %bl
testq %rdx, %rdx
je 0x24d12
xorl %esi, %esi
callq 0x24d16
jmp 0x24d12
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::force_hermitian_rec_diag_stat(alglib_impl::x_matrix*, long, long)
static void force_hermitian_rec_diag_stat(x_matrix *a, ae_int_t offset, ae_int_t len)
{
    ae_complex *p, *prow, *pcol;
    ae_int_t i, j;
    
    /* try to split problem into two smaller ones */
    if( len>x_nb )
    {
        ae_int_t n1, n2;
        x_split_length(len, x_nb, &n1, &n2);
        force_hermitian_rec_diag_stat(a, offset, n1);
        force_hermitian_rec_diag_stat(a, offset+n1, n2);
        force_hermitian_rec_off_stat(a, offset+n1, offset, n2, n1);
        return;
    }
    
    /* base case */
    p = (ae_complex*)(a->ptr)+offset*a->stride+offset;
    for(i=0; i<len; i++)
    {
        pcol = p+i;
        prow = p+i*a->stride;
        for(j=0; j<i; j++,pcol+=a->stride,prow++)
            *pcol = *prow;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x10, %rdx
jle 0x24d8e
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %rdx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2e5da
movq (%r15), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x24d16
leaq (%r15,%r14), %r13
movq (%r12), %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x24d16
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x2eceb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %r8
movq %rax, %rsi
imulq %r14, %rsi
shlq $0x4, %rsi
movq %r14, %rcx
shlq $0x4, %rcx
addq %r8, %rcx
addq %rsi, %rcx
xorl %esi, %esi
testq %rdx, %rdx
cmovleq %rsi, %rdx
movq %rax, %rdi
shlq $0x4, %rdi
addq $0x10, %rdi
imulq %r14, %rdi
addq %r8, %rdi
xorl %r8d, %r8d
cmpq %rdx, %r8
je 0x24d80
movq %r8, %r9
shlq $0x4, %r9
addq %rcx, %r9
movq %rax, %r10
imulq %rsi, %r10
addq %rdi, %r10
xorl %r11d, %r11d
cmpq %r11, %rsi
je 0x24e0c
leaq (%r10,%r11), %rax
movups (%rax), %xmm0
movups %xmm0, (%r9)
movq 0x10(%rbx), %rax
movq %rax, %r14
shlq $0x4, %r14
addq %r14, %r9
addq $0x10, %r11
jmp 0x24de8
incq %r8
addq $0x10, %rsi
jmp 0x24dcc
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_bool2str(bool, char*, alglib_impl::ae_state*)
void ae_bool2str(ae_bool v, char *buf, ae_state *state)
{
    char c = v ? '1' : '0';
    ae_int_t i;
    for(i=0; i<AE_SER_ENTRY_LENGTH; i++)
        buf[i] = c;
    buf[AE_SER_ENTRY_LENGTH] = 0;
}

// Assembly:
orb $0x30, %dil
xorl %eax, %eax
cmpq $0xb, %rax
je 0x24f70
movb %dil, (%rsi,%rax)
incq %rax
jmp 0x24f61
movb $0x0, 0xb(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_str2bool(char const*, alglib_impl::ae_state*, char const**)
ae_bool ae_str2bool(const char *buf, ae_state *state, const char **pasttheend)
{
    ae_bool was0, was1;
    const char *emsg = "ALGLIB: unable to read boolean value from stream";
    
    was0 = ae_false;
    was1 = ae_false;
    while( *buf==' ' || *buf=='\t' || *buf=='\n' || *buf=='\r' )
        buf++;
    while( *buf!=' ' && *buf!='\t' && *buf!='\n' && *buf!='\r' && *buf!=0 )
    {
        if( *buf=='0' )
        {
            was0 = ae_true;
            buf++;
            continue;
        }
        if( *buf=='1' )
        {
            was1 = ae_true;
            buf++;
            continue;
        }
        ae_break(state, ERR_ASSERTION_FAILED, emsg);
    }
    *pasttheend = buf;
    if( (!was0) && (!was1) )
        ae_break(state, ERR_ASSERTION_FAILED, emsg);
    if( was0 && was1 )
        ae_break(state, ERR_ASSERTION_FAILED, emsg);
    return was1 ? ae_true : ae_false;
}

// Assembly:
pushq %rax
movabsq $0x100002600, %rax      # imm = 0x100002600
movzbl (%rdi), %r8d
cmpq $0x20, %r8
ja 0x24f95
btq %r8, %rax
jae 0x24f95
incq %rdi
jmp 0x24f80
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x31, %r8b
ja 0x24fe5
movzbl %r8b, %r8d
cmpq $0x30, %r8
je 0x24fb3
cmpq $0x31, %r8
jne 0x24fbe
movb $0x1, %cl
jmp 0x24fb5
movb $0x1, %al
movb 0x1(%rdi), %r8b
incq %rdi
jmp 0x24f99
movabsq $0x100002601, %r9       # imm = 0x100002601
btq %r8, %r9
jae 0x24fe5
movq %rdi, (%rdx)
testb $0x1, %al
je 0x24fe0
testb $0x1, %cl
jne 0x24fe5
notb %al
andb $0x1, %al
popq %rcx
retq
testb $0x1, %cl
jne 0x24fda
leaq 0xe8b8(%rip), %rdx      # 0x338a4
pushq $0x3
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x235f7
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_double2str(double, char*, alglib_impl::ae_state*)
void ae_double2str(double v, char *buf, ae_state *state)
{
    union _u
    {
        double dval;
        unsigned char bytes[9];
    } u;
    ae_int_t i;
    ae_int_t sixbits[12];

    /*
     * handle special quantities
     */
    if( ae_isnan(v, state) )
    {
        const char *s = ".nan_______";
        memcpy(buf, s, strlen(s)+1);
        return;
    }
    if( ae_isposinf(v, state) )
    {
        const char *s = ".posinf____";
        memcpy(buf, s, strlen(s)+1);
        return;
    }
    if( ae_isneginf(v, state) )
    {
        const char *s = ".neginf____";
        memcpy(buf, s, strlen(s)+1);
        return;
    }
    
    /*
     * process general case:
     * 1. copy v to array of chars
     * 2. set 9th byte of u.bytes to zero in order to
     *    simplify conversion to six-bit representation
     * 3. convert to little endian (if needed)
     * 4. convert to six-bit representation
     *    (last 12th element of sixbits is always zero, we do not output it)
     */
    u.dval = v;
    u.bytes[8] = 0;
    if( state->endianness==AE_BIG_ENDIAN )
    {
        for(i=0; i<sizeof(double)/2; i++)
        {
            unsigned char tc;
            tc = u.bytes[i];
            u.bytes[i] = u.bytes[sizeof(double)-1-i];
            u.bytes[sizeof(double)-1-i] = tc;
        }
    }
    ae_threebytes2foursixbits(u.bytes+0, sixbits+0);
    ae_threebytes2foursixbits(u.bytes+3, sixbits+4);
    ae_threebytes2foursixbits(u.bytes+6, sixbits+8);
    for(i=0; i<AE_SER_ENTRY_LENGTH; i++)
        buf[i] = ae_sixbits2char(sixbits[i]);
    buf[AE_SER_ENTRY_LENGTH] = 0x00;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdi
callq 0x243cc
testb %al, %al
je 0x2522c
movabsq $0x5f5f5f5f6e616e2e, %rax # imm = 0x5F5F5F5F6E616E2E
jmp 0x25266
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x243dc
testb %al, %al
je 0x2524a
movabsq $0x5f666e69736f702e, %rax # imm = 0x5F666E69736F702E
jmp 0x25266
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x24404
testb %al, %al
je 0x2527b
movabsq $0x5f666e6967656e2e, %rax # imm = 0x5F666E6967656E2E
movq %rax, (%rbx)
movl $0x5f5f5f, 0x8(%rbx)    # imm = 0x5F5F5F
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
cmpq $0x2, (%r14)
jne 0x252b6
leaq 0x10(%rsp), %rax
pushq $0x7
popq %rcx
cmpq $0x3, %rcx
je 0x252b6
movb (%rax), %dl
movb 0x10(%rsp,%rcx), %sil
movb %sil, (%rax)
movb %dl, 0x10(%rsp,%rcx)
decq %rcx
incq %rax
jmp 0x2529a
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x24eee
leaq 0x13(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x24eee
leaq 0x16(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x24eee
xorl %eax, %eax
leaq 0xdf64(%rip), %rcx      # 0x33250
cmpq $0xb, %rax
je 0x2530a
movq 0x20(%rsp,%rax,8), %rsi
movb $0x3f, %dl
cmpq $0x3f, %rsi
ja 0x25302
movb (%rsi,%rcx), %dl
movb %dl, (%rbx,%rax)
incq %rax
jmp 0x252ec
movb $0x0, 0xb(%rbx)
jmp 0x25270
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xa(%rsp), %r15
movl %esi, %edi
movq %r15, %rsi
callq 0x24f5b
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
pushq $0x5
popq %rcx
cqto
idivq %rcx
movq %rdx, %r12
movq %r15, %rdi
callq 0x30f0
addq %rsp, %rax
addq $0xa, %rax
testq %r12, %r12
je 0x25600
movw $0x20, (%rax)
jmp 0x25609
movb $0x0, 0x2(%rax)
movw $0xa0d, (%rax)          # imm = 0xA0D
leaq 0xa(%rsp), %rdi
callq 0x30f0
movq %rax, %r15
movq 0x20(%rbx), %rax
addq %r15, %rax
cmpq 0x18(%rbx), %rax
jg 0x25664
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
cmpq $0xa, %rax
je 0x25646
cmpq $0xb, %rax
jne 0x25664
movq 0x28(%rbx), %rdi
leaq 0xa(%rsp), %rsi
callq 0x3430
jmp 0x25658
movq 0x30(%rbx), %rdi
leaq 0xa(%rsp), %rsi
callq 0x33f0
addq %r15, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe2ef(%rip), %rdx      # 0x3395a
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x235f7
// File: /workspace/github_cpp_makefile_star2_O2/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 0x251fe
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
pushq $0x5
popq %rcx
cqto
idivq %rcx
movq %rdx, %r12
movq %r15, %rdi
callq 0x30f0
addq %rsp, %rax
addq $0xa, %rax
testq %r12, %r12
je 0x2578d
movw $0x20, (%rax)
jmp 0x25796
movb $0x0, 0x2(%rax)
movw $0xa0d, (%rax)          # imm = 0xA0D
leaq 0xa(%rsp), %rdi
callq 0x30f0
movq %rax, %r15
movq 0x20(%rbx), %rax
addq %r15, %rax
cmpq 0x18(%rbx), %rax
jg 0x257f1
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
cmpq $0xa, %rax
je 0x257d3
cmpq $0xb, %rax
jne 0x257f1
movq 0x28(%rbx), %rdi
leaq 0xa(%rsp), %rsi
callq 0x3430
jmp 0x257e5
movq 0x30(%rbx), %rdi
leaq 0xa(%rsp), %rsi
callq 0x33f0
addq %r15, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe162(%rip), %rdx      # 0x3395a
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x235f7
// File: /workspace/github_cpp_makefile_star2_O2/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 %xmm0, %xmm2
movapd 0xd968(%rip), %xmm0     # 0x33210
andpd %xmm0, %xmm2
andpd %xmm0, %xmm1
movapd %xmm2, %xmm0
maxsd %xmm1, %xmm0
minsd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x258c9
jp 0x258c9
retq
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
addsd 0xa91f(%rip), %xmm2     # 0x301f8
sqrtsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25920
jp 0x25920
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_O2/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 0x2594d
jnp 0x2594e
retq
movsd -0x18(%rsp), %xmm0
cmpneqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd85d(%rip), %xmm4     # 0x33210
movapd %xmm3, %xmm5
andpd %xmm4, %xmm5
andpd %xmm2, %xmm4
ucomisd %xmm5, %xmm4
movapd 0xa7e5(%rip), %xmm5     # 0x301b0
xorpd %xmm0, %xmm5
jbe 0x259ff
movapd %xmm3, %xmm4
divsd %xmm2, %xmm4
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0]
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm1, %xmm4
addpd %xmm0, %xmm4
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm4
jmp 0x25a2f
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm0, %xmm4
unpcklpd %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0]
addpd %xmm4, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movapd %xmm1, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
movapd %xmm4, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25a7d
jp 0x25a7d
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_O2/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 0x25aad
jnp 0x25aae
retq
movsd -0x18(%rsp), %xmm0
cmpneqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd70d(%rip), %xmm3     # 0x33210
movapd %xmm2, %xmm4
andpd %xmm3, %xmm4
andpd %xmm1, %xmm3
ucomisd %xmm4, %xmm3
jbe 0x25b43
movapd %xmm2, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movapd 0xa683(%rip), %xmm1     # 0x301b0
xorpd %xmm0, %xmm1
mulsd %xmm3, %xmm1
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm0
jmp 0x25b6f
movapd %xmm1, %xmm3
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm3
xorpd 0xa651(%rip), %xmm0     # 0x301b0
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm3
movapd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r8b
andb $-0x21, %r8b
movq %rsi, %r10
xorq $0x1, %r10
movq %rcx, %r11
xorq $0x1, %r11
xorl %eax, %eax
testq %r9, %r9
cmovgq %r9, %rax
orq %r10, %r11
je 0x25d8f
cmpb $0x4e, %r8b
jne 0x25db2
shlq $0x4, %rcx
shlq $0x4, %rsi
subq $0x1, %rax
jb 0x25e16
movups (%rdx), %xmm0
movups %xmm0, (%rdi)
addq %rcx, %rdx
addq %rsi, %rdi
jmp 0x25d77
xorl %ecx, %ecx
cmpb $0x4e, %r8b
jne 0x25deb
subq $0x1, %rax
jb 0x25e16
leaq (%rdx,%rcx), %rsi
leaq (%rdi,%rcx), %r8
movups (%rsi), %xmm0
movups %xmm0, (%r8)
addq $0x10, %rcx
jmp 0x25d97
addq $0x8, %rdx
shlq $0x4, %rcx
addq $0x8, %rdi
shlq $0x4, %rsi
movaps 0xa3e7(%rip), %xmm0     # 0x301b0
subq $0x1, %rax
jb 0x25e16
movsd -0x8(%rdx), %xmm1
movsd %xmm1, -0x8(%rdi)
movsd (%rdx), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi)
addq %rcx, %rdx
addq %rsi, %rdi
jmp 0x25dc9
movaps 0xa3be(%rip), %xmm0     # 0x301b0
subq $0x1, %rax
jb 0x25e16
movsd (%rdx,%rcx), %xmm1
movsd %xmm1, (%rdi,%rcx)
movsd 0x8(%rdx,%rcx), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x8(%rdi,%rcx)
addq $0x10, %rcx
jmp 0x25df2
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25f3d
cmpb $0x4e, %al
jne 0x25f6c
xorl %eax, %eax
testq %r9, %r9
cmovgq %r9, %rax
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
shlq $0x4, %rcx
shlq $0x4, %rsi
subq $0x1, %rax
jb 0x25fda
movupd (%rdx), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
addq %rcx, %rdx
addq %rsi, %rdi
jmp 0x25f1f
cmpb $0x4e, %al
jne 0x25fa7
xorl %eax, %eax
testq %r9, %r9
cmovleq %rax, %r9
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
subq $0x1, %r9
jb 0x25fda
movupd (%rdx,%rax), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi,%rax)
addq $0x10, %rax
jmp 0x25f4e
movapd 0xa23c(%rip), %xmm1     # 0x301b0
xorl %eax, %eax
testq %r9, %r9
cmovgq %r9, %rax
xorpd %xmm0, %xmm1
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shlq $0x4, %rcx
shlq $0x4, %rsi
subq $0x1, %rax
jb 0x25fda
movupd (%rdx), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
addq %rcx, %rdx
addq %rsi, %rdi
jmp 0x25f8d
movapd 0xa201(%rip), %xmm1     # 0x301b0
xorpd %xmm0, %xmm1
xorl %eax, %eax
testq %r9, %r9
cmovleq %rax, %r9
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
subq $0x1, %r9
jb 0x25fda
movupd (%rdx,%rax), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi,%rax)
addq $0x10, %rax
jmp 0x25fc0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdx, %rdx
cmovgq %rdx, %rax
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
cmpq $0x1, %rsi
jne 0x26651
movapd 0x9b8f(%rip), %xmm2     # 0x301b0
subq $0x1, %rax
jb 0x2668c
movupd (%rdi), %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
xorpd %xmm2, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulpd %xmm1, %xmm4
mulpd %xmm0, %xmm3
addpd %xmm4, %xmm3
movupd %xmm3, (%rdi)
addq $0x10, %rdi
jmp 0x26621
shlq $0x4, %rsi
movapd 0x9b53(%rip), %xmm2     # 0x301b0
subq $0x1, %rax
jb 0x2668c
movupd (%rdi), %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
xorpd %xmm2, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulpd %xmm1, %xmm4
mulpd %xmm0, %xmm3
addpd %xmm4, %xmm3
movupd %xmm3, (%rdi)
addq %rsi, %rdi
jmp 0x2665d
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r8, %rax
movq %rdx, %r8
movq %rsi, %rdx
xorq $0x1, %rdx
movq %rcx, %r9
xorq $0x1, %r9
orq %rdx, %r9
je 0x266da
xorl %edx, %edx
testq %rax, %rax
cmovgq %rax, %rdx
shlq $0x3, %rcx
shlq $0x3, %rsi
xorpd %xmm0, %xmm0
subq $0x1, %rdx
jb 0x2675d
movsd (%rdi), %xmm1
mulsd (%r8), %xmm1
addsd %xmm1, %xmm0
addq %rcx, %r8
addq %rsi, %rdi
jmp 0x266bb
pushq $0x4
popq %rcx
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x2673b
movsd 0x8(%rdi), %xmm1
mulsd 0x8(%r8), %xmm1
movsd (%rdi), %xmm2
mulsd (%r8), %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rdi), %xmm1
mulsd 0x10(%r8), %xmm1
addsd %xmm2, %xmm1
movsd 0x18(%rdi), %xmm2
mulsd 0x18(%r8), %xmm2
addsd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rcx
addq $0x20, %rdi
addq $0x20, %r8
jmp 0x266ef
xorl %eax, %eax
testq %rdx, %rdx
cmovleq %rax, %rdx
cmpq %rax, %rdx
je 0x2675d
movsd (%rdi,%rax,8), %xmm1
mulsd (%r8,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x26744
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r9
movq %rsi, %rax
xorq $0x1, %rax
movq %rcx, %rdx
xorq $0x1, %rdx
orq %rax, %rdx
je 0x2679c
xorl %eax, %eax
testq %r8, %r8
cmovgq %r8, %rax
shlq $0x3, %rcx
shlq $0x3, %rsi
subq $0x1, %rax
jb 0x267e5
movsd (%r9), %xmm0
movsd %xmm0, (%rdi)
addq %rcx, %r9
addq %rsi, %rdi
jmp 0x26785
pushq $0x2
popq %rcx
movq %r8, %rax
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
subq $0x1, %rax
jb 0x267d4
movsd (%r9,%rcx), %xmm0
movsd %xmm0, (%rdi,%rcx)
movsd 0x8(%r9,%rcx), %xmm0
movsd %xmm0, 0x8(%rdi,%rcx)
addq $0x10, %rcx
jmp 0x267b0
testb $0x1, %r8b
je 0x267e5
movsd (%r9,%rcx), %xmm0
movsd %xmm0, (%rdi,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r9
movq %rsi, %rax
xorq $0x1, %rax
movq %rcx, %rdx
xorq $0x1, %rdx
orq %rax, %rdx
je 0x268ca
xorl %eax, %eax
testq %r8, %r8
cmovgq %r8, %rax
shlq $0x3, %rcx
shlq $0x3, %rsi
subq $0x1, %rax
jb 0x2691b
movsd (%r9), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rcx, %r9
addq %rsi, %rdi
jmp 0x268af
pushq $0x2
popq %rcx
movq %r8, %rax
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
subq $0x1, %rax
jb 0x2690a
movsd (%r9,%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rcx)
movsd 0x8(%r9,%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi,%rcx)
addq $0x10, %rcx
jmp 0x268de
testb $0x1, %r8b
je 0x2691b
mulsd (%r9,%rcx), %xmm0
movsd %xmm0, (%rdi,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdx, %rdx
cmovgq %rdx, %rax
cmpq $0x1, %rsi
jne 0x26b31
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x26b4c
movsd (%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rcx,8)
incq %rcx
jmp 0x26b19
shlq $0x3, %rsi
subq $0x1, %rax
jb 0x26b4c
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
jmp 0x26b35
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x38, %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x26bcb
leaq 0x8(%r14), %rdi
movzbl %bpl, %ebp
pushq $0x2
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x26bcb
leaq 0x68(%r14), %rdi
pushq $0x3
popq %rdx
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x239a5
testb %al, %al
je 0x26bcb
addq $0x98, %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
movl %ebp, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x239a5
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/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 0x23a2b
testb %al, %al
je 0x26c48
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
movzbl %bpl, %ebp
movq %r15, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x26c48
leaq 0x68(%rbx), %rdi
leaq 0x68(%r14), %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x26c48
movl $0x98, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x23a2b
testb %al, %al
je 0x26c48
movl (%r14), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x26c4a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq