LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25b02
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x25b02
movq -0x8(%rax), %rdi
callq 0x32e0
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_O3/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 0x25b52
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x25b52
movq -0x8(%rax), %rdi
callq 0x32e0
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_isneginf_stateless(double, long)
ae_bool ae_isneginf_stateless(double x, ae_int_t endianness)
{
    union _u
    {
        double a;
        ae_int32_t p[2];
    } u;
    ae_int32_t high, low;
    u.a = x;
    if( endianness==AE_LITTLE_ENDIAN )
    {
        high = u.p[1];
        low  = u.p[0];
    }
    else
    {
        high = u.p[0];
        low  = u.p[1];
    }
    
    /* this code is a bit tricky to avoid comparison of high with 0xFFF00000, which may be unsafe with some buggy compilers */
    return ((high&0x7FFFFFFF)==0x7FF00000) && (high!=(ae_int32_t)0x7FF00000) && (low==0);
}

// Assembly:
movq %xmm0, %rcx
movq %rcx, %rax
shrq $0x20, %rax
cmpq $0x1, %rdi
movl %eax, %edx
cmovnel %ecx, %edx
movl %edx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl $0x7ff00000, %r8d       # imm = 0x7FF00000
cmpl %r8d, %esi
setne %sil
cmpl %r8d, %edx
sete %dl
orb %sil, %dl
jne 0x25d2a
cmpq $0x1, %rdi
movl %ecx, %ecx
cmoveq %rcx, %rax
testq %rax, %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x30b0
movl %eax, %ebx
callq 0x30b0
movl %eax, %ebp
cmpl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jne 0x25f11
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x25f03
movl %eax, %ebx
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0x25f27
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x25f19
movl %eax, %ebp
cvtsi2sd %ebx, %xmm1
cvtsi2sd %ebp, %xmm0
movsd 0xd2a1(%rip), %xmm2     # 0x331d8
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::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 %r14
pushq %rbx
subq $0x78, %rsp
cmpq $0x3, 0x18(%rdi)
jne 0x26070
movq 0x8(%rdi), %rdx
cmpq (%rdi), %rdx
jne 0x26070
movb $0x1, %bl
testq %rdx, %rdx
je 0x26072
leaq 0x50(%rsp), %rax
movq %rax, (%rax)
xorl %ebx, %ebx
movq %rbx, 0x8(%rax)
movl $0x1, %ecx
movq %rcx, 0x10(%rax)
movq %rax, -0x8(%rax)
leaq 0xd195(%rip), %rsi      # 0x33181
movq %rsi, 0x20(%rax)
movq %rcx, -0x28(%rax)
movapd 0x10214(%rip), %xmm0    # 0x36210
movupd %xmm0, -0x20(%rax)
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
movq %rcx, -0x10(%rax)
leaq 0x20(%rsp), %r8
movq %rbx, (%r8)
leaq 0x18(%rsp), %r9
movq %rbx, (%r9)
leaq 0x17(%rsp), %r14
movb $0x0, (%r14)
leaq 0x28(%rsp), %rax
movq %rax, (%rsp)
xorl %esi, %esi
movq %r14, %rcx
callq 0x2607c
cmpb $0x0, (%r14)
jne 0x26072
movsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb $0x1, %bl
jne 0x26055
jnp 0x26072
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x107a9(%rip), %xmm0    # 0x36810
ucomisd %xmm1, %xmm0
setae %bl
jmp 0x26072
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x78, %rsp
cmpq $0x4, 0x18(%rdi)
jne 0x2636e
movq 0x8(%rdi), %rdx
cmpq (%rdi), %rdx
jne 0x2636e
movb $0x1, %bl
testq %rdx, %rdx
je 0x26370
leaq 0x50(%rsp), %rax
movq %rax, (%rax)
xorl %ebx, %ebx
movq %rbx, 0x8(%rax)
movl $0x1, %ecx
movq %rcx, 0x10(%rax)
movq %rax, -0x8(%rax)
leaq 0xce97(%rip), %rsi      # 0x33181
movq %rsi, 0x20(%rax)
movq %rcx, -0x28(%rax)
movapd 0xff16(%rip), %xmm0     # 0x36210
movupd %xmm0, -0x20(%rax)
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
movq %rcx, -0x10(%rax)
leaq 0x20(%rsp), %r8
movq %rbx, (%r8)
leaq 0x18(%rsp), %r9
movq %rbx, (%r9)
leaq 0x17(%rsp), %r14
movb $0x0, (%r14)
leaq 0x28(%rsp), %rax
movq %rax, (%rsp)
xorl %esi, %esi
movq %r14, %rcx
callq 0x2637a
cmpb $0x0, (%r14)
jne 0x26370
movsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb $0x1, %bl
jne 0x26353
jnp 0x26370
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x104ab(%rip), %xmm0    # 0x36810
ucomisd %xmm1, %xmm0
setae %bl
jmp 0x26370
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2671c
movq 0x8(%rdi), %rdx
cmpq (%rdi), %rdx
jne 0x2671c
movb $0x1, %bl
testq %rdx, %rdx
je 0x2671e
xorl %esi, %esi
callq 0x26722
jmp 0x2671e
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x11, %rdx
jl 0x26755
movq %rbx, %r12
andq $0xf, %r12
je 0x267b3
movabsq $0x7ffffffffffffff0, %rax # imm = 0x7FFFFFFFFFFFFFF0
andq %rax, %rbx
jmp 0x267e1
testq %rbx, %rbx
jle 0x267a9
movq 0x10(%r15), %rax
movq %rax, %rcx
imulq %r14, %rcx
shlq $0x3, %rcx
addq 0x30(%r15), %rcx
leaq (%rcx,%r14,8), %rcx
shlq $0x3, %rax
xorl %edx, %edx
movq %rcx, %rsi
testq %rdx, %rdx
je 0x2679a
movq %rsi, %rdi
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rdi)
incq %r8
addq %rax, %rdi
cmpq %r8, %rdx
jne 0x26785
incq %rdx
addq $0x8, %rsi
addq %rax, %rcx
cmpq %rbx, %rdx
jne 0x2677a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %r12
shrq %r12
subq %r12, %rbx
leaq 0xf(%rbx), %rcx
testq %rbx, %rbx
cmovnsq %rbx, %rcx
andq $-0x10, %rcx
movq %rbx, %rax
subq %rcx, %rax
je 0x267e1
movl $0x10, %ecx
subq %rax, %rcx
addq %rcx, %rbx
subq %rcx, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x26722
leaq (%rbx,%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x26722
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x324a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2683f
movq 0x8(%rdi), %rdx
cmpq (%rdi), %rdx
jne 0x2683f
movb $0x1, %bl
testq %rdx, %rdx
je 0x26841
xorl %esi, %esi
callq 0x26845
jmp 0x26841
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x11, %rdx
jl 0x2687c
movq %rbx, %r12
andq $0xf, %r12
je 0x26909
movabsq $0x7ffffffffffffff0, %rax # imm = 0x7FFFFFFFFFFFFFF0
andq %rax, %rbx
jmp 0x26937
testq %rbx, %rbx
jle 0x268ff
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rsi
movq %rcx, %rdx
imulq %r15, %rdx
shlq $0x4, %rdx
movq %r15, %rax
shlq $0x4, %rax
addq %rsi, %rax
addq %rdx, %rax
movq %rcx, %rdx
shlq $0x4, %rdx
addq $0x10, %rdx
imulq %r15, %rdx
addq %rsi, %rdx
xorl %esi, %esi
xorl %edi, %edi
testq %rdi, %rdi
je 0x268f3
movq %rdi, %r8
shlq $0x4, %r8
addq %rax, %r8
imulq %rsi, %rcx
movq %rcx, %r9
addq %rdx, %r9
xorl %r10d, %r10d
movups (%r9,%r10), %xmm0
movups %xmm0, (%r8)
movq 0x10(%r14), %rcx
movq %rcx, %r11
shlq $0x4, %r11
addq %r11, %r8
addq $0x10, %r10
cmpq %r10, %rsi
jne 0x268d3
incq %rdi
addq $0x10, %rsi
cmpq %rbx, %rdi
jne 0x268b7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %r12
shrq %r12
subq %r12, %rbx
leaq 0xf(%rbx), %rcx
testq %rbx, %rbx
cmovnsq %rbx, %rcx
andq $-0x10, %rcx
movq %rbx, %rax
subq %rcx, %rax
je 0x26937
movl $0x10, %ecx
subq %rax, %rcx
addq %rcx, %rbx
subq %rcx, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26845
leaq (%rbx,%r15), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x26845
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x32671
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26afc
btq %r8, %rax
jae 0x26afc
incq %rdi
jmp 0x26ae7
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x31, %r8b
ja 0x26b4c
movzbl %r8b, %r8d
cmpq $0x30, %r8
je 0x26b1a
cmpq $0x31, %r8
jne 0x26b25
movb $0x1, %cl
jmp 0x26b1c
movb $0x1, %al
movb 0x1(%rdi), %r8b
incq %rdi
jmp 0x26b00
movabsq $0x100002601, %r9       # imm = 0x100002601
btq %r8, %r9
jae 0x26b4c
movq %rdi, (%rdx)
testb $0x1, %al
je 0x26b47
testb $0x1, %cl
jne 0x26b4c
notb %al
andb $0x1, %al
popq %rcx
retq
testb $0x1, %cl
jne 0x26b41
leaq 0xfdbd(%rip), %rdx      # 0x36910
movq %rsi, %rdi
movl $0x3, %esi
callq 0x24dff
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_get_alloc_size(alglib_impl::ae_serializer*)
ae_int_t ae_serializer_get_alloc_size(ae_serializer *serializer)
{
    ae_int_t rows, lastrowsize, result;
    
    serializer->mode = AE_SM_READY2S;
    
    /* if no entries needes (degenerate case) */
    if( serializer->entries_needed==0 )
    {
        serializer->bytes_asked = 1;
        return serializer->bytes_asked;
    }
    
    /* non-degenerate case */
    rows = serializer->entries_needed/AE_SER_ENTRIES_PER_ROW;
    lastrowsize = AE_SER_ENTRIES_PER_ROW;
    if( serializer->entries_needed%AE_SER_ENTRIES_PER_ROW )
    {
        lastrowsize = serializer->entries_needed%AE_SER_ENTRIES_PER_ROW;
        rows++;
    }
    
    /* calculate result size */
    result  = ((rows-1)*AE_SER_ENTRIES_PER_ROW+lastrowsize)*AE_SER_ENTRY_LENGTH;
    result +=  (rows-1)*(AE_SER_ENTRIES_PER_ROW-1)+(lastrowsize-1);
    result += rows*2;
    serializer->bytes_asked = result;
    return result;
}

// Assembly:
movq $0x2, (%rdi)
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x27365
movabsq $0x6666666666666667, %rdx # imm = 0x6666666666666667
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq %rdx
addq %rax, %rdx
leaq (%rdx,%rdx,4), %rax
xorl %esi, %esi
subq %rax, %rcx
setne %sil
movl $0x5, %eax
cmovneq %rcx, %rax
addq %rdx, %rsi
leaq (%rsi,%rsi,4), %rcx
addq $-0x5, %rcx
addq %rax, %rcx
leaq (%rcx,%rcx,4), %rdx
leaq (%rcx,%rdx,2), %rcx
leaq (%rax,%rsi,2), %rax
leaq (%rax,%rsi,4), %rax
addq $-0x4, %rax
addq %rcx, %rax
decq %rax
jmp 0x2736a
movl $0x1, %eax
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2742d
movw $0x20, (%rax)
jmp 0x27436
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 0x27489
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
cmpq $0xa, %rax
je 0x2746f
cmpq $0xb, %rax
jne 0x27489
movq 0x28(%rbx), %rdi
movq %rsp, %rsi
callq 0x3470
jmp 0x2747f
movq 0x30(%rbx), %rdi
movq %rsp, %rsi
callq 0x3430
addq %r15, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf536(%rip), %rdx      # 0x369c6
movq %r14, %rdi
movl $0x3, %esi
callq 0x24dff
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26e8d
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 0x275ea
movw $0x20, (%rax)
jmp 0x275f3
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 0x2764e
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
cmpq $0xa, %rax
je 0x27630
cmpq $0xb, %rax
jne 0x2764e
movq 0x28(%rbx), %rdi
leaq 0xa(%rsp), %rsi
callq 0x3470
jmp 0x27642
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 0xf371(%rip), %rdx      # 0x369c6
movq %r14, %rdi
movl $0x3, %esi
callq 0x24dff
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeb19(%rip), %xmm0     # 0x36220
andpd %xmm0, %xmm2
andpd %xmm0, %xmm1
movapd %xmm2, %xmm0
maxsd %xmm1, %xmm0
minsd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x27728
jp 0x27728
retq
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
addsd 0xbaa8(%rip), %xmm2     # 0x331e0
xorps %xmm1, %xmm1
sqrtsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27782
jp 0x27782
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_O3/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 0x277af
jnp 0x277b0
retq
movsd -0x18(%rsp), %xmm0
cmpneqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xea0b(%rip), %xmm4     # 0x36220
movapd %xmm3, %xmm5
andpd %xmm4, %xmm5
andpd %xmm2, %xmm4
ucomisd %xmm5, %xmm4
movapd 0xb983(%rip), %xmm5     # 0x331b0
xorpd %xmm0, %xmm5
jbe 0x27861
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 0x27891
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_O3/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 0x278df
jp 0x278df
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_O3/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 0x2790f
jnp 0x27910
retq
movsd -0x18(%rsp), %xmm0
cmpneqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe8bb(%rip), %xmm3     # 0x36220
movapd %xmm2, %xmm4
andpd %xmm3, %xmm4
andpd %xmm1, %xmm3
ucomisd %xmm4, %xmm3
jbe 0x279a5
movapd %xmm2, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movapd 0xb821(%rip), %xmm1     # 0x331b0
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 0x279d1
movapd %xmm1, %xmm3
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm3
xorpd 0xb7ef(%rip), %xmm0     # 0x331b0
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_O3/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 0x27bee
cmpb $0x4e, %al
jne 0x27c10
testq %r9, %r9
jle 0x27c7c
shlq $0x4, %rsi
shlq $0x4, %rcx
movups (%rdx), %xmm0
movups %xmm0, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x27bd8
jmp 0x27c7c
cmpb $0x4e, %al
jne 0x27c4d
testq %r9, %r9
jle 0x27c7c
xorl %eax, %eax
movups (%rdx,%rax), %xmm0
movups %xmm0, (%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x27bfd
jmp 0x27c7c
testq %r9, %r9
jle 0x27c7c
addq $0x8, %rdi
shlq $0x4, %rsi
addq $0x8, %rdx
shlq $0x4, %rcx
movaps 0xb584(%rip), %xmm0     # 0x331b0
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 0x27c2c
jmp 0x27c7c
testq %r9, %r9
jle 0x27c7c
xorl %eax, %eax
movaps 0xb555(%rip), %xmm0     # 0x331b0
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 0x27c5b
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27db0
cmpb $0x4e, %al
jne 0x27ddc
testq %r9, %r9
jle 0x27e40
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
shlq $0x4, %rsi
shlq $0x4, %rcx
movupd (%rdx), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x27d94
jmp 0x27e40
cmpb $0x4e, %al
jne 0x27e12
testq %r9, %r9
jle 0x27e40
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
xorl %eax, %eax
movupd (%rdx,%rax), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x27dc3
jmp 0x27e40
testq %r9, %r9
jle 0x27e40
movapd 0xb3c7(%rip), %xmm1     # 0x331b0
xorpd %xmm0, %xmm1
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shlq $0x4, %rsi
shlq $0x4, %rcx
movupd (%rdx), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r9
jne 0x27df9
jmp 0x27e40
testq %r9, %r9
jle 0x27e40
movapd 0xb391(%rip), %xmm1     # 0x331b0
xorpd %xmm0, %xmm1
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
xorl %eax, %eax
movupd (%rdx,%rax), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi,%rax)
addq $0x10, %rax
decq %r9
jne 0x27e29
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x284d3
testq %rdx, %rdx
jle 0x28518
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0xad0c(%rip), %xmm2     # 0x331b0
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
decq %rdx
jne 0x284a4
jmp 0x28518
testq %rdx, %rdx
jle 0x28518
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
shlq $0x4, %rsi
movapd 0xacc4(%rip), %xmm2     # 0x331b0
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
decq %rdx
jne 0x284ec
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2855d
testq %r8, %r8
jle 0x28606
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 0x28541
jmp 0x28605
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 0x285e5
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 0x28591
addq %r8, %rdx
jmp 0x285e8
movq %rdi, %rcx
testq %rax, %rax
jle 0x28605
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x285ef
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2863e
testq %r8, %r8
jle 0x2863d
shlq $0x3, %rsi
shlq $0x3, %rcx
movsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r8
jne 0x2862a
retq
cmpq $0x2, %r8
jl 0x28670
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 0x28651
testb $0x1, %r8b
je 0x2863d
movsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28746
testq %r8, %r8
jle 0x28745
shlq $0x3, %rsi
shlq $0x3, %rcx
movsd (%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
decq %r8
jne 0x2872e
retq
cmpq $0x2, %r8
jl 0x28780
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 0x28759
testb $0x1, %r8b
je 0x28745
mulsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2895e
testq %rdx, %rdx
jle 0x2897b
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x28946
jmp 0x2897b
testq %rdx, %rdx
jle 0x2897b
shlq $0x3, %rsi
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
decq %rdx
jne 0x28967
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x38(%rdi)
movq $0x1, 0x40(%rdi)
addq $0x48, %rdi
xorl %r15d, %r15d
xorl %esi, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2507d
testb %al, %al
je 0x28a6f
movq 0x58(%rbx), %rax
movq %rax, 0x60(%rbx)
movq $0x0, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
movzbl %bpl, %ebp
xorl %r15d, %r15d
xorl %esi, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2507d
testb %al, %al
je 0x28a6f
movq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
movq $0x0, 0x68(%rbx)
movq $0x3, 0x70(%rbx)
leaq 0x78(%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2507d
testb %al, %al
je 0x28a6f
movq 0x88(%rbx), %rax
movq %rax, 0x90(%rbx)
movq $0x0, 0x98(%rbx)
movq $0x4, 0xa0(%rbx)
leaq 0xa8(%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2507d
testb %al, %al
je 0x28a6f
movq 0xb8(%rbx), %rax
movq %rax, 0xc0(%rbx)
movb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25262
testb %al, %al
je 0x28af3
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
movzbl %bpl, %ebp
movq %r15, %rdx
movl %ebp, %ecx
callq 0x25262
testb %al, %al
je 0x28af3
leaq 0x68(%rbx), %rdi
leaq 0x68(%r14), %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x25262
testb %al, %al
je 0x28af3
movl $0x98, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x25262
testb %al, %al
je 0x28af3
movl (%r14), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x28af5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28b1d
movq 0x58(%rbx), %rdi
callq *0x50(%rbx)
xorl %eax, %eax
movq %rax, 0x58(%rbx)
leaq -0x3c06(%rip), %r14     # 0x24f24
movq %r14, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movq %rax, 0x8(%rbx)
cmpq %rax, 0x28(%rbx)
je 0x28b43
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 0x28b6b
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 0x28b9e
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_O3/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
movdqu (%rsi), %xmm1
movdqa 0xd2b3(%rip), %xmm0     # 0x36220
pand %xmm1, %xmm0
pshufd $0xee, %xmm0, %xmm2     # xmm2 = xmm0[2,3,2,3]
ucomisd %xmm2, %xmm0
jbe 0x28fc3
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movupd (%rax), %xmm1
movapd 0xa210(%rip), %xmm3     # 0x331b0
xorpd %xmm1, %xmm3
movapd %xmm1, %xmm4
shufpd $0x1, %xmm3, %xmm4      # xmm4 = xmm4[1],xmm3[0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm4, %xmm0
addpd %xmm1, %xmm0
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm0
jmp 0x29004
movdqa %xmm1, %xmm2
punpckhqdq %xmm1, %xmm2    # xmm2 = xmm2[1],xmm1[1]
movdqa %xmm1, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movupd (%rax), %xmm2
movapd 0xa1c9(%rip), %xmm3     # 0x331b0
xorpd %xmm2, %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm2, %xmm0
shufpd $0x1, %xmm3, %xmm2      # xmm2 = xmm2[1],xmm3[0]
addpd %xmm2, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29804
jp 0x29804
movsd -0x18(%rsp), %xmm0
cmpeqsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq