LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_vector_wrapper::attach_to(alglib_impl::ae_vector*)
void alglib::ae_vector_wrapper::attach_to(alglib_impl::ae_vector *ptr)
{
    if( ptr==&vec )
        throw alglib::ap_error("ALGLIB: attempt to attach vector to itself");
    if( p_vec==&vec )
        ae_vector_clear(p_vec);
    p_vec = ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x10(%rdi), %rax
cmpq %rsi, %rax
je 0x2bdbe
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq %rax, %r15
jne 0x2bdb4
movq $0x0, (%r15)
cmpq $0x0, 0x20(%r15)
je 0x2bd9f
movq 0x20(%r15), %rdi
callq *0x18(%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
leaq -0x6780(%rip), %rcx     # 0x2562c
movq %rcx, 0x18(%r15)
movq %rax, 0x28(%r15)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xbb55(%rip), %rsi      # 0x37927
movq %rax, %rdi
callq 0x2966e
leaq 0x17d9f(%rip), %rsi     # 0x43b80
leaq -0x18564(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_vector_wrapper::allocate_own(long, long)
void alglib::ae_vector_wrapper::allocate_own(ae_int_t size, alglib_impl::ae_datatype datatype)
{
    if( p_vec==&vec )
        ae_vector_clear(p_vec);
    p_vec = &vec;
    if( !ae_vector_init(p_vec, size, datatype, NULL, false) )
        throw alglib::ap_error("ALGLIB: malloc error");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rdi), %r13
leaq 0x10(%rdi), %r15
cmpq %r15, %r13
jne 0x2be4f
movq $0x0, (%r13)
cmpq $0x0, 0x20(%r13)
je 0x2be3a
movq 0x20(%r13), %rdi
callq *0x18(%r13)
xorl %eax, %eax
movq %rax, 0x20(%r13)
leaq -0x681b(%rip), %rcx     # 0x2562c
movq %rcx, 0x18(%r13)
movq %rax, 0x28(%r13)
movq %r15, 0x8(%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x25900
testb %al, %al
je 0x2be75
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xba89(%rip), %rsi      # 0x37912
movq %rax, %rdi
callq 0x2966e
leaq 0x17ce8(%rip), %rsi     # 0x43b80
leaq -0x1861b(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_1d_array::boolean_1d_array(char const*)
alglib::boolean_1d_array::boolean_1d_array(const char *s)  
{
    std::vector<const char*> svec;
    size_t i;
    char *p = filter_spaces(s);
    try
    {
        str_vector_create(p, true, &svec);
        allocate_own((ae_int_t)(svec.size()), alglib_impl::DT_BOOL);
        for(i=0; i<svec.size(); i++)
            operator()((ae_int_t)i) = parse_bool_delim(svec[i],",]");
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x17c9f(%rip), %rcx     # 0x43bc0
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2c032
movq %rax, %r14
movq %rsp, %rdx
movq %rax, %rdi
movl $0x1, %esi
callq 0x2c0ec
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x3, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2be04
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x2bfaa
xorl %r12d, %r12d
leaq 0xb9d8(%rip), %r15      # 0x37952
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x2c21a
movq 0x8(%rbx), %rcx
movq 0x28(%rcx), %rcx
movb %al, (%rcx,%r12)
incq %r12
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x2bf7a
testq %r14, %r14
je 0x2bfb8
movq -0x8(%r14), %rdi
callq 0x32e0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2bfce
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x2c004
jmp 0x2bfe1
movq %rax, %rdi
callq 0x3100
testq %r14, %r14
je 0x2bff7
movq -0x8(%r14), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2c01a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x2baee
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::filter_spaces(char const*)
char* alglib::filter_spaces(const char *s)
{
    size_t i, j, n;
    char *r;
    char *r0;
    n = strlen(s);
    r = (char*)alglib_impl::ae_malloc(n+1, NULL);
    if( r==NULL )
        throw ap_error("malloc error");
    for(i=0,j=0,r0=r; i<=n; i++,s++)
        if( !isspace(*s) )
        {
            *r0 = *s;
            r0++;
        }
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3110
movq %rax, %r14
incq %r14
jne 0x2c052
xorl %r15d, %r15d
jmp 0x2c062
movl $0x10, %esi
movq %r14, %rdi
callq 0x25580
movq %rax, %r15
testq %r15, %r15
je 0x2c0a7
cmpq $0x1, %r14
adcq $0x0, %r14
xorl %r12d, %r12d
movq %r15, %r13
movb (%rbx,%r12), %bpl
movsbl %bpl, %edi
callq 0x3050
testl %eax, %eax
jne 0x2c08d
movb %bpl, (%r13)
incq %r13
incq %r12
cmpq %r12, %r14
jne 0x2c075
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb85f(%rip), %rsi      # 0x3791a
movq %rax, %rdi
callq 0x2966e
leaq 0x17ab6(%rip), %rsi     # 0x43b80
leaq -0x1884d(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::str_vector_create(char const*, bool, std::vector<char const*, std::allocator<char const*>>*)
void alglib::str_vector_create(const char *src, bool match_head_only, std::vector<const char*> *p_vec)
{
    //
    // parse beginning of the string.
    // try to handle "[]" string
    //
    p_vec->clear();
    if( *src!='[' )
        throw alglib::ap_error("Incorrect initializer for vector");
    src++;
    if( *src==']' )
        return;
    p_vec->push_back(src);
    for(;;)
    {
        if( *src==0 )
            throw alglib::ap_error("Incorrect initializer for vector");
        if( *src==']' )
        {
            if( src[1]==0 || !match_head_only)
                return;
            throw alglib::ap_error("Incorrect initializer for vector");
        }
        if( *src==',' )
        {
            p_vec->push_back(src+1);
            src++;
            continue;
        }
        src++;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, (%rsp)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x2c10b
movq %rax, 0x8(%r14)
cmpb $0x5b, (%rdi)
jne 0x2c1c7
leaq 0x1(%rdi), %rax
movq %rax, (%rsp)
cmpb $0x5d, 0x1(%rdi)
je 0x2c18b
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x2c136
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x2c141
movq %rsp, %rdx
movq %r14, %rdi
callq 0x33604
leaq 0x8(%rsp), %r15
movq (%rsp), %rax
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
je 0x2c15d
cmpl $0x5d, %ecx
je 0x2c17d
testl %ecx, %ecx
jne 0x2c174
jmp 0x2c195
incq %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x33740
movq (%rsp), %rax
incq %rax
movq %rax, (%rsp)
jmp 0x2c146
cmpb $0x0, 0x1(%rax)
sete %al
xorb $0x1, %bl
orb %al, %bl
je 0x2c1e5
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb878(%rip), %rsi      # 0x37a21
movq %rax, %rdi
callq 0x2966e
leaq 0x179c8(%rip), %rsi     # 0x43b80
leaq -0x1893b(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb846(%rip), %rsi      # 0x37a21
movq %rax, %rdi
callq 0x2966e
jmp 0x2c1b1
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb828(%rip), %rsi      # 0x37a21
movq %rax, %rdi
callq 0x2966e
jmp 0x2c1b1
jmp 0x2c207
jmp 0x2c207
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::parse_bool_delim(char const*, char const*)
ae_bool alglib::parse_bool_delim(const char *s, const char *delim)
{
    const char *p;
    char buf[8];
    
    // try to parse false
    p = "false";
    memset(buf, 0, sizeof(buf));
    strncpy(buf, s, strlen(p));
    if( my_stricmp(buf, p)==0 )
    {
        if( s[strlen(p)]==0 || strchr(delim,s[strlen(p)])==NULL )
            throw alglib::ap_error("Cannot parse value");
        return ae_false;
    }

    // try to parse true
    p = "true";
    memset(buf, 0, sizeof(buf));
    strncpy(buf, s, strlen(p));
    if( my_stricmp(buf, p)==0 )
    {
        if( s[strlen(p)]==0 || strchr(delim,s[strlen(p)])==NULL )
            throw alglib::ap_error("Cannot parse value");
        return ae_true;
    }

    // error
    throw alglib::ap_error("Cannot parse value");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %r14
movq $0x0, (%r14)
movl $0x5, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3150
leaq 0xb81a(%rip), %rsi      # 0x37a63
movq %r14, %rdi
callq 0x2ef6e
movq %rax, %r14
testq %rax, %rax
je 0x2c2bc
movq %rsp, %r12
movq $0x0, (%r12)
movl $0x4, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x3150
leaq 0xb801(%rip), %rsi      # 0x37a7c
movq %r12, %rdi
callq 0x2ef6e
testq %rax, %rax
jne 0x2c302
movsbl 0x4(%r15), %esi
testl %esi, %esi
je 0x2c29e
movq %rbx, %rdi
callq 0x30f0
testq %rax, %rax
jne 0x2c2d2
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb7b7(%rip), %rsi      # 0x37a69
movq %rax, %rdi
callq 0x2966e
jmp 0x2c31e
movsbl 0x5(%r15), %esi
testl %esi, %esi
je 0x2c2e4
movq %rbx, %rdi
callq 0x30f0
testq %rax, %rax
je 0x2c2e4
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb771(%rip), %rsi      # 0x37a69
movq %rax, %rdi
callq 0x2966e
jmp 0x2c31e
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb753(%rip), %rsi      # 0x37a69
movq %rax, %rdi
callq 0x2966e
leaq 0x1785b(%rip), %rsi     # 0x43b80
leaq -0x18aa8(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
jmp 0x2c338
jmp 0x2c338
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_1d_array::setcontent(long, bool const*)
void alglib::boolean_1d_array::setcontent(ae_int_t iLen, const bool *pContent )
{
    ae_int_t i;
    setlength(iLen);
    for(i=0; i<iLen; i++)
        p_vec->ptr.p_bool[i] = pContent[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2bcaa
testq %r14, %r14
jle 0x2c3fe
movq 0x8(%r15), %rax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movq 0x28(%rax), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x2c3ec
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::arraytostring[abi:cxx11](bool const*, long)
std::string alglib::arraytostring(const bool *ptr, ae_int_t n)
{
    std::string result;
    ae_int_t i;
    result = "[";
    for(i=0; i<n; i++)
    {
        if( i!=0 )
            result += ",";
        result += ptr[i] ? "true" : "false";
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xb584(%rip), %rcx      # 0x37a1d
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
testq %r14, %r14
jle 0x2c4ee
xorl %ebp, %ebp
leaq 0xb5c6(%rip), %r13      # 0x37a7c
leaq 0xb562(%rip), %r12      # 0x37a1f
testq %rbp, %rbp
je 0x2c4cd
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3470
cmpb $0x0, (%r15,%rbp)
movq %r13, %rsi
jne 0x2c4de
leaq 0xb585(%rip), %rsi      # 0x37a63
movq %rbx, %rdi
callq 0x3470
incq %rbp
cmpq %rbp, %r14
jne 0x2c4bd
leaq 0xb45e(%rip), %rsi      # 0x37953
movq %rbx, %rdi
callq 0x3470
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c511
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2c52c
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_1d_array::integer_1d_array(char const*)
alglib::integer_1d_array::integer_1d_array(const char *s)  
{
    std::vector<const char*> svec;
    size_t i;
    char *p = filter_spaces(s);
    try
    {
        str_vector_create(p, true, &svec);
        allocate_own((ae_int_t)(svec.size()), alglib_impl::DT_INT);
        for(i=0; i<svec.size(); i++)
            operator()((ae_int_t)i) = parse_int_delim(svec[i],",]");
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x17617(%rip), %rcx     # 0x43be0
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2c032
movq %rax, %r14
movq %rsp, %rdx
movq %rax, %rdi
movl $0x1, %esi
callq 0x2c0ec
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x3, %rsi
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2be04
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x2c652
xorl %r12d, %r12d
leaq 0xb330(%rip), %r15      # 0x37952
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x2c6da
movq 0x8(%rbx), %rcx
movq 0x28(%rcx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x2c622
testq %r14, %r14
je 0x2c660
movq -0x8(%r14), %rdi
callq 0x32e0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2c676
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x2c6ac
jmp 0x2c689
movq %rax, %rdi
callq 0x3100
testq %r14, %r14
je 0x2c69f
movq -0x8(%r14), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2c6c2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x2baee
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::parse_int_delim(char const*, char const*)
alglib::ae_int_t alglib::parse_int_delim(const char *s, const char *delim)
{
    const char *p;
    long long_val;
    volatile ae_int_t ae_val;
    
    p = s;

    //
    // check string structure:
    // * leading sign
    // * at least one digit
    // * delimiter
    //
    if( *s=='-' || *s=='+' )
        s++;
    if( *s==0 || strchr("1234567890",*s)==NULL)
        throw alglib::ap_error("Cannot parse value");
    while( *s!=0 && strchr("1234567890",*s)!=NULL )
        s++;
    if( *s==0 || strchr(delim,*s)==NULL )
        throw alglib::ap_error("Cannot parse value");

    // convert and ensure that value fits into ae_int_t
    s = p;
    long_val = atol(s);
    ae_val = long_val;
    if( ae_val!=long_val )
        throw alglib::ap_error("Cannot parse value");
    return ae_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x2c6fb
movq %rbx, %r12
cmpl $0x2b, %eax
jne 0x2c6ff
leaq 0x1(%rbx), %r12
movsbl (%r12), %esi
testl %esi, %esi
je 0x2c7ed
leaq 0xb36e(%rip), %rdi      # 0x37a81
movl $0xb, %edx
callq 0x32c0
testq %rax, %rax
je 0x2c7ed
movsbl (%r12), %ebp
testl %ebp, %ebp
sete %r13b
je 0x2c7bb
leaq 0xb343(%rip), %rdi      # 0x37a81
movl $0xb, %edx
movl %ebp, %esi
callq 0x32c0
testq %rax, %rax
je 0x2c77d
incq %r12
leaq 0xb328(%rip), %r15      # 0x37a81
movsbl (%r12), %ebp
testl %ebp, %ebp
sete %r13b
je 0x2c7bb
movl $0xb, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x32c0
incq %r12
testq %rax, %rax
jne 0x2c759
testb %r13b, %r13b
jne 0x2c7bb
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x30f0
testq %rax, %rax
je 0x2c7bb
movq %rbx, %rdi
callq 0x32f0
movq %rax, (%rsp)
movq (%rsp), %rcx
cmpq %rax, %rcx
jne 0x2c80b
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb29a(%rip), %rsi      # 0x37a69
movq %rax, %rdi
callq 0x2966e
leaq 0x173a2(%rip), %rsi     # 0x43b80
leaq -0x18f61(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb268(%rip), %rsi      # 0x37a69
movq %rax, %rdi
callq 0x2966e
jmp 0x2c7d7
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xb24a(%rip), %rsi      # 0x37a69
movq %rax, %rdi
callq 0x2966e
jmp 0x2c7d7
jmp 0x2c82d
jmp 0x2c82d
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_1d_array::setcontent(long, long const*)
void alglib::integer_1d_array::setcontent(ae_int_t iLen, const ae_int_t *pContent )
{
    ae_int_t i;
    setlength(iLen);
    for(i=0; i<iLen; i++)
        p_vec->ptr.p_int[i] = pContent[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2bcaa
testq %r14, %r14
jle 0x2c8d2
movq 0x8(%r15), %rax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
movq 0x28(%rax), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x2c8be
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::arraytostring[abi:cxx11](long const*, long)
std::string alglib::arraytostring(const ae_int_t *ptr, ae_int_t n)
{
    std::string result;
    ae_int_t i;
    char buf[64];
    result = "[";
    for(i=0; i<n; i++)
    {
        if( sprintf(buf, i==0 ? "%ld" : ",%ld", long(ptr[i]))>=(int)sizeof(buf) )
            throw ap_error("arraytostring(): buffer overflow");
        result += buf;
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xb0ac(%rip), %rcx      # 0x37a1d
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
testq %r14, %r14
jle 0x2c9ca
leaq 0xb10b(%rip), %r13      # 0x37a97
leaq 0x10(%rsp), %r12
xorl %ebp, %ebp
testq %rbp, %rbp
movq %r13, %rsi
leaq 0xb0f8(%rip), %rax      # 0x37a98
cmoveq %rax, %rsi
movq (%r15,%rbp,8), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3080
cmpl $0x40, %eax
jge 0x2c9eb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3470
incq %rbp
cmpq %rbp, %r14
jne 0x2c993
leaq 0xaf82(%rip), %rsi      # 0x37953
movq %rbx, %rdi
callq 0x3470
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %r15
leaq 0xb09d(%rip), %rsi      # 0x37a9c
movq %rax, %rdi
callq 0x2966e
leaq 0x17172(%rip), %rsi     # 0x43b80
leaq -0x19191(%rip), %rdx    # 0x13884
movq %r15, %rdi
callq 0x33f0
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0x2ca2f
jmp 0x2ca2c
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x2ca49
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::real_1d_array::real_1d_array(char const*)
alglib::real_1d_array::real_1d_array(const char *s)  
{
    std::vector<const char*> svec;
    size_t i;
    char *p = filter_spaces(s);
    try
    {
        str_vector_create(p, true, &svec);
        allocate_own((ae_int_t)(svec.size()), alglib_impl::DT_REAL);
        for(i=0; i<svec.size(); i++)
            operator()((ae_int_t)i) = parse_real_delim(svec[i],",]");
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x17119(%rip), %rcx     # 0x43c00
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2c032
movq %rax, %r14
movq %rsp, %rdx
movq %rax, %rdi
movl $0x1, %esi
callq 0x2c0ec
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x3, %rsi
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2be04
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x2cb72
xorl %r12d, %r12d
leaq 0xae12(%rip), %r15      # 0x37952
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x2cbfa
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x2cb40
testq %r14, %r14
je 0x2cb80
movq -0x8(%r14), %rdi
callq 0x32e0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2cb96
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x2cbcc
jmp 0x2cba9
movq %rax, %rdi
callq 0x3100
testq %r14, %r14
je 0x2cbbf
movq -0x8(%r14), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2cbe2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x2baee
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::parse_real_delim(char const*, char const*)
double alglib::parse_real_delim(const char *s, const char *delim)
{
    double result;
    const char *new_s;
    if( !_parse_real_delim(s, delim, &result, &new_s) )
        throw alglib::ap_error("Cannot parse value");
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x2f007
testb %al, %al
je 0x2cc22
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xae33(%rip), %rsi      # 0x37a69
movq %rax, %rdi
callq 0x2966e
leaq 0x16f3b(%rip), %rsi     # 0x43b80
leaq -0x193c8(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::real_1d_array::setcontent(long, double const*)
void alglib::real_1d_array::setcontent(ae_int_t iLen, const double *pContent )
{
    ae_int_t i;
    setlength(iLen);
    for(i=0; i<iLen; i++)
        p_vec->ptr.p_double[i] = pContent[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2bcaa
testq %r14, %r14
jle 0x2ccfc
movq 0x8(%r15), %rax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
movq 0x28(%rax), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x2cce6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex_1d_array::complex_1d_array(char const*)
alglib::complex_1d_array::complex_1d_array(const char *s)  
{
    std::vector<const char*> svec;
    size_t i;
    char *p = filter_spaces(s);
    try
    {
        str_vector_create(p, true, &svec);
        allocate_own((ae_int_t)(svec.size()), alglib_impl::DT_COMPLEX);
        for(i=0; i<svec.size(); i++)
            operator()((ae_int_t)i) = parse_complex_delim(svec[i],",]");
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x16b76(%rip), %rcx     # 0x43c20
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2c032
movq %rax, %r14
movq %rsp, %rdx
movq %rax, %rdi
movl $0x1, %esi
callq 0x2c0ec
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x3, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2be04
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x2d159
movl $0x8, %r13d
xorl %ebp, %ebp
leaq 0xa84a(%rip), %r15      # 0x37952
leaq 0x18(%rsp), %r12
movq (%rax,%rbp,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x2d1e4
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rax,%r13)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax,%r13)
incq %rbp
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x10, %r13
cmpq %rcx, %rbp
jb 0x2d10d
testq %r14, %r14
je 0x2d167
movq -0x8(%r14), %rdi
callq 0x32e0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2d17d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2d1b6
jmp 0x2d193
movq %rax, %rdi
callq 0x3100
testq %r14, %r14
je 0x2d1a9
movq -0x8(%r14), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2d1cc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x2baee
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex_1d_array::setcontent(long, alglib::complex const*)
void alglib::complex_1d_array::setcontent(ae_int_t iLen, const alglib::complex *pContent )
{
    ae_int_t i;
    setlength(iLen);
    for(i=0; i<iLen; i++)
    {
        p_vec->ptr.p_complex[i].x = pContent[i].x;
        p_vec->ptr.p_complex[i].y = pContent[i].y;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2bcaa
testq %r14, %r14
jle 0x2d4bd
movq 0x8(%r15), %rax
xorl %ecx, %ecx
movsd (%rbx,%rcx), %xmm0
movq 0x28(%rax), %rdx
movsd %xmm0, (%rdx,%rcx)
movsd 0x8(%rbx,%rcx), %xmm0
movq 0x28(%rax), %rdx
movsd %xmm0, 0x8(%rdx,%rcx)
addq $0x10, %rcx
decq %r14
jne 0x2d496
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::arraytostring[abi:cxx11](alglib::complex const*, long, int)
std::string alglib::arraytostring(const alglib::complex *ptr, ae_int_t n, int dps)
{
    std::string result;
    ae_int_t i;
    result = "[";
    for(i=0; i<n; i++)
    {
        if( i!=0 )
            result += ",";
        result += ptr[i].tostring(dps);
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xa4bd(%rip), %rcx      # 0x37a1d
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
testq %r14, %r14
jle 0x2d5d7
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
testq %r13, %r13
je 0x2d590
movq %rbx, %rdi
leaq 0xa494(%rip), %rsi      # 0x37a1f
callq 0x3470
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2993e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2d5cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %r13
addq $0x10, %r15
cmpq %r13, %r14
jne 0x2d57c
leaq 0xa375(%rip), %rsi      # 0x37953
movq %rbx, %rdi
callq 0x3470
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d5fc
jmp 0x2d5fc
movq %rax, %r14
jmp 0x2d620
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2d620
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2d638
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::ae_matrix_wrapper(alglib::ae_matrix_wrapper const&)
alglib::ae_matrix_wrapper::ae_matrix_wrapper(const alglib::ae_matrix_wrapper &rhs)
{
    if( rhs.p_mat!=NULL )
    {
        p_mat = &mat;
        if( !ae_matrix_init_copy(p_mat, rhs.p_mat, NULL, ae_false) )
            throw alglib::ap_error("ALGLIB: malloc error!");
    }
    else
        p_mat = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x16575(%rip), %rax     # 0x43c40
movq %rax, (%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x2d723
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x25c35
testb %al, %al
jne 0x2d72b
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xa162(%rip), %rsi      # 0x37867
movq %rax, %rdi
callq 0x2966e
leaq 0x1646c(%rip), %rsi     # 0x43b80
leaq -0x19e97(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq $0x0, 0x8(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::operator=(alglib::ae_matrix_wrapper const&)
const alglib::ae_matrix_wrapper& alglib::ae_matrix_wrapper::operator=(const alglib::ae_matrix_wrapper &rhs)
{
    if( this==&rhs )
        return *this;
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
    if( rhs.p_mat!=NULL )
    {
        p_mat = &mat;
        if( !ae_matrix_init_copy(p_mat, rhs.p_mat, NULL, ae_false) )
            throw alglib::ap_error("ALGLIB: malloc error!");
    }
    else
        p_mat = NULL;
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2d7fe
movq %rsi, %r14
movq 0x8(%rbx), %r12
leaq 0x10(%rbx), %r15
cmpq %r15, %r12
jne 0x2d7a5
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
cmpq $0x0, 0x30(%r12)
je 0x2d78d
movq 0x30(%r12), %rdi
callq *0x28(%r12)
xorl %eax, %eax
movq %rax, 0x30(%r12)
leaq -0x816f(%rip), %rcx     # 0x2562c
movq %rcx, 0x28(%r12)
movq %rax, 0x38(%r12)
cmpq $0x0, 0x8(%r14)
je 0x2d7f6
movq %r15, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x25c35
testb %al, %al
jne 0x2d7fe
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xa08f(%rip), %rsi      # 0x37867
movq %rax, %rdi
callq 0x2966e
leaq 0x16399(%rip), %rsi     # 0x43b80
leaq -0x19f6a(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::setlength(long, long)
void alglib::ae_matrix_wrapper::setlength(ae_int_t rows, ae_int_t cols)
{
    if( p_mat==NULL )
        throw alglib::ap_error("ALGLIB: setlength() error, p_mat==NULL (array was not correctly initialized)");
    if( p_mat!=&mat )
        throw alglib::ap_error("ALGLIB: setlength() error, p_mat!=&mat (attempt to resize frozen array)");
    if( !ae_matrix_set_length(p_mat, rows, cols, NULL) )
        throw alglib::ap_error("ALGLIB: malloc error");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2d84c
addq $0x10, %rax
cmpq %rax, %rdi
jne 0x2d86a
xorl %ecx, %ecx
callq 0x25df3
testb %al, %al
je 0x2d888
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xa0f8(%rip), %rsi      # 0x37958
movq %rax, %rdi
callq 0x2966e
jmp 0x2d8a4
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xa127(%rip), %rsi      # 0x379a5
movq %rax, %rdi
callq 0x2966e
jmp 0x2d8a4
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xa076(%rip), %rsi      # 0x37912
movq %rax, %rdi
callq 0x2966e
leaq 0x162d5(%rip), %rsi     # 0x43b80
leaq -0x1a02e(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
jmp 0x2d8be
jmp 0x2d8be
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::attach_to(alglib_impl::ae_matrix*)
void alglib::ae_matrix_wrapper::attach_to(alglib_impl::ae_matrix *ptr)
{
    if( ptr==&mat )
        throw alglib::ap_error("ALGLIB: attempt to attach matrix to itself");
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
    p_mat = ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x10(%rdi), %rax
cmpq %rsi, %rax
je 0x2d97c
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq %rax, %r15
jne 0x2d972
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
cmpq $0x0, 0x30(%r15)
je 0x2d95d
movq 0x30(%r15), %rdi
callq *0x28(%r15)
xorl %eax, %eax
movq %rax, 0x30(%r15)
leaq -0x833e(%rip), %rcx     # 0x2562c
movq %rcx, 0x28(%r15)
movq %rax, 0x38(%r15)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0xa05d(%rip), %rsi      # 0x379ed
movq %rax, %rdi
callq 0x2966e
leaq 0x161e1(%rip), %rsi     # 0x43b80
leaq -0x1a122(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_matrix_wrapper::allocate_own(long, long, long)
void alglib::ae_matrix_wrapper::allocate_own(ae_int_t rows, ae_int_t cols, alglib_impl::ae_datatype datatype)
{
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
    p_mat = &mat;
    if( !ae_matrix_init(p_mat, rows, cols, datatype, NULL, false) )
        throw alglib::ap_error("ALGLIB: malloc error");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq 0x8(%rdi), %rbp
leaq 0x10(%rdi), %r12
cmpq %r12, %rbp
jne 0x2da18
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
cmpq $0x0, 0x30(%rbp)
je 0x2da03
movq 0x30(%rbp), %rdi
callq *0x28(%rbp)
xorl %eax, %eax
movq %rax, 0x30(%rbp)
leaq -0x83e4(%rip), %rcx     # 0x2562c
movq %rcx, 0x28(%rbp)
movq %rax, 0x38(%rbp)
movq %r12, 0x8(%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x25b46
testb %al, %al
je 0x2da46
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3140
movq %rax, %rbx
leaq 0x9eb8(%rip), %rsi      # 0x37912
movq %rax, %rdi
callq 0x2966e
leaq 0x16117(%rip), %rsi     # 0x43b80
leaq -0x1a1ec(%rip), %rdx    # 0x13884
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_2d_array::boolean_2d_array(char const*)
alglib::boolean_2d_array::boolean_2d_array(const char *s)  
{
    std::vector< std::vector<const char*> > smat;
    size_t i, j;
    char *p = filter_spaces(s);
    try
    {
        str_matrix_create(p, &smat);
        if( smat.size()!=0 )
        {
            allocate_own((ae_int_t)(smat.size()), (ae_int_t)(smat[0].size()), alglib_impl::DT_BOOL);
            for(i=0; i<smat.size(); i++)
                for(j=0; j<smat[0].size(); j++)
                    operator()((ae_int_t)i,(ae_int_t)j) = parse_bool_delim(smat[i][j],",]");
        }
        else
            allocate_own(0, 0, alglib_impl::DT_BOOL);
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x1612e(%rip), %rcx     # 0x43c60
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2c032
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2dca5
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
subq %rax, %rsi
je 0x2dc1b
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rsi
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x3, %rdx
movl $0x1, %ecx
movq %rbx, %rdi
callq 0x2d9c2
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x2dc2c
xorl %r13d, %r13d
leaq 0x9da4(%rip), %r15      # 0x37952
movq (%rsp), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x2dc00
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r14d, %r14d
movq (%rax,%rbp,8), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2c21a
movq 0x8(%rbx), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%r13,8), %rcx
movb %al, (%rcx,%r14)
incq %r14
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x2dbc9
movq 0x8(%rsp), %rax
subq (%rsp), %rax
incq %r13
sarq $0x3, %rax
imulq %r12, %rax
cmpq %rax, %r13
jb 0x2dbae
jmp 0x2dc2c
movl $0x1, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d9c2
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2dc3f
movq -0x8(%rax), %rdi
callq 0x32e0
movq %rsp, %rdi
callq 0x33526
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2dc85
jmp 0x2dc5d
movq %rax, %rdi
callq 0x3100
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2dc78
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq %rsp, %rdi
callq 0x33526
movq %rbx, %rdi
callq 0x2d654
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_2d_array::setcontent(long, long, bool const*)
void alglib::boolean_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const bool *pContent )
{
    ae_int_t i, j;
    setlength(irows, icols);
    for(i=0; i<irows; i++)
        for(j=0; j<icols; j++)
            p_mat->ptr.pp_bool[i][j] = pContent[i*icols+j];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2d820
testq %r15, %r15
jle 0x2df09
movq 0x8(%r12), %rax
xorl %ecx, %ecx
testq %r14, %r14
jle 0x2defe
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movq 0x38(%rax), %rdi
movq (%rdi,%rcx,8), %rdi
movb %sil, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %r14
jne 0x2dee6
incq %rcx
addq %r14, %rbx
cmpq %r15, %rcx
jne 0x2dedf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::boolean_2d_array::tostring[abi:cxx11]() const
std::string alglib::boolean_2d_array::tostring() const 
{
    std::string result;
    ae_int_t i;
    if( isempty() )
        return "[[]]";
    result = "[";
    for(i=0; i<rows(); i++)
    {
        if( i!=0 )
            result += ",";
        result += arraytostring(&operator()(i,0), cols());
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2e00a
cmpq $0x0, (%rax)
je 0x2e00a
cmpq $0x0, 0x8(%rax)
je 0x2e00a
movq %rsi, %r14
leaq 0x9ab5(%rip), %rcx      # 0x37a1d
leaq 0x8(%rsp), %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
leaq 0x38(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2df9c
movq (%rax), %rax
jmp 0x2df9e
xorl %eax, %eax
cmpq %rax, %r13
jge 0x2e029
testq %r13, %r13
je 0x2dfbb
movq %r12, %rdi
leaq 0x9a69(%rip), %rsi      # 0x37a1f
callq 0x3470
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2dfca
movq 0x8(%rax), %rdx
jmp 0x2dfcc
xorl %edx, %edx
movq 0x38(%rax), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
callq 0x2c467
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e005
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %r13
jmp 0x2df8e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9a00(%rip), %rsi      # 0x37a18
leaq 0x99fd(%rip), %rdx      # 0x37a1c
movq %rbx, %rdi
callq 0x33574
jmp 0x2e081
leaq 0x9923(%rip), %rsi      # 0x37953
leaq 0x8(%rsp), %rdi
callq 0x3470
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r15
cmpq %r15, %rcx
je 0x2e05e
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2e065
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e098
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e0cc
jmp 0x2e0cc
jmp 0x2e0cc
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e0cf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2e0cf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e0eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_2d_array::integer_2d_array(char const*)
alglib::integer_2d_array::integer_2d_array(const char *s)  
{
    std::vector< std::vector<const char*> > smat;
    size_t i, j;
    char *p = filter_spaces(s);
    try
    {
        str_matrix_create(p, &smat);
        if( smat.size()!=0 )
        {
            allocate_own((ae_int_t)(smat.size()), (ae_int_t)(smat[0].size()), alglib_impl::DT_INT);
            for(i=0; i<smat.size(); i++)
                for(j=0; j<smat[0].size(); j++)
                    operator()((ae_int_t)i,(ae_int_t)j) = parse_int_delim(smat[i][j],",]");
        }
        else
            allocate_own(0, 0, alglib_impl::DT_INT);
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x15af2(%rip), %rcx     # 0x43c80
movq %rcx, (%rdi)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2c032
movq %rsp, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x2dca5
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
subq %rax, %rsi
je 0x2e277
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rsi
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x3, %rdx
movl $0x2, %ecx
movq %rbx, %rdi
callq 0x2d9c2
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x2e288
xorl %r13d, %r13d
leaq 0x9748(%rip), %r15      # 0x37952
movq (%rsp), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x2e25c
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r14d, %r14d
movq (%rax,%rbp,8), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2c6da
movq 0x8(%rbx), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x2e225
movq 0x8(%rsp), %rax
subq (%rsp), %rax
incq %r13
sarq $0x3, %rax
imulq %r12, %rax
cmpq %rax, %r13
jb 0x2e20a
jmp 0x2e288
movl $0x2, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d9c2
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2e29b
movq -0x8(%rax), %rdi
callq 0x32e0
movq %rsp, %rdi
callq 0x33526
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2e2e1
jmp 0x2e2b9
movq %rax, %rdi
callq 0x3100
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2e2d4
movq -0x8(%rax), %rdi
callq 0x32e0
callq 0x3360
movq %rax, %r14
callq 0x33c0
movq %rsp, %rdi
callq 0x33526
movq %rbx, %rdi
callq 0x2d654
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_2d_array::setcontent(long, long, long const*)
void alglib::integer_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const ae_int_t *pContent )
{
    ae_int_t i, j;
    setlength(irows, icols);
    for(i=0; i<irows; i++)
        for(j=0; j<icols; j++)
            p_mat->ptr.pp_int[i][j] = pContent[i*icols+j];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2d820
testq %r15, %r15
jle 0x2e3b9
movq 0x8(%r12), %rax
leaq (,%r14,8), %rcx
xorl %edx, %edx
testq %r14, %r14
jle 0x2e3ae
xorl %esi, %esi
movq (%rbx,%rsi,8), %rdi
movq 0x38(%rax), %r8
movq (%r8,%rdx,8), %r8
movq %rdi, (%r8,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0x2e396
incq %rdx
addq %rcx, %rbx
cmpq %r15, %rdx
jne 0x2e38f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::integer_2d_array::tostring[abi:cxx11]() const
std::string alglib::integer_2d_array::tostring() const 
{
    std::string result;
    ae_int_t i;
    if( isempty() )
        return "[[]]";
    result = "[";
    for(i=0; i<rows(); i++)
    {
        if( i!=0 )
            result += ",";
        result += arraytostring(&operator()(i,0), cols());
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2e4ba
cmpq $0x0, (%rax)
je 0x2e4ba
cmpq $0x0, 0x8(%rax)
je 0x2e4ba
movq %rsi, %r14
leaq 0x9605(%rip), %rcx      # 0x37a1d
leaq 0x8(%rsp), %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
leaq 0x38(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e44c
movq (%rax), %rax
jmp 0x2e44e
xorl %eax, %eax
cmpq %rax, %r13
jge 0x2e4d9
testq %r13, %r13
je 0x2e46b
movq %r12, %rdi
leaq 0x95b9(%rip), %rsi      # 0x37a1f
callq 0x3470
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e47a
movq 0x8(%rax), %rdx
jmp 0x2e47c
xorl %edx, %edx
movq 0x38(%rax), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
callq 0x2c93b
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e4b5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
incq %r13
jmp 0x2e43e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9550(%rip), %rsi      # 0x37a18
leaq 0x954d(%rip), %rdx      # 0x37a1c
movq %rbx, %rdi
callq 0x33574
jmp 0x2e531
leaq 0x9473(%rip), %rsi      # 0x37953
leaq 0x8(%rsp), %rdi
callq 0x3470
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r15
cmpq %r15, %rcx
je 0x2e50e
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2e515
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e548
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e57c
jmp 0x2e57c
jmp 0x2e57c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e57f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x2e57f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e59b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3420
nop