LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x471c0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x485d5
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4859d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x33e0
movq -0x88(%rbp), %rdi
leaq 0xfd92(%rip), %rsi      # 0x584a1
callq 0x33d0
jmp 0x48716
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x487f3
leaq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq 0xfde0(%rip), %rsi      # 0x5851b
leaq 0xfdda(%rip), %rax      # 0x5851c
cmpq $0x0, %rcx
cmoveq %rax, %rsi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movb $0x0, %al
callq 0x3080
cmpl $0x40, %eax
jl 0x487ce
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
leaq 0xfda0(%rip), %rsi      # 0x58520
callq 0x42660
jmp 0x48787
movq -0x98(%rbp), %rdi
leaq 0x1c3e3(%rip), %rsi     # 0x64b78
leaq -0x2afec(%rip), %rdx    # 0x1d7b0
callq 0x3490
jmp 0x48843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4882e
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x31e0
jmp 0x4882e
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x32c0
jmp 0x487e0
jmp 0x487e2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4871e
movq -0x88(%rbp), %rdi
leaq 0xfbd6(%rip), %rsi      # 0x583d7
callq 0x32c0
jmp 0x48808
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4881e
movq -0x88(%rbp), %rdi
callq 0x31a0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x31a0
movq -0x78(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x46f40
movq -0x58(%rbp), %rax
leaq 0x1c2b0(%rip), %rcx     # 0x64bf8
movq %rcx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x530a0
movq -0x10(%rbp), %rdi
callq 0x476e0
movq %rax, -0x50(%rbp)
jmp 0x48963
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x477e0
jmp 0x4897f
leaq -0x28(%rbp), %rdi
callq 0x530c0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x47400
jmp 0x4899b
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x530c0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x48a48
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x530e0
movq (%rax), %rdi
leaq 0xf9fb(%rip), %rsi      # 0x583d6
callq 0x48aa0
movsd %xmm0, -0x68(%rbp)
jmp 0x489e7
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x48b30
movq %rax, -0x70(%rbp)
jmp 0x489fa
movq -0x70(%rbp), %rax
movsd -0x68(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x489a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x48a77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
callq 0x30f0
movq -0x38(%rbp), %rdi
callq 0x3ad30
callq 0x3420
jmp 0x48a9a
movq -0x38(%rbp), %rdi
callq 0x3ad30
jmp 0x48a68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3460
jmp 0x48a66
jmp 0x48a77
leaq -0x28(%rbp), %rdi
callq 0x53100
addq $0x70, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x53100
movq -0x58(%rbp), %rdi
callq 0x46f70
movq -0x40(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x4c220
testb $0x1, %al
jne 0x48b19
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xfa09(%rip), %rsi      # 0x584ed
callq 0x42660
jmp 0x48aeb
movq -0x38(%rbp), %rdi
leaq 0x1c082(%rip), %rsi     # 0x64b78
leaq -0x2b34d(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31e0
jmp 0x48b24
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x471c0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x48ca7
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x48c6d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x46f40
movq -0x68(%rbp), %rax
leaq 0x1b91d(%rip), %rcx     # 0x64c18
movq %rcx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x530a0
movq -0x10(%rbp), %rdi
callq 0x476e0
movq %rax, -0x60(%rbp)
jmp 0x49316
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x477e0
jmp 0x49332
leaq -0x28(%rbp), %rdi
callq 0x530c0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x47400
jmp 0x4934e
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x530c0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x493fa
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x530e0
movq (%rax), %rsi
leaq 0xf048(%rip), %rdx      # 0x583d6
leaq -0x58(%rbp), %rdi
callq 0x49450
jmp 0x49399
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x497f0
movq %rax, -0x78(%rbp)
jmp 0x493ac
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x42960
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x49356
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4942c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
callq 0x30f0
movq -0x38(%rbp), %rdi
callq 0x3ad30
callq 0x3420
jmp 0x4944f
movq -0x38(%rbp), %rdi
callq 0x3ad30
jmp 0x4941a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3460
jmp 0x49418
jmp 0x4942c
leaq -0x28(%rbp), %rdi
callq 0x53100
addq $0x80, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x53100
movq -0x68(%rbp), %rdi
callq 0x46f70
movq -0x40(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x471c0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4999f
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movsd (%rcx), %xmm0
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movsd %xmm0, (%rcx)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movsd 0x8(%rcx), %xmm0
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4992d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x33e0
movq -0x60(%rbp), %rdi
leaq 0xe9bb(%rip), %rsi      # 0x584a1
callq 0x33d0
jmp 0x49aed
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x49b89
cmpq $0x0, -0x28(%rbp)
je 0x49b2f
movq -0x60(%rbp), %rdi
leaq 0xe98e(%rip), %rsi      # 0x584a3
callq 0x32c0
jmp 0x49b1c
jmp 0x49b2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x49bb8
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movl -0x1c(%rbp), %edx
leaq -0x58(%rbp), %rdi
callq 0x42c50
jmp 0x49b4c
movq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x33b0
jmp 0x49b5b
leaq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x49af5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31a0
jmp 0x49bb8
movq -0x60(%rbp), %rdi
leaq 0xe843(%rip), %rsi      # 0x583d7
callq 0x32c0
jmp 0x49b9b
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x49bae
movq -0x60(%rbp), %rdi
callq 0x31a0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x31a0
movq -0x30(%rbp), %rdi
callq 0x34c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1af89(%rip), %rcx     # 0x64c28
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x49d2d
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x3b980
testb $0x1, %al
jne 0x49d2b
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0xe5f5(%rip), %rsi      # 0x582eb
callq 0x42660
jmp 0x49cfd
movq -0x30(%rbp), %rdi
leaq 0x1ae70(%rip), %rsi     # 0x64b78
leaq -0x2c55f(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31e0
jmp 0x49d3f
jmp 0x49d39
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x49d7b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49e34
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x49d99
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3bdd0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x49e20
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x3b980
testb $0x1, %al
jne 0x49e1e
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xe502(%rip), %rsi      # 0x582eb
callq 0x42660
jmp 0x49df0
movq -0x38(%rbp), %rdi
leaq 0x1ad7d(%rip), %rsi     # 0x64b78
leaq -0x2c652(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31e0
jmp 0x49e3e
jmp 0x49e2c
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x49ec6
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xe54e(%rip), %rsi      # 0x583dc
callq 0x42660
jmp 0x49e95
movq -0x38(%rbp), %rdi
leaq 0x1acd8(%rip), %rsi     # 0x64b78
leaq -0x2c6f7(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31e0
jmp 0x49f9a
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
je 0x49f27
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0xe537(%rip), %rsi      # 0x58429
callq 0x42660
jmp 0x49ef9
movq -0x40(%rbp), %rdi
leaq 0x1ac74(%rip), %rsi     # 0x64b78
leaq -0x2c75b(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31e0
jmp 0x49f9a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3bc30
testb $0x1, %al
jne 0x49f94
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0xe437(%rip), %rsi      # 0x58396
callq 0x42660
jmp 0x49f66
movq -0x48(%rbp), %rdi
leaq 0x1ac07(%rip), %rsi     # 0x64b78
leaq -0x2c7c8(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31e0
jmp 0x49f9a
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x4a135
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0xe371(%rip), %rsi      # 0x58471
callq 0x42660
jmp 0x4a107
movq -0x30(%rbp), %rdi
leaq 0x1aa66(%rip), %rsi     # 0x64b78
leaq -0x2c969(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31e0
jmp 0x4a165
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x4a153
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3bdd0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34c0
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x4a1aa
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3bdd0
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x3b7d0
testb $0x1, %al
jne 0x4a22a
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0xe1a1(%rip), %rsi      # 0x58396
callq 0x42660
jmp 0x4a1fc
movq -0x40(%rbp), %rdi
leaq 0x1a971(%rip), %rsi     # 0x64b78
leaq -0x2ca5e(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31e0
jmp 0x4a230
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49e50
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4aa71
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4aa61
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
imulq -0x18(%rbp), %rdx
addq -0x30(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4aa17
jmp 0x4aa63
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4aa05
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x33e0
movq -0x78(%rbp), %rdi
callq 0x4a030
testb $0x1, %al
jne 0x4aac1
jmp 0x4ab1c
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x34d0
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0xd9b6(%rip), %rsi      # 0x5849c
callq 0x52fa0
jmp 0x4aaed
leaq -0x39(%rbp), %rdi
callq 0x3330
movl $0x1, -0x50(%rbp)
jmp 0x4ac28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3330
jmp 0x4ac3e
leaq 0xd97e(%rip), %rsi      # 0x584a1
leaq -0x30(%rbp), %rdi
callq 0x33d0
jmp 0x4ab2e
movq $0x0, -0x38(%rbp)
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x49fb0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jge 0x4abff
cmpq $0x0, -0x38(%rbp)
je 0x4ab89
leaq 0xd938(%rip), %rsi      # 0x584a3
leaq -0x30(%rbp), %rdi
callq 0x32c0
jmp 0x4ab76
jmp 0x4ab89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4ac3e
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4a940
movq -0x78(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x49ff0
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0x47f10
jmp 0x4abbf
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x33b0
jmp 0x4abce
leaq -0x70(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4ab36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31a0
jmp 0x4ac3e
leaq 0xd7d1(%rip), %rsi      # 0x583d7
leaq -0x30(%rbp), %rdi
callq 0x32c0
jmp 0x4ac11
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3190
movl $0x1, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rdi
callq 0x34c0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49e50
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4b130
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4b120
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
imulq -0x18(%rbp), %rdx
addq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4b0d7
jmp 0x4b122
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4b0c5
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x33e0
movq -0x78(%rbp), %rdi
callq 0x4a030
testb $0x1, %al
jne 0x4b181
jmp 0x4b1dc
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x34d0
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0xd2f6(%rip), %rsi      # 0x5849c
callq 0x52fa0
jmp 0x4b1ad
leaq -0x39(%rbp), %rdi
callq 0x3330
movl $0x1, -0x50(%rbp)
jmp 0x4b2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3330
jmp 0x4b2fe
leaq 0xd2be(%rip), %rsi      # 0x584a1
leaq -0x30(%rbp), %rdi
callq 0x33d0
jmp 0x4b1ee
movq $0x0, -0x38(%rbp)
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x49fb0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jge 0x4b2bf
cmpq $0x0, -0x38(%rbp)
je 0x4b249
leaq 0xd278(%rip), %rsi      # 0x584a3
leaq -0x30(%rbp), %rdi
callq 0x32c0
jmp 0x4b236
jmp 0x4b249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4b2fe
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4aff0
movq -0x78(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x49ff0
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0x486d0
jmp 0x4b27f
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x33b0
jmp 0x4b28e
leaq -0x70(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4b1f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31a0
jmp 0x4b2fe
leaq 0xd111(%rip), %rsi      # 0x583d7
leaq -0x30(%rbp), %rdi
callq 0x32c0
jmp 0x4b2d1
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3190
movl $0x1, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rdi
callq 0x34c0
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::real_2d_array::setcontent(long, long, double const*)
void alglib::real_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const double *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_double[i][j] = pContent[i*icols+j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49e50
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4b7f2
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4b7e2
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
imulq -0x18(%rbp), %rdx
addq -0x30(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4b797
jmp 0x4b7e4
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4b785
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::real_2d_array::tostring[abi:cxx11](int) const
std::string alglib::real_2d_array::tostring(int dps) 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(), dps);
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33e0
movq -0x80(%rbp), %rdi
callq 0x4a030
testb $0x1, %al
jne 0x4b847
jmp 0x4b8a2
leaq -0x41(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x34d0
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0xcc30(%rip), %rsi      # 0x5849c
callq 0x52fa0
jmp 0x4b873
leaq -0x41(%rbp), %rdi
callq 0x3330
movl $0x1, -0x58(%rbp)
jmp 0x4b9b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3330
jmp 0x4b9ca
leaq 0xcbf8(%rip), %rsi      # 0x584a1
leaq -0x38(%rbp), %rdi
callq 0x33d0
jmp 0x4b8b4
movq $0x0, -0x40(%rbp)
movq -0x80(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x49fb0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jge 0x4b988
cmpq $0x0, -0x40(%rbp)
je 0x4b90f
leaq 0xcbb2(%rip), %rsi      # 0x584a3
leaq -0x38(%rbp), %rdi
callq 0x32c0
jmp 0x4b8fc
jmp 0x4b90f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4b9ca
movq -0x80(%rbp), %rdi
movq -0x40(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4b6b0
movq -0x80(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x49ff0
movq -0xa8(%rbp), %rsi
movq %rax, %rdx
movl -0x14(%rbp), %ecx
leaq -0x78(%rbp), %rdi
callq 0x48db0
jmp 0x4b948
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x33b0
jmp 0x4b957
leaq -0x78(%rbp), %rdi
callq 0x31a0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x4b8bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x31a0
jmp 0x4b9ca
leaq 0xca48(%rip), %rsi      # 0x583d7
leaq -0x38(%rbp), %rdi
callq 0x32c0
jmp 0x4b99a
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3190
movl $0x1, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x50(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex_2d_array::setcontent(long, long, alglib::complex const*)
void alglib::complex_2d_array::setcontent(ae_int_t irows, ae_int_t icols, const alglib::complex *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_complex[i][j].x = pContent[i*icols+j].x;
            p_mat->ptr.pp_complex[i][j].y = pContent[i*icols+j].y;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49e50
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4bf19
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4bf06
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
imulq -0x18(%rbp), %rdx
addq -0x30(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movsd (%rcx), %xmm0
movq 0x8(%rax), %rcx
movq 0x38(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq -0x30(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movsd %xmm0, (%rcx)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
imulq -0x18(%rbp), %rdx
addq -0x30(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movsd 0x8(%rcx), %xmm0
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4be6b
jmp 0x4bf08
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4be55
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex_2d_array::tostring[abi:cxx11](int) const
std::string alglib::complex_2d_array::tostring(int dps) 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(), dps);
    }
    result += "]";
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33e0
movq -0x80(%rbp), %rdi
callq 0x4a030
testb $0x1, %al
jne 0x4bf67
jmp 0x4bfc2
leaq -0x41(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x34d0
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0xc510(%rip), %rsi      # 0x5849c
callq 0x52fa0
jmp 0x4bf93
leaq -0x41(%rbp), %rdi
callq 0x3330
movl $0x1, -0x58(%rbp)
jmp 0x4c0d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3330
jmp 0x4c0ea
leaq 0xc4d8(%rip), %rsi      # 0x584a1
leaq -0x38(%rbp), %rdi
callq 0x33d0
jmp 0x4bfd4
movq $0x0, -0x40(%rbp)
movq -0x80(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x49fb0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jge 0x4c0a8
cmpq $0x0, -0x40(%rbp)
je 0x4c02f
leaq 0xc492(%rip), %rsi      # 0x584a3
leaq -0x38(%rbp), %rdi
callq 0x32c0
jmp 0x4c01c
jmp 0x4c02f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4c0ea
movq -0x80(%rbp), %rdi
movq -0x40(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4bd80
movq -0x80(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x49ff0
movq -0xa8(%rbp), %rsi
movq %rax, %rdx
movl -0x14(%rbp), %ecx
leaq -0x78(%rbp), %rdi
callq 0x49ab0
jmp 0x4c068
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x33b0
jmp 0x4c077
leaq -0x78(%rbp), %rdi
callq 0x31a0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x4bfdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x31a0
jmp 0x4c0ea
leaq 0xc328(%rip), %rsi      # 0x583d7
leaq -0x38(%rbp), %rdi
callq 0x32c0
jmp 0x4c0ba
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3190
movl $0x1, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x50(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::my_stricmp(char const*, char const*)
alglib::ae_int_t alglib::my_stricmp(const char *s1, const char *s2)
{
    int c1, c2;
    
    //
    // handle special cases
    //
    if(s1==NULL && s2!=NULL)
        return -1;
    if(s1!=NULL && s2==NULL)
        return +1;
    if(s1==NULL && s2==NULL)
        return 0;

    //
    // compare
    //
    for (;;)
    {
        c1 = *s1;
        c2 = *s2;
        s1++;
        s2++;
        if( c1==0 )
            return c2==0 ? 0 : -1;
        if( c2==0 )
            return c1==0 ? 0 : +1;
        c1 = tolower(c1);
        c2 = tolower(c2);
        if( c1<c2 )
            return -1;
        if( c1>c2 )
            return +1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4c12b
cmpq $0x0, -0x18(%rbp)
je 0x4c12b
movq $-0x1, -0x8(%rbp)
jmp 0x4c20a
cmpq $0x0, -0x10(%rbp)
je 0x4c146
cmpq $0x0, -0x18(%rbp)
jne 0x4c146
movq $0x1, -0x8(%rbp)
jmp 0x4c20a
cmpq $0x0, -0x10(%rbp)
jne 0x4c161
cmpq $0x0, -0x18(%rbp)
jne 0x4c161
movq $0x0, -0x8(%rbp)
jmp 0x4c20a
jmp 0x4c163
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x4c1ad
movl -0x20(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x4c20a
cmpl $0x0, -0x20(%rbp)
jne 0x4c1cb
movl -0x1c(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x4c20a
movl -0x1c(%rbp), %edi
callq 0x3410
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %edi
callq 0x3410
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4c1f3
movq $-0x1, -0x8(%rbp)
jmp 0x4c20a
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x4c205
movq $0x1, -0x8(%rbp)
jmp 0x4c20a
jmp 0x4c163
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::randomreal()
double alglib::randomreal()
{
    int i1 = rand();
    int i2 = rand();
    while(i1==RAND_MAX)
        i1 =rand();
    while(i2==RAND_MAX)
        i2 =rand();
    double mx = RAND_MAX;
    return (i1+i2/mx)/mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x30b0
movl %eax, -0x4(%rbp)
callq 0x30b0
movl %eax, -0x8(%rbp)
cmpl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jne 0x4c76b
callq 0x30b0
movl %eax, -0x4(%rbp)
jmp 0x4c758
jmp 0x4c76d
cmpl $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
jne 0x4c780
callq 0x30b0
movl %eax, -0x8(%rbp)
jmp 0x4c76d
movsd 0x8a38(%rip), %xmm0     # 0x551c0
movsd %xmm0, -0x10(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
divsd -0x10(%rbp), %xmm1
addsd %xmm1, %xmm0
divsd -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vzero(long, double*, long)
void _ialglib_vzero(ae_int_t n, double *p, ae_int_t stride)
{
    ae_int_t i;
    if( stride==1 )
    {
        for(i=0; i<n; i++,p++)
            *p = 0.0;
    }
    else
    {
        for(i=0; i<n; i++,p+=stride)
            *p = 0.0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x4db70
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4db6e
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x4db3f
jmp 0x4dbad
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4dbab
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4db78
jmp 0x4dbad
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vzero_complex(long, alglib_impl::ae_complex*, long)
void _ialglib_vzero_complex(ae_int_t n, ae_complex *p, ae_int_t stride)
{
    ae_int_t i;
    if( stride==1 )
    {
        for(i=0; i<n; i++,p++)
        {
            p->x = 0.0;
            p->y = 0.0;
        }
    }
    else
    {
        for(i=0; i<n; i++,p+=stride)
        {
            p->x = 0.0;
            p->y = 0.0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x4dc0c
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4dc0a
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x4dbcf
jmp 0x4dc55
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4dc53
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4dc14
jmp 0x4dc55
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vcopy(long, double const*, long, double*, long)
void _ialglib_vcopy(ae_int_t n, const double *a, ae_int_t stridea, double *b, ae_int_t strideb)
{
    ae_int_t i, n2;
    if( stridea==1 && strideb==1 )
    {
        n2 = n/2;
        for(i=n2; i!=0; i--, a+=2, b+=2)
        {
            b[0] = a[0];
            b[1] = a[1];
        }
        if( n%2!=0 )
            b[0] = a[0];
    }
    else
    {
        for(i=0; i<n; i++,a+=stridea,b+=strideb)
            *b = *a;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x4dd1d
cmpq $0x1, -0x28(%rbp)
jne 0x4dd1d
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4dcf7
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x4dca8
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x4dd1b
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x4dd6f
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4dd6d
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4dd25
jmp 0x4dd6f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vcopy_complex(long, alglib_impl::ae_complex const*, long, double*, long, char const*)
void _ialglib_vcopy_complex(ae_int_t n, const ae_complex *a, ae_int_t stridea, double *b, ae_int_t strideb, const char *conj)
{
    ae_int_t i;

    /*
     * more general case
     */
    if( conj[0]=='N' || conj[0]=='n' )
    {
        for(i=0; i<n; i++,a+=stridea,b+=2*strideb)
        {
            b[0] = a->x;
            b[1] = a->y;
        }
    }
    else
    {
        for(i=0; i<n; i++,a+=stridea,b+=2*strideb)
        {
            b[0] = a->x;
            b[1] = -a->y;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
je 0x4ddb4
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x4de1b
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4de19
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4ddbc
jmp 0x4de99
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4de97
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4de23
jmp 0x4de99
popq %rbp
retq
nopl (%rax,%rax)