LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_update_row_pointers(alglib_impl::ae_matrix*, void*)
void ae_matrix_update_row_pointers(ae_matrix *dst, void *storage)
{
    char *p_base;
    void **pp_ptr;
    ae_int_t i;
    if( dst->rows>0 && dst->cols>0 )
    {
        p_base = (char*)storage;
        pp_ptr = (void**)dst->data.ptr;
        dst->ptr.pp_void = pp_ptr;
        for(i=0; i<dst->rows; i++, p_base+=dst->stride*ae_sizeof(dst->datatype))
            pp_ptr[i] = p_base;
    }
    else
        dst->ptr.pp_void = NULL;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
jle 0x2568c
cmpq $0x0, 0x8(%rdi)
jle 0x2568c
movq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rdi
leaq -0x1(%rdi), %r8
xorl %r9d, %r9d
leaq 0x124b8(%rip), %r10     # 0x37b20
movq %rsi, (%rcx,%r9,8)
cmpq $0x3, %r8
ja 0x25679
movq -0x8(%r10,%rdi,8), %r11
jmp 0x2567c
xorl %r11d, %r11d
imulq %rdx, %r11
incq %r9
addq %r11, %rsi
cmpq %r9, %rax
jne 0x25668
retq
movq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_frame_leave(alglib_impl::ae_state*)
void ae_frame_leave(ae_state *state)
{
    while( state->p_top_block->ptr!=DYN_FRAME && state->p_top_block->ptr!=DYN_BOTTOM)
    {
        if( state->p_top_block->ptr!=NULL && state->p_top_block->deallocator!=NULL)
            ((ae_deallocator)(state->p_top_block->deallocator))(state->p_top_block->ptr);
        state->p_top_block = state->p_top_block->p_next;
    }
    state->p_top_block = state->p_top_block->p_next;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rax
cmpq $0x2, %rax
je 0x25750
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
cmpq $0x1, %rax
je 0x25750
movq 0x20(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x2573f
movq 0x20(%rbx), %rax
cmpq $0x0, 0x8(%rax)
je 0x2573f
movq 0x20(%rbx), %rax
movq 0x20(%rbx), %rcx
movq 0x10(%rcx), %rdi
callq *0x8(%rax)
movq 0x20(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x20(%rbx)
movq 0x20(%rbx), %rax
jmp 0x25702
movq 0x20(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_frame_make(alglib_impl::ae_state*, alglib_impl::ae_frame*)
void ae_frame_make(ae_state *state, ae_frame *tmp)
{
    tmp->db_marker.p_next = state->p_top_block;
    tmp->db_marker.deallocator = NULL;
    tmp->db_marker.ptr = DYN_FRAME;
    state->p_top_block = &tmp->db_marker;
}

// Assembly:
movq 0x20(%rdi), %rax
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movq $0x2, 0x10(%rsi)
movq %rsi, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_malloc(alglib_impl::ae_dyn_block*, long, alglib_impl::ae_state*, bool)
ae_bool ae_db_malloc(ae_dyn_block *block, ae_int_t size, ae_state *state, ae_bool make_automatic)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(size>=0, "ae_db_malloc(): negative size", state);
    if( size<0 )
        return ae_false;
    
    /* alloc */
    block->ptr = ae_malloc((size_t)size, state);
    if( block->ptr==NULL && size!=0 )
        return ae_false;
    if( make_automatic && state!=NULL )
        ae_db_attach(block, state);
    else
        block->p_next = NULL;
    block->deallocator = ae_free;
    return ae_true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
setns %cl
orb %al, %cl
je 0x25808
movq %rsi, %r15
testq %rsi, %rsi
js 0x257c9
movq %rdi, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x255f1
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rax
testq %r15, %r15
je 0x257cd
testq %rax, %rax
jne 0x257cd
xorl %eax, %eax
jmp 0x257fd
testq %r14, %r14
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x257e9
movq 0x20(%r14), %rax
movq %rax, (%rbx)
movq %rbx, 0x20(%r14)
jmp 0x257f0
movq $0x0, (%rbx)
leaq -0x1cb(%rip), %rax      # 0x2562c
movq %rax, 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11e58(%rip), %rdx     # 0x37667
movq %r14, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_realloc(alglib_impl::ae_dyn_block*, long, alglib_impl::ae_state*)
ae_bool ae_db_realloc(ae_dyn_block *block, ae_int_t size, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(size>=0, "ae_db_realloc(): negative size", state);
    if( size<0 )
        return ae_false;
    
    /* realloc */
    if( block->ptr!=NULL )
        ((ae_deallocator)block->deallocator)(block->ptr);
    block->ptr = ae_malloc((size_t)size, state);
    if( block->ptr==NULL && size!=0 )
        return ae_false;
    block->deallocator = ae_free;
    return ae_true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
setns %cl
orb %al, %cl
je 0x2589a
movq %rsi, %r14
testq %rsi, %rsi
js 0x25883
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x25866
movq 0x10(%rbx), %rdi
callq *0x8(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x255f1
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rax
testq %r14, %r14
je 0x25887
testq %rax, %rax
jne 0x25887
xorl %eax, %eax
jmp 0x25894
leaq -0x262(%rip), %rax      # 0x2562c
movq %rax, 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11de4(%rip), %rdx     # 0x37685
movq %r15, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_free(alglib_impl::ae_dyn_block*)
void ae_db_free(ae_dyn_block *block)
{
    if( block->ptr!=NULL )
        ((ae_deallocator)block->deallocator)(block->ptr);
    block->ptr = NULL;
    block->deallocator = ae_free;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x258c0
movq 0x10(%rbx), %rdi
callq *0x8(%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x2a3(%rip), %rax      # 0x2562c
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_swap_matrices(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*)
void ae_db_swap(ae_dyn_block *block1, ae_dyn_block *block2)
{
    void (*deallocator)(void*) = NULL;
    void * volatile ptr;
    ptr = block1->ptr;
    deallocator = block1->deallocator;
    block1->ptr = block2->ptr;
    block1->deallocator = block2->deallocator;
    block2->ptr = ptr;
    block2->deallocator = deallocator;
}

// Assembly:
movq 0x30(%rdi), %rax
movq %rax, -0x8(%rsp)
movq 0x28(%rdi), %rax
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rdi)
movq -0x8(%rsp), %rcx
movq %rcx, 0x30(%rsi)
movq %rax, 0x28(%rsi)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movq 0x38(%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rdi)
movq 0x38(%rsi), %rcx
movq %rcx, 0x38(%rdi)
movups %xmm0, (%rsi)
movups %xmm1, 0x10(%rsi)
movq %rax, 0x38(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_init(alglib_impl::ae_vector*, long, long, alglib_impl::ae_state*, bool)
ae_bool ae_vector_init(ae_vector *dst, ae_int_t size, ae_datatype datatype, ae_state *state, ae_bool make_automatic)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(size>=0, "ae_vector_init(): negative size", state);
    if( size<0 )
        return ae_false;

    /* init */
    dst->cnt = size;
    dst->datatype = datatype;
    if( !ae_db_malloc(&dst->data, size*ae_sizeof(datatype), state, make_automatic) )
        return ae_false;
    dst->ptr.p_ptr = dst->data.ptr;
    return ae_true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rcx, %rcx
sete %al
testq %rsi, %rsi
setns %dil
orb %al, %dil
je 0x2596a
testq %rsi, %rsi
js 0x25966
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
leaq -0x1(%rdx), %rax
cmpq $0x3, %rax
ja 0x2593e
leaq 0x121e9(%rip), %rax     # 0x37b20
movq -0x8(%rax,%rdx,8), %rax
jmp 0x25940
xorl %eax, %eax
imulq %rsi, %rax
movzbl %r8b, %r8d
movq %rax, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x25785
testb %al, %al
je 0x25966
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
movb $0x1, %al
jmp 0x25968
xorl %eax, %eax
popq %rbx
retq
leaq 0x11d33(%rip), %rdx     # 0x376a4
movq %rcx, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_init_copy(alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*, bool)
ae_bool ae_vector_init_copy(ae_vector *dst, ae_vector *src, ae_state *state, ae_bool make_automatic)
{
    if( !ae_vector_init(dst, src->cnt, src->datatype, state, make_automatic) )
        return ae_false;
    if( src->cnt!=0 )
        memcpy(dst->ptr.p_ptr, src->ptr.p_ptr, (size_t)(src->cnt*ae_sizeof(src->datatype)));
    return ae_true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x25900
movl %eax, %ebx
testb %al, %al
je 0x259d8
movq (%r14), %rax
testq %rax, %rax
je 0x259d8
movq 0x28(%r15), %rdi
movq 0x8(%r14), %rcx
movq 0x28(%r14), %rsi
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
ja 0x259cd
leaq 0x1215a(%rip), %rdx     # 0x37b20
movq -0x8(%rdx,%rcx,8), %rdx
jmp 0x259cf
xorl %edx, %edx
imulq %rax, %rdx
callq 0x3200
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_set_length(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool ae_vector_set_length(ae_vector *dst, ae_int_t newsize, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(newsize>=0, "ae_vector_set_length(): negative size", state);
    if( newsize<0 )
        return ae_false;

    /* set length */
    if( dst->cnt==newsize )
        return ae_true;
    dst->cnt = newsize;
    if( !ae_db_realloc(&dst->data, newsize*ae_sizeof(dst->datatype), state) )
        return ae_false;
    dst->ptr.p_ptr = dst->data.ptr;
    return ae_true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
setns %cl
orb %al, %cl
je 0x25ab0
testq %rsi, %rsi
js 0x25aa4
movq %rdi, %r14
movb $0x1, %bl
cmpq %rsi, (%rdi)
je 0x25aa6
movq %rsi, (%r14)
leaq 0x10(%r14), %rdi
movq 0x8(%r14), %rax
leaq -0x1(%rax), %rcx
cmpq $0x3, %rcx
ja 0x25a88
leaq 0x1209f(%rip), %rcx     # 0x37b20
movq -0x8(%rcx,%rax,8), %rax
jmp 0x25a8a
xorl %eax, %eax
imulq %rsi, %rax
movq %rax, %rsi
callq 0x25835
testb %al, %al
je 0x25aa4
movq 0x20(%r14), %rax
movq %rax, 0x28(%r14)
jmp 0x25aa6
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x11c0d(%rip), %rax     # 0x376c4
movq %rdx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init(alglib_impl::ae_matrix*, long, long, long, alglib_impl::ae_state*, bool)
ae_bool ae_matrix_init(ae_matrix *dst, ae_int_t rows, ae_int_t cols, ae_datatype datatype, ae_state *state, ae_bool make_automatic)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(rows>=0 && cols>=0, "ae_matrix_init(): negative length", state);
    if( rows<0 || cols<0 )
        return ae_false;

    /* if one of rows/cols is zero, another MUST be too */
    if( rows==0 || cols==0 )
    {
        rows = 0;
        cols = 0;
    }

    /* init */
    dst->rows = rows;
    dst->cols = cols;
    dst->stride = cols;
    while( dst->stride*ae_sizeof(datatype)%AE_DATA_ALIGN!=0 )
        dst->stride++;
    dst->datatype = datatype;
    if( !ae_db_malloc(&dst->data, dst->rows*((ae_int_t)sizeof(void*)+dst->stride*ae_sizeof(datatype))+AE_DATA_ALIGN-1, state, make_automatic) )
        return ae_false;
    ae_matrix_update_row_pointers(dst, ae_align((char*)dst->data.ptr+dst->rows*sizeof(void*),AE_DATA_ALIGN));
    return ae_true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %r8, %r8
sete %al
movq %rdx, %rdi
orq %rsi, %rdi
setns %dil
orb %al, %dil
je 0x25c21
movq %rdx, %rax
orq %rsi, %rax
js 0x25c1d
testq %rsi, %rsi
movq %rdx, %r10
cmoveq %rsi, %r10
testq %rdx, %rdx
cmoveq %rdx, %rsi
movq %rsi, (%rbx)
movq %r10, 0x8(%rbx)
leaq -0x1(%rcx), %rdx
leaq 0x11f8e(%rip), %rax     # 0x37b20
cmpq $0x3, %rdx
ja 0x25b9f
movq -0x8(%rax,%rcx,8), %rdi
jmp 0x25ba1
xorl %edi, %edi
imull %r10d, %edi
incq %r10
testb $0xf, %dil
jne 0x25b92
decq %r10
movq %r10, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
cmpq $0x3, %rdx
ja 0x25bca
movq -0x8(%rax,%rcx,8), %rax
jmp 0x25bcc
xorl %eax, %eax
imulq %r10, %rax
addq $0x8, %rax
imulq %rsi, %rax
addq $0xf, %rax
movzbl %r9b, %ecx
movq %rax, %rsi
movq %r8, %rdx
callq 0x25785
testb %al, %al
je 0x25c1d
movq (%rbx), %rax
shlq $0x3, %rax
addq 0x30(%rbx), %rax
movl %eax, %ecx
andl $0xf, %ecx
movl $0x10, %esi
subq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x2563b
movb $0x1, %al
jmp 0x25c1f
xorl %eax, %eax
popq %rbx
retq
leaq 0x11ac2(%rip), %rdx     # 0x376ea
movq %r8, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init_copy(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*, alglib_impl::ae_state*, bool)
ae_bool ae_matrix_init_copy(ae_matrix *dst, ae_matrix *src, ae_state *state, ae_bool make_automatic)
{
    ae_int_t i;
    if( !ae_matrix_init(dst, src->rows, src->cols, src->datatype, state, make_automatic) )
        return ae_false;
    if( src->rows!=0 && src->cols!=0 )
    {
        if( dst->stride==src->stride )
            memcpy(dst->ptr.pp_void[0], src->ptr.pp_void[0], (size_t)(src->rows*src->stride*ae_sizeof(src->datatype)));
        else
            for(i=0; i<dst->rows; i++)
                memcpy(dst->ptr.pp_void[i], src->ptr.pp_void[i], (size_t)(dst->cols*ae_sizeof(dst->datatype)));
    }
    return ae_true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %r9d
movq %rdx, %r8
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
movq 0x18(%r14), %rcx
callq 0x25b46
movl %eax, %ebx
testb %al, %al
je 0x25d09
movq (%r14), %rax
testq %rax, %rax
je 0x25d09
cmpq $0x0, 0x8(%r14)
je 0x25d09
movq 0x10(%r14), %rdx
cmpq %rdx, 0x10(%r15)
jne 0x25cb3
movq 0x38(%r15), %rcx
movq (%rcx), %rdi
movq 0x18(%r14), %rcx
movq 0x38(%r14), %rsi
movq (%rsi), %rsi
imulq %rax, %rdx
leaq -0x1(%rcx), %rax
cmpq $0x3, %rax
ja 0x25cfe
leaq 0x11e74(%rip), %rax     # 0x37b20
movq -0x8(%rax,%rcx,8), %rax
jmp 0x25d00
cmpq $0x0, (%r15)
jle 0x25d09
xorl %r12d, %r12d
leaq 0x11e5d(%rip), %r13     # 0x37b20
movq 0x18(%r15), %rax
leaq -0x1(%rax), %rcx
cmpq $0x3, %rcx
ja 0x25cd8
movq -0x8(%r13,%rax,8), %rdx
jmp 0x25cda
xorl %edx, %edx
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rdi
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rsi
imulq 0x8(%r15), %rdx
callq 0x3200
incq %r12
cmpq (%r15), %r12
jl 0x25cc3
jmp 0x25d09
xorl %eax, %eax
imulq %rax, %rdx
callq 0x3200
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init_from_x(alglib_impl::ae_matrix*, alglib_impl::x_matrix*, alglib_impl::ae_state*, bool)
void ae_matrix_init_from_x(ae_matrix *dst, x_matrix *src, ae_state *state, ae_bool make_automatic)
{
    char *p_src_row;
    char *p_dst_row;
    ae_int_t row_size;
    ae_int_t i;
    ae_matrix_init(dst, (ae_int_t)src->rows, (ae_int_t)src->cols, (ae_datatype)src->datatype, state, make_automatic);
    if( src->rows!=0 && src->cols!=0 )
    {
        p_src_row = (char*)src->ptr;
        p_dst_row = (char*)(dst->ptr.pp_void[0]);
        row_size = ae_sizeof((ae_datatype)src->datatype)*(ae_int_t)src->cols;
        for(i=0; i<src->rows; i++, p_src_row+=src->stride*ae_sizeof((ae_datatype)src->datatype), p_dst_row+=dst->stride*ae_sizeof((ae_datatype)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
movl %ecx, %r9d
movq %rdx, %r8
movq %rsi, %rbx
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
movq 0x18(%rbx), %rcx
movq %rdi, (%rsp)
callq 0x25b46
cmpq $0x0, (%rbx)
je 0x25de4
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x25de4
movq 0x18(%rbx), %rcx
leaq -0x1(%rcx), %rdx
leaq 0x11dbd(%rip), %r14     # 0x37b20
cmpq $0x3, %rdx
ja 0x25d70
movq -0x8(%r14,%rcx,8), %r15
jmp 0x25d73
xorl %r15d, %r15d
cmpq $0x0, (%rbx)
jle 0x25de4
movq (%rsp), %rcx
movq 0x38(%rcx), %rcx
movq 0x30(%rbx), %r12
movq (%rcx), %r13
imulq %rax, %r15
xorl %ebp, %ebp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
movq 0x18(%rbx), %rdx
leaq -0x1(%rdx), %rsi
cmpq $0x3, %rsi
ja 0x25db1
movq -0x8(%r14,%rdx,8), %rax
jmp 0x25db3
xorl %eax, %eax
movq 0x10(%rbx), %rcx
movq (%rsp), %rdi
movq 0x10(%rdi), %rdi
cmpq $0x3, %rsi
ja 0x25dcc
movq -0x8(%r14,%rdx,8), %rdx
jmp 0x25dce
xorl %edx, %edx
imulq %rdi, %rdx
incq %rbp
imulq %rcx, %rax
addq %rax, %r12
addq %rdx, %r13
cmpq (%rbx), %rbp
jl 0x25d8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_set_length(alglib_impl::ae_matrix*, long, long, alglib_impl::ae_state*)
ae_bool ae_matrix_set_length(ae_matrix *dst, ae_int_t rows, ae_int_t cols, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(rows>=0 && cols>=0, "ae_matrix_set_length(): negative length", state);
    if( rows<0 || cols<0 )
        return ae_false;

    if( dst->rows==rows && dst->cols==cols )
        return ae_true;    
    dst->rows = rows;
    dst->cols = cols;
    dst->stride = cols;
    while( dst->stride*ae_sizeof(dst->datatype)%AE_DATA_ALIGN!=0 )
        dst->stride++;
    if( !ae_db_realloc(&dst->data, dst->rows*((ae_int_t)sizeof(void*)+dst->stride*ae_sizeof(dst->datatype))+AE_DATA_ALIGN-1, state) )
        return ae_false;
    ae_matrix_update_row_pointers(dst, ae_align((char*)dst->data.ptr+dst->rows*sizeof(void*),AE_DATA_ALIGN));
    return ae_true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rcx, %rcx
sete %al
movq %rdx, %rdi
orq %rsi, %rdi
setns %dil
orb %al, %dil
je 0x25ec9
movq %rdx, %rax
orq %rsi, %rax
js 0x25ec5
cmpq %rsi, (%rbx)
jne 0x25e2d
movb $0x1, %al
cmpq %rdx, 0x8(%rbx)
je 0x25ec7
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
movq 0x18(%rbx), %rax
leaq -0x1(%rax), %r9
leaq 0x11cdd(%rip), %r8      # 0x37b20
cmpq $0x3, %r9
ja 0x25e50
movq -0x8(%r8,%rax,8), %rdi
jmp 0x25e52
xorl %edi, %edi
imull %edx, %edi
incq %rdx
testb $0xf, %dil
jne 0x25e43
decq %rdx
movq %rdx, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
cmpq $0x3, %r9
ja 0x25e76
movq -0x8(%r8,%rax,8), %rax
jmp 0x25e78
xorl %eax, %eax
imulq %rdx, %rax
addq $0x8, %rax
imulq %rsi, %rax
addq $0xf, %rax
movq %rax, %rsi
movq %rcx, %rdx
callq 0x25835
testb %al, %al
je 0x25ec5
movq (%rbx), %rax
shlq $0x3, %rax
addq 0x30(%rbx), %rax
movl %eax, %ecx
andl $0xf, %ecx
movl $0x10, %esi
subq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x2563b
movb $0x1, %al
jmp 0x25ec7
xorl %eax, %eax
popq %rbx
retq
leaq 0x1183c(%rip), %rdx     # 0x3770c
movq %rcx, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_clear(alglib_impl::ae_matrix*)
void ae_matrix_clear(ae_matrix *dst)
{
    dst->rows = 0;
    dst->cols = 0;
    dst->stride = 0;
    ae_db_free(&dst->data);
    dst->ptr.p_ptr = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x30(%rdi)
je 0x25efd
movq 0x30(%rbx), %rdi
callq *0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x30(%rbx)
leaq -0x8de(%rip), %rcx      # 0x2562c
movq %rcx, 0x28(%rbx)
movq %rax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x25fa4
movq 0x8(%r14), %rax
cmpq 0x8(%rbx), %rax
jne 0x25fa4
leaq 0x18(%r14), %r12
jmp 0x26008
cmpq $0x2, 0x10(%r14)
jne 0x25fbd
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x25fbd
movq -0x8(%rax), %rdi
callq 0x32e0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
ja 0x25fdc
leaq 0x11b4b(%rip), %rdx     # 0x37b20
movq -0x8(%rdx,%rcx,8), %rdi
jmp 0x25fde
xorl %edi, %edi
imulq %rax, %rdi
leaq 0x10(%r14), %r12
movq %r15, %rsi
callq 0x255f1
movq %rax, 0x20(%r14)
movq $0x3, 0x18(%r14)
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq $0x2, (%r12)
movq (%rbx), %rax
testq %rax, %rax
je 0x2603c
movq 0x20(%r14), %rdi
movq 0x8(%rbx), %rcx
movq 0x28(%rbx), %rsi
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
ja 0x26048
leaq 0x11aeb(%rip), %rdx     # 0x37b20
movq -0x8(%rdx,%rcx,8), %rdx
jmp 0x2604a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %edx, %edx
imulq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3200
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
cmpq (%rsi), %rax
jne 0x26094
movq 0x8(%r14), %rax
cmpq 0x8(%rbx), %rax
jne 0x26094
movq 0x18(%r14), %rax
cmpq 0x18(%rbx), %rax
jne 0x26094
leaq 0x28(%r14), %r12
jmp 0x26101
cmpq $0x2, 0x20(%r14)
jne 0x260ad
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x260ad
movq -0x8(%rax), %rdi
callq 0x32e0
movq (%rbx), %rcx
movq %rcx, (%r14)
movq 0x8(%rbx), %rdi
movq %rdi, 0x8(%r14)
movq %rdi, 0x10(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
imulq %rcx, %rdi
leaq -0x1(%rax), %rcx
cmpq $0x3, %rcx
ja 0x260e3
leaq 0x11a44(%rip), %rcx     # 0x37b20
movq -0x8(%rcx,%rax,8), %rax
jmp 0x260e5
xorl %eax, %eax
imulq %rax, %rdi
leaq 0x20(%r14), %r12
movq %r15, %rsi
callq 0x255f1
movq %rax, 0x30(%r14)
movq $0x3, 0x28(%r14)
movq $0x2, (%r12)
cmpq $0x0, (%rbx)
je 0x261b6
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x261b6
movq 0x18(%rbx), %rcx
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
ja 0x2613c
leaq 0x119eb(%rip), %rdx     # 0x37b20
movq -0x8(%rdx,%rcx,8), %r15
jmp 0x2613f
xorl %r15d, %r15d
cmpq $0x0, (%rbx)
jle 0x261b6
movq 0x38(%rbx), %rcx
movq (%rcx), %r12
movq 0x30(%r14), %r13
imulq %rax, %r15
xorl %ebp, %ebp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
movq 0x18(%rbx), %rdx
leaq -0x1(%rdx), %rsi
cmpq $0x3, %rsi
ja 0x26180
leaq 0x119a7(%rip), %rax     # 0x37b20
movq -0x8(%rax,%rdx,8), %rax
jmp 0x26182
xorl %eax, %eax
movq 0x10(%rbx), %rcx
movq 0x10(%r14), %rdi
cmpq $0x3, %rsi
ja 0x2619e
leaq 0x11989(%rip), %rsi     # 0x37b20
movq -0x8(%rsi,%rdx,8), %rdx
jmp 0x261a0
xorl %edx, %edx
imulq %rdi, %rdx
incq %rbp
imulq %rcx, %rax
addq %rax, %r12
addq %rdx, %r13
cmpq (%rbx), %rbp
jl 0x26156
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_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 0x261e8
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x261e8
movq -0x8(%rax), %rdi
callq 0x32e0
movq 0x28(%r14), %rax
movq %rax, 0x20(%rbx)
movq $0x3, 0x18(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_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 0x26239
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x26239
movq -0x8(%rax), %rdi
callq 0x32e0
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%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_O1/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 0x26297
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x26297
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_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_fp_neq(double, double)
ae_bool ae_fp_eq(double v1, double v2)
{
    /* IEEE-strict floating point comparison */
    volatile double x = v1;
    volatile double y = v2;
    return x==y;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
movsd -0x8(%rsp), %xmm0
cmpneqsd -0x10(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_isnan_stateless(double, long)
ae_bool ae_isnan_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];
    }
    return ((high &0x7FF00000)==0x7FF00000) && (((high &0x000FFFFF)!=0) || (low!=0));
}

// Assembly:
movq %xmm0, %rcx
movq %rcx, %rax
shrq $0x20, %rax
cmpq $0x1, %rdi
movl %eax, %edx
cmovnel %ecx, %edx
movl %edx, %esi
notl %esi
testl $0x7ff00000, %esi       # imm = 0x7FF00000
jne 0x263d2
cmpq $0x1, %rdi
movl %ecx, %ecx
cmoveq %rcx, %rax
testl $0xfffff, %edx          # imm = 0xFFFFF
setne %cl
testq %rax, %rax
setne %al
orb %cl, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2646f
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_O1/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 0x26656
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x26648
movl %eax, %ebx
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0x2666c
callq 0x30b0
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x2665e
movl %eax, %ebp
cvtsi2sd %ebx, %xmm1
cvtsi2sd %ebp, %xmm0
movsd 0xdb1c(%rip), %xmm2     # 0x34198
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::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 0x267c3
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
jne 0x267c3
testq %rax, %rax
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movb $0x1, %bl
jne 0x267c5
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 0xda42(%rip), %rsi      # 0x34181
movq %rsi, 0x20(%rax)
movq %rcx, -0x28(%rax)
movapd 0x10941(%rip), %xmm0    # 0x37090
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 0x267cf
cmpb $0x0, (%r14)
jne 0x267c5
movsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb $0x1, %bl
jne 0x267a8
jnp 0x267c5
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x10906(%rip), %xmm0    # 0x370c0
ucomisd %xmm1, %xmm0
setae %bl
jmp 0x267c5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26acf
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
jne 0x26acf
testq %rax, %rax
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movb $0x1, %bl
jne 0x26ad1
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 0xd736(%rip), %rsi      # 0x34181
movq %rsi, 0x20(%rax)
movq %rcx, -0x28(%rax)
movapd 0x10635(%rip), %xmm0    # 0x37090
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 0x26adb
cmpb $0x0, (%r14)
jne 0x26ad1
movsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb $0x1, %bl
jne 0x26ab4
jnp 0x26ad1
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x105fa(%rip), %xmm0    # 0x370c0
ucomisd %xmm1, %xmm0
setae %bl
jmp 0x26ad1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26faf
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
jne 0x26faf
testq %rax, %rax
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movb $0x1, %bl
jne 0x26fb1
xorl %esi, %esi
callq 0x26fb5
jmp 0x26fb1
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26fe8
movq %rbx, %r12
andq $0xf, %r12
je 0x27046
movabsq $0x7ffffffffffffff0, %rax # imm = 0x7FFFFFFFFFFFFFF0
andq %rax, %rbx
jmp 0x27074
testq %rbx, %rbx
jle 0x2703c
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 0x2702d
movq %rsi, %rdi
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rdi)
incq %r8
addq %rax, %rdi
cmpq %r8, %rdx
jne 0x27018
incq %rdx
addq $0x8, %rsi
addq %rax, %rcx
cmpq %rbx, %rdx
jne 0x2700d
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 0x27074
movl $0x10, %ecx
subq %rax, %rcx
addq %rcx, %rbx
subq %rcx, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x26fb5
leaq (%rbx,%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x26fb5
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 0x331c4
// File: /workspace/github_cpp_makefile_star2_O1/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 0x270e0
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
jne 0x270e0
testq %rax, %rax
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movb $0x1, %bl
jne 0x270e2
xorl %esi, %esi
callq 0x270e6
jmp 0x270e2
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2711d
movq %rbx, %r12
andq $0xf, %r12
je 0x271a4
movabsq $0x7ffffffffffffff0, %rax # imm = 0x7FFFFFFFFFFFFFF0
andq %rax, %rbx
jmp 0x271d2
testq %rbx, %rbx
jle 0x2719a
movq 0x10(%r14), %rax
movq 0x30(%r14), %rdx
movq %rax, %rsi
imulq %r15, %rsi
shlq $0x4, %rsi
movq %r15, %rcx
shlq $0x4, %rcx
addq %rdx, %rcx
addq %rsi, %rcx
shlq $0x4, %rax
addq $0x10, %rax
imulq %r15, %rax
addq %rdx, %rax
xorl %edx, %edx
xorl %esi, %esi
testq %rsi, %rsi
je 0x2718e
movq %rsi, %rdi
shlq $0x4, %rdi
addq %rcx, %rdi
movq 0x10(%r14), %r8
imulq %rdx, %r8
addq %rax, %r8
xorl %r9d, %r9d
movups (%r8,%r9), %xmm0
movups %xmm0, (%rdi)
movq 0x10(%r14), %r10
shlq $0x4, %r10
addq %r10, %rdi
addq $0x10, %r9
cmpq %r9, %rdx
jne 0x27172
incq %rsi
addq $0x10, %rdx
cmpq %rbx, %rsi
jne 0x27155
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 0x271d2
movl $0x10, %ecx
subq %rax, %rcx
addq %rcx, %rbx
subq %rcx, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x270e6
leaq (%rbx,%r15), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x270e6
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 0x3333d
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_threebytes2foursixbits(unsigned char const*, long*)
void ae_threebytes2foursixbits(const unsigned char *src, ae_int_t *dst)
{
    dst[0] = src[0] & 0x3F;
    dst[1] = (src[0]>>6) | ((src[1]&0x0F)<<2);
    dst[2] = (src[1]>>4) | ((src[2]&0x03)<<4);
    dst[3] = src[2]>>2;
}

// Assembly:
movzbl (%rdi), %eax
andl $0x3f, %eax
movq %rax, (%rsi)
movzbl (%rdi), %eax
shrl $0x6, %eax
movzbl 0x1(%rdi), %ecx
andl $0xf, %ecx
leal (%rax,%rcx,4), %eax
movq %rax, 0x8(%rsi)
movzbl 0x1(%rdi), %eax
shrl $0x4, %eax
movzbl 0x2(%rdi), %ecx
shll $0x4, %ecx
andl $0x30, %ecx
orl %eax, %ecx
movq %rcx, 0x10(%rsi)
movzbl 0x2(%rdi), %eax
shrl $0x2, %eax
movq %rax, 0x18(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
cmpq $0x20, %rcx
ja 0x27396
btq %rcx, %rax
jae 0x27396
incq %rdi
jmp 0x27382
xorl %r8d, %r8d
movabsq $0x100002601, %rcx      # imm = 0x100002601
xorl %eax, %eax
movzbl (%rdi), %r9d
cmpl $0x31, %r9d
jne 0x273b6
incq %rdi
movb $0x1, %al
jmp 0x273a5
jae 0x273e4
movl %r9d, %r9d
btq %r9, %rcx
jb 0x273cf
cmpq $0x30, %r9
jne 0x273e4
incq %rdi
movb $0x1, %r8b
jmp 0x273a5
movq %rdi, (%rdx)
testb $0x1, %r8b
je 0x273e0
testb $0x1, %al
jne 0x273e4
andb $0x1, %al
popq %rcx
retq
testb $0x1, %al
jne 0x273dc
leaq 0x10349(%rip), %rdx     # 0x37734
movq %rsi, %rdi
movl $0x3, %esi
callq 0x25507
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_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 0x27b10
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 0x27b15
movl $0x1, %eax
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_sstart_str(alglib_impl::ae_serializer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void ae_serializer_sstart_str(ae_serializer *serializer, std::string *buf)
{
    serializer->mode = AE_SM_TO_CPPSTRING;
    serializer->out_cppstr = buf;
    serializer->entries_saved = 0;
    serializer->bytes_written = 0;
}

// Assembly:
movq $0xb, (%rdi)
movq %rsi, 0x28(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_sstart_str(alglib_impl::ae_serializer*, char*)
void ae_serializer_sstart_str(ae_serializer *serializer, char *buf)
{
    serializer->mode = AE_SM_TO_STRING;
    serializer->out_str = buf;
    serializer->out_str[0] = 0;
    serializer->entries_saved = 0;
    serializer->bytes_written = 0;
}

// Assembly:
movq $0xa, (%rdi)
movq %rsi, 0x30(%rdi)
movb $0x0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x20(%rdi)
retq