LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_dotproduct(double const*, long, double const*, long, long)
double ae_v_dotproduct(const double *v0, ae_int_t stride0, const double *v1, ae_int_t stride1, ae_int_t n)
{
    double result = 0;
    ae_int_t i;
    if( stride0!=1 || stride1!=1 )
    {
        /*
         * slow general code
         */
        for(i=0; i<n; i++, v0+=stride0, v1+=stride1)
            result += (*v0)*(*v1);
    }
    else
    {
        /*
         * optimized code for stride=1
         */
        ae_int_t n4 = n/4;
        ae_int_t nleft = n%4;
        for(i=0; i<n4; i++, v0+=4, v1+=4)
            result += v0[0]*v1[0]+v0[1]*v1[1]+v0[2]*v1[2]+v0[3]*v1[3];
        for(i=0; i<nleft; i++, v0++, v1++)
            result += v0[0]*v1[0];
    }
    return result;
}

// Assembly:
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)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x4196e
cmpq $0x1, -0x20(%rbp)
je 0x419d5
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x419d0
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x41976
jmp 0x41afc
movq -0x28(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
movq %rdx, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x41aa0
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x41a01
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jge 0x41afa
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x41aa8
jmp 0x41afc
movsd -0x30(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_move(double*, long, double const*, long, long)
void ae_v_move(double *vdst,  ae_int_t stride_dst, const double* vsrc,  ae_int_t stride_src, ae_int_t n)
{
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        /*
         * general unoptimized case
         */
        for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            *vdst = *vsrc;
    }
    else
    {
        /*
         * optimized case
         */
        ae_int_t n2 = n/2;
        for(i=0; i<n2; i++, vdst+=2, vsrc+=2)
        {
            vdst[0] = vsrc[0];
            vdst[1] = vsrc[1];
        }
        if( n%2!=0 )
            vdst[0] = vsrc[0];
    }
}

// Assembly:
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, -0x10(%rbp)
jne 0x41b36
cmpq $0x1, -0x20(%rbp)
je 0x41b8b
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x41b86
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x41b3e
jmp 0x41c1d
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x41bf7
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x41ba5
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x41c1b
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x41c1d
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_moved(double*, long, double const*, long, long, double)
void ae_v_moved(double *vdst,  ae_int_t stride_dst, const double* vsrc,  ae_int_t stride_src, ae_int_t n, double alpha)
{
    ae_int_t i;
    if( stride_dst!=1 || stride_src!=1 )
    {
        /*
         * general unoptimized case
         */
        for(i=0; i<n; i++, vdst+=stride_dst, vsrc+=stride_src)
            *vdst = alpha*(*vsrc);
    }
    else
    {
        /*
         * optimized case
         */
        ae_int_t n2 = n/2;
        for(i=0; i<n2; i++, vdst+=2, vsrc+=2)
        {
            vdst[0] = alpha*vsrc[0];
            vdst[1] = alpha*vsrc[1];
        }
        if( n%2!=0 )
            vdst[0] = alpha*vsrc[0];
    }
}

// Assembly:
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)
movsd %xmm0, -0x30(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x41dbb
cmpq $0x1, -0x20(%rbp)
je 0x41e15
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x41e10
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x41dc3
jmp 0x41eb6
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x41e8b
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x41e2f
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x41eb4
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x41eb6
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_muld(double*, long, long, double)
void ae_v_muld(double *vdst,  ae_int_t stride_dst, ae_int_t n, double alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        /*
         * general unoptimized case
         */
        for(i=0; i<n; i++, vdst+=stride_dst)
            *vdst *= alpha;
    }
    else
    {
        /*
         * highly optimized case
         */
        for(i=0; i<n; i++, vdst++)
            *vdst *= alpha;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
cmpq $0x1, -0x10(%rbp)
je 0x4232f
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4232d
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x422f4
jmp 0x4236e
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4236c
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x42337
jmp 0x4236e
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_rcommstate_init(alglib_impl::rcommstate*, alglib_impl::ae_state*, bool)
ae_bool _rcommstate_init(rcommstate* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->ba, 0, DT_BOOL,    _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ia, 0, DT_INT,     _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ra, 0, DT_REAL,    _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->ca, 0, DT_COMPLEX, _state, make_automatic) )
        return ae_false;
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
xorl %edx, %edx
movl %edx, %esi
movl $0x1, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x423d7
movb $0x0, -0x1(%rbp)
jmp 0x42465
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
xorl %edx, %edx
movl %edx, %esi
movl $0x2, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x42404
movb $0x0, -0x1(%rbp)
jmp 0x42465
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
xorl %edx, %edx
movl %edx, %esi
movl $0x3, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x42431
movb $0x0, -0x1(%rbp)
jmp 0x42465
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
xorl %edx, %edx
movl %edx, %esi
movl $0x4, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x42461
movb $0x0, -0x1(%rbp)
jmp 0x42465
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_rcommstate_init_copy(alglib_impl::rcommstate*, alglib_impl::rcommstate*, alglib_impl::ae_state*, bool)
ae_bool _rcommstate_init_copy(rcommstate* dst, rcommstate* src, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init_copy(&dst->ba, &src->ba, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ia, &src->ia, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ra, &src->ra, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->ca, &src->ca, _state, make_automatic) )
        return ae_false;
    dst->stage = src->stage;
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
addq $0x38, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x424b9
movb $0x0, -0x1(%rbp)
jmp 0x42550
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x424e4
movb $0x0, -0x1(%rbp)
jmp 0x42550
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
addq $0x68, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x4250f
movb $0x0, -0x1(%rbp)
jmp 0x42550
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
addq $0x98, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x42540
movb $0x0, -0x1(%rbp)
jmp 0x42550
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_rcommstate_clear(alglib_impl::rcommstate*)
void _rcommstate_clear(rcommstate* p)
{
    ae_vector_clear(&p->ba);
    ae_vector_clear(&p->ia);
    ae_vector_clear(&p->ra);
    ae_vector_clear(&p->ca);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x3b6f0
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
callq 0x3b6f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::get_aenv_nan()
double alglib::get_aenv_nan()
{
    double r;
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    r = _alglib_env_state.v_nan;
    alglib_impl::ae_state_clear(&_alglib_env_state);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x58(%rbp), %rdi
callq 0x3ae90
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::get_aenv_posinf()
double alglib::get_aenv_posinf()
{
    double r;
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    r = _alglib_env_state.v_posinf;
    alglib_impl::ae_state_clear(&_alglib_env_state);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x58(%rbp), %rdi
callq 0x3ae90
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::get_aenv_neginf()
double alglib::get_aenv_neginf()
{
    double r;
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    r = _alglib_env_state.v_neginf;
    alglib_impl::ae_state_clear(&_alglib_env_state);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x58(%rbp), %rdi
callq 0x3ae90
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex::operator*=(alglib::complex const&)
alglib::complex& alglib::complex::operator*=(const alglib::complex& z)
{
    double t = x*z.x-y*z.y;
    y = x*z.y+y*z.x;
    x = t; 
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm2
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rcx
mulsd 0x8(%rcx), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd (%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm2
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rcx
mulsd (%rcx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::complex::operator/=(alglib::complex const&)
alglib::complex& alglib::complex::operator/=(const alglib::complex& z)
{
    alglib::complex result;
    double e;
    double f;
    if( fabs(z.y)<fabs(z.x) )
    {
        e = z.y/z.x;
        f = z.x+z.y*e;
        result.x = (x+y*e)/f;
        result.y = (y-x*e)/f;
    }
    else
    {
        e = z.x/z.y;
        f = z.y+z.x*e;
        result.x = (y+x*e)/f;
        result.y = (-x+y*e)/f;
    }
    *this = result;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x427a0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
movaps 0x155ef(%rip), %xmm0    # 0x580b0
pand %xmm0, %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x155dc(%rip), %xmm2    # 0x580b0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x42b7b
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movq -0x10(%rbp), %rcx
divsd (%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm1
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x8(%rax), %xmm1
movsd (%rax), %xmm0
movsd -0x28(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x42c0f
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq -0x10(%rbp), %rcx
divsd 0x8(%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%rax), %xmm1
movsd (%rax), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd (%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
movsd 0x8(%rax), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x42960
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::operator==(alglib::complex const&, alglib::complex const&)
const bool alglib::operator==(const alglib::complex& lhs, const alglib::complex& rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs.x;
    volatile double y1 = lhs.y;
    volatile double y2 = rhs.y;
    return x1==x2 && y1==y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x31(%rbp)
jne 0x43642
jp 0x43642
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::operator/(alglib::complex const&, alglib::complex const&)
const alglib::complex alglib::operator/(const alglib::complex& lhs, const alglib::complex& rhs)
{
    alglib::complex result;
    double e;
    double f;
    if( fabs(rhs.y)<fabs(rhs.x) )
    {
        e = rhs.y/rhs.x;
        f = rhs.x+rhs.y*e;
        result.x = (lhs.x+lhs.y*e)/f;
        result.y = (lhs.y-lhs.x*e)/f;
    }
    else
    {
        e = rhs.x/rhs.y;
        f = rhs.y+rhs.x*e;
        result.x = (lhs.y+lhs.x*e)/f;
        result.y = (-lhs.x+lhs.y*e)/f;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x427a0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movaps 0x1465c(%rip), %xmm0    # 0x580b0
pand %xmm0, %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x14649(%rip), %xmm2    # 0x580b0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43b1d
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movq -0x18(%rbp), %rcx
divsd (%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm1
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x43bc0
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movq -0x18(%rbp), %rcx
divsd 0x8(%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::operator/(double const&, alglib::complex const&)
const alglib::complex alglib::operator/(const double& lhs, const alglib::complex& rhs)
{
    alglib::complex result;
    double e;
    double f;
    if( fabs(rhs.y)<fabs(rhs.x) )
    {
        e = rhs.y/rhs.x;
        f = rhs.x+rhs.y*e;
        result.x = lhs/f;
        result.y = -lhs*e/f;
    }
    else
    {
        e = rhs.x/rhs.y;
        f = rhs.y+rhs.x*e;
        result.x = lhs*e/f;
        result.y = -lhs/f;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x427a0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movaps 0x144ac(%rip), %xmm0    # 0x580b0
pand %xmm0, %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x14499(%rip), %xmm2    # 0x580b0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43c9f
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movq -0x18(%rbp), %rcx
divsd (%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x43d1b
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movq -0x18(%rbp), %rcx
divsd 0x8(%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
mulsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::abscomplex(alglib::complex const&)
double alglib::abscomplex(const alglib::complex &z)
{
    double w;
    double xabs;
    double yabs;
    double v;

    xabs = fabs(z.x);
    yabs = fabs(z.y);
    w = xabs>yabs ? xabs : yabs;
    v = xabs<yabs ? xabs : yabs; 
    if( v==0 )
        return w;
    else
    {
        double t = v/w;
        return w*sqrt(1+t*t);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x14305(%rip), %xmm1    # 0x580b0
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movaps 0x142ec(%rip), %xmm1    # 0x580b0
pand %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x43de5
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x43def
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43e15
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x43e1f
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x43e45
jp 0x43e45
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x43e8e
movsd -0x30(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x11194(%rip), %xmm1    # 0x55008
addsd %xmm1, %xmm0
callq 0x3200
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::vmul(double*, long, long, double)
void alglib::vmul(double *vdst,  ae_int_t stride_dst, ae_int_t n, double alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        //
        // general unoptimized case
        //
        for(i=0; i<n; i++, vdst+=stride_dst)
            *vdst *= alpha;
    }
    else
    {
        //
        // optimized case
        //
        for(i=0; i<n; i++, vdst++)
            *vdst *= alpha;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
cmpq $0x1, -0x10(%rbp)
je 0x46b8f
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x46b8d
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46b54
jmp 0x46bce
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x46bcc
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x46b97
jmp 0x46bce
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::vmul(alglib::complex*, long, long, alglib::complex)
void alglib::vmul(alglib::complex *vdst, ae_int_t stride_dst, ae_int_t n, alglib::complex alpha)
{
    ae_int_t i;
    if( stride_dst!=1 )
    {
        //
        // general unoptimized case
        //
        double ax = alpha.x, ay = alpha.y;
        for(i=0; i<n; i++, vdst+=stride_dst)
        {
            double  dstx = vdst->x, dsty = vdst->y;
            vdst->x = ax*dstx-ay*dsty;
            vdst->y = ax*dsty+ay*dstx;
        }
    }
    else
    {
        //
        // optimized case
        //
        double ax = alpha.x, ay = alpha.y;
        for(i=0; i<n; i++, vdst++)
        {
            double  dstx = vdst->x, dsty = vdst->y;
            vdst->x = ax*dstx-ay*dsty;
            vdst->y = ax*dsty+ay*dstx;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x1, -0x10(%rbp)
je 0x46e11
movq -0x70(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x46e0c
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd -0x48(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
shlq $0x4, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46d62
jmp 0x46ed8
movq -0x70(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x46ed6
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x60(%rbp), %xmm2
movsd -0x58(%rbp), %xmm1
mulsd -0x68(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
movsd -0x68(%rbp), %xmm2
movsd -0x58(%rbp), %xmm1
mulsd -0x60(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x46e30
jmp 0x46ed8
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib::ae_vector_wrapper::ae_vector_wrapper(alglib::ae_vector_wrapper const&)
alglib::ae_vector_wrapper::ae_vector_wrapper(const alglib::ae_vector_wrapper &rhs)
{
    if( rhs.p_vec!=NULL )
    {
        p_vec = &vec;
        if( !ae_vector_init_copy(p_vec, rhs.p_vec, NULL, ae_false) )
            throw alglib::ap_error("ALGLIB: malloc error!");
    }
    else
        p_vec = 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 0x1db79(%rip), %rcx     # 0x64b88
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4709d
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 0x3b4d0
testb $0x1, %al
jne 0x4709b
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x11285(%rip), %rsi     # 0x582eb
callq 0x42660
jmp 0x4706d
movq -0x30(%rbp), %rdi
leaq 0x1db00(%rip), %rsi     # 0x64b78
leaq -0x298cf(%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 0x470af
jmp 0x470a9
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_vector_wrapper::operator=(alglib::ae_vector_wrapper const&)
const alglib::ae_vector_wrapper& alglib::ae_vector_wrapper::operator=(const alglib::ae_vector_wrapper &rhs)
{
    if( this==&rhs )
        return *this;
    if( p_vec==&vec )
        ae_vector_clear(p_vec);
    if( rhs.p_vec!=NULL )
    {
        p_vec = &vec;
        if( !ae_vector_init_copy(p_vec, rhs.p_vec, NULL, ae_false) )
            throw alglib::ap_error("ALGLIB: malloc error!");
    }
    else
        p_vec = 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 0x470eb
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x471a4
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x47109
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3b6f0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x47190
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 0x3b4d0
testb $0x1, %al
jne 0x4718e
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x11192(%rip), %rsi     # 0x582eb
callq 0x42660
jmp 0x47160
movq -0x38(%rbp), %rdi
leaq 0x1da0d(%rip), %rsi     # 0x64b78
leaq -0x299c2(%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 0x471ae
jmp 0x4719c
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_vector_wrapper::setlength(long)
void alglib::ae_vector_wrapper::setlength(ae_int_t iLen)
{
    if( p_vec==NULL )
        throw alglib::ap_error("ALGLIB: setlength() error, p_vec==NULL (array was not correctly initialized)");
    if( p_vec!=&vec )
        throw alglib::ap_error("ALGLIB: setlength() error, p_vec!=&vec (attempt to resize frozen array)");
    if( !ae_vector_set_length(p_vec, iLen, NULL) )
        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 -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x47232
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x11107(%rip), %rsi     # 0x58301
callq 0x42660
jmp 0x47201
movq -0x30(%rbp), %rdi
leaq 0x1d96c(%rip), %rsi     # 0x64b78
leaq -0x29a63(%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 0x47302
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
je 0x47293
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x110f0(%rip), %rsi     # 0x5834e
callq 0x42660
jmp 0x47265
movq -0x38(%rbp), %rdi
leaq 0x1d908(%rip), %rsi     # 0x64b78
leaq -0x29ac7(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31e0
jmp 0x47302
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b620
testb $0x1, %al
jne 0x472fc
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x110cf(%rip), %rsi     # 0x58396
callq 0x42660
jmp 0x472ce
movq -0x40(%rbp), %rdi
leaq 0x1d89f(%rip), %rsi     # 0x64b78
leaq -0x29b30(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31e0
jmp 0x47302
addq $0x40, %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_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 %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 0x473c5
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1101b(%rip), %rsi     # 0x583ab
callq 0x42660
jmp 0x47397
movq -0x30(%rbp), %rdi
leaq 0x1d7d6(%rip), %rsi     # 0x64b78
leaq -0x29bf9(%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 0x473f5
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x473e3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3b6f0
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_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x47436
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3b6f0
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x474b1
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x10f1a(%rip), %rsi     # 0x58396
callq 0x42660
jmp 0x47483
movq -0x38(%rbp), %rdi
leaq 0x1d6ea(%rip), %rsi     # 0x64b78
leaq -0x29ce5(%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 0x474b7
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34c0
// File: 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 %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 0x1d630(%rip), %rcx     # 0x64bb8
movq %rcx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x530a0
movq -0x10(%rbp), %rdi
callq 0x476e0
movq %rax, -0x50(%rbp)
jmp 0x475a3
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x477e0
jmp 0x475bf
leaq -0x28(%rbp), %rdi
callq 0x530c0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x47400
jmp 0x475db
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 0x47685
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x530e0
movq (%rax), %rdi
leaq 0x10dbb(%rip), %rsi     # 0x583d6
callq 0x479c0
movb %al, -0x61(%rbp)
jmp 0x47625
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x47c70
movq %rax, -0x70(%rbp)
jmp 0x47638
movq -0x70(%rbp), %rax
movb -0x61(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x475e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x476b4
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 0x476d7
movq -0x38(%rbp), %rdi
callq 0x3ad30
jmp 0x476a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3460
jmp 0x476a3
jmp 0x476b4
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::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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3110
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3acc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x47765
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x10c6e(%rip), %rsi     # 0x5839e
callq 0x42660
jmp 0x47737
movq -0x48(%rbp), %rdi
leaq 0x1d436(%rip), %rsi     # 0x64b78
leaq -0x29f99(%rip), %rdx    # 0x1d7b0
callq 0x3490
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x31e0
jmp 0x477d6
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x477cc
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x3040
cmpl $0x0, %eax
jne 0x477b0
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x477b2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4777d
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34c0
nop
// File: 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 %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 0x47e16
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x47ddd
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x33e0
movq -0x40(%rbp), %rdi
leaq 0x1055e(%rip), %rsi     # 0x584a1
callq 0x33d0
jmp 0x47f4a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x47fc9
cmpq $0x0, -0x28(%rbp)
je 0x47f8e
movq -0x40(%rbp), %rdi
leaq 0x10535(%rip), %rsi     # 0x584a3
callq 0x32c0
jmp 0x47f75
jmp 0x47f8e
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31a0
jmp 0x47ff8
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %cl
leaq 0x1055c(%rip), %rax     # 0x58500
leaq 0x1053c(%rip), %rsi     # 0x584e7
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x32c0
jmp 0x47fb9
jmp 0x47fbb
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x47f52
movq -0x40(%rbp), %rdi
leaq 0x10403(%rip), %rsi     # 0x583d7
callq 0x32c0
jmp 0x47fdb
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x47fee
movq -0x40(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: 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 %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 0x1cad0(%rip), %rcx     # 0x64bd8
movq %rcx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x530a0
movq -0x10(%rbp), %rdi
callq 0x476e0
movq %rax, -0x50(%rbp)
jmp 0x48123
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x477e0
jmp 0x4813f
leaq -0x28(%rbp), %rdi
callq 0x530c0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x47400
jmp 0x4815b
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 0x48205
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x530e0
movq (%rax), %rdi
leaq 0x1023b(%rip), %rsi     # 0x583d6
callq 0x48260
movq %rax, -0x68(%rbp)
jmp 0x481a6
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x48460
movq %rax, -0x70(%rbp)
jmp 0x481b9
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x48163
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x48234
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 0x48257
movq -0x38(%rbp), %rdi
callq 0x3ad30
jmp 0x48225
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3460
jmp 0x48223
jmp 0x48234
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)