LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_ftplan_init(alglib_impl::ftplan*, alglib_impl::ae_state*, bool)
ae_bool _ftplan_init(ftplan* p, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init(&p->plan, 0, DT_INT, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->precomputed, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->tmpbuf, 0, DT_REAL, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init(&p->stackbuf, 0, DT_REAL, _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
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 0x38f03
movb $0x0, -0x1(%rbp)
jmp 0x38f91
movq -0x10(%rbp), %rdi
addq $0x30, %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 0x38f30
movb $0x0, -0x1(%rbp)
jmp 0x38f91
movq -0x10(%rbp), %rdi
addq $0x60, %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 0x38f5d
movb $0x0, -0x1(%rbp)
jmp 0x38f91
movq -0x10(%rbp), %rdi
addq $0x90, %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 0x38f8d
movb $0x0, -0x1(%rbp)
jmp 0x38f91
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::_ftplan_init_copy(alglib_impl::ftplan*, alglib_impl::ftplan*, alglib_impl::ae_state*, bool)
ae_bool _ftplan_init_copy(ftplan* dst, ftplan* src, ae_state *_state, ae_bool make_automatic)
{
    if( !ae_vector_init_copy(&dst->plan, &src->plan, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->precomputed, &src->precomputed, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->tmpbuf, &src->tmpbuf, _state, make_automatic) )
        return ae_false;
    if( !ae_vector_init_copy(&dst->stackbuf, &src->stackbuf, _state, make_automatic) )
        return ae_false;
    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
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x38fe1
movb $0x0, -0x1(%rbp)
jmp 0x3906c
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x3900c
movb $0x0, -0x1(%rbp)
jmp 0x3906c
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x39037
movb $0x0, -0x1(%rbp)
jmp 0x3906c
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
movq -0x18(%rbp), %rsi
addq $0x90, %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b4d0
testb $0x1, %al
jne 0x39068
movb $0x0, -0x1(%rbp)
jmp 0x3906c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::nuexpm1(double, alglib_impl::ae_state*)
double nuexpm1(double x, ae_state *_state)
{
    double r;
    double xx;
    double ep;
    double eq;
    double result;


    if( ae_fp_less(x,-0.5)||ae_fp_greater(x,0.5) )
    {
        result = ae_exp(x, _state)-1.0;
        return result;
    }
    xx = x*x;
    ep = 1.2617719307481059087798E-4;
    ep = ep*xx+3.0299440770744196129956E-2;
    ep = ep*xx+9.9999999999999999991025E-1;
    eq = 3.0019850513866445504159E-6;
    eq = eq*xx+2.5244834034968410419224E-3;
    eq = eq*xx+2.2726554820815502876593E-1;
    eq = eq*xx+2.0000000000000000000897E0;
    r = x*ep;
    r = r/(eq-r);
    result = r+r;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x1c592(%rip), %xmm1    # 0x558a0
callq 0x3c440
testb $0x1, %al
jne 0x3932f
movsd -0x10(%rbp), %xmm0
movsd 0x1c12c(%rip), %xmm1    # 0x55450
callq 0x3c4c0
testb $0x1, %al
jne 0x3932f
jmp 0x3935d
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x3cdd0
movsd 0x1bcc3(%rip), %xmm1    # 0x55008
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x39461
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x1e5c4(%rip), %xmm0    # 0x57938
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e5a1(%rip), %xmm1    # 0x57930
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1bc5a(%rip), %xmm1    # 0x55008
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x1e569(%rip), %xmm0    # 0x57928
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e546(%rip), %xmm1    # 0x57920
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e51f(%rip), %xmm1    # 0x57918
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1bfb0(%rip), %xmm1    # 0x553c8
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::nucosm1(double, alglib_impl::ae_state*)
double nucosm1(double x, ae_state *_state)
{
    double xx;
    double c;
    double result;


    if( ae_fp_less(x,-0.25*ae_pi)||ae_fp_greater(x,0.25*ae_pi) )
    {
        result = ae_cos(x, _state)-1;
        return result;
    }
    xx = x*x;
    c = 4.7377507964246204691685E-14;
    c = c*xx-1.1470284843425359765671E-11;
    c = c*xx+2.0876754287081521758361E-9;
    c = c*xx-2.7557319214999787979814E-7;
    c = c*xx+2.4801587301570552304991E-5;
    c = c*xx-1.3888888888888872993737E-3;
    c = c*xx+4.1666666666666666609054E-2;
    result = -0.5*xx+xx*xx*c;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x1e4b2(%rip), %xmm1    # 0x57940
callq 0x3c440
testb $0x1, %al
jne 0x394af
movsd -0x10(%rbp), %xmm0
movsd 0x1c654(%rip), %xmm1    # 0x55af8
callq 0x3c4c0
testb $0x1, %al
jne 0x394af
jmp 0x394dd
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x3cbc0
movsd 0x1bb43(%rip), %xmm1    # 0x55008
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x395e6
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x1e484(%rip), %xmm0    # 0x57978
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e461(%rip), %xmm1    # 0x57970
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e43a(%rip), %xmm1    # 0x57968
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e413(%rip), %xmm1    # 0x57960
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e3ec(%rip), %xmm1    # 0x57958
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e3c5(%rip), %xmm1    # 0x57950
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1e39e(%rip), %xmm1    # 0x57948
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
movsd 0x1c2d1(%rip), %xmm2    # 0x558a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::hsschur_extschursign(double, double, alglib_impl::ae_state*)
static double hsschur_extschursign(double a, double b, ae_state *_state)
{
    double result;


    if( ae_fp_greater_eq(b,0) )
    {
        result = ae_fabs(a, _state);
    }
    else
    {
        result = -ae_fabs(a, _state);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x39629
jmp 0x3963e
movsd -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x3c820
movsd %xmm0, -0x20(%rbp)
jmp 0x39668
movsd -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x3c820
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::hsschur_extschursigntoone(double, alglib_impl::ae_state*)
static ae_int_t hsschur_extschursigntoone(double b, ae_state *_state)
{
    ae_int_t result;


    if( ae_fp_greater_eq(b,0) )
    {
        result = 1;
    }
    else
    {
        result = -1;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x3a184
jmp 0x3a18e
movq $0x1, -0x18(%rbp)
jmp 0x3a196
movq $-0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::xblas_xfastpow(double, long, alglib_impl::ae_state*)
static double xblas_xfastpow(double r, ae_int_t n, ae_state *_state)
{
    double result;


    result = 0;
    if( n>0 )
    {
        if( n%2==0 )
        {
            result = ae_sqr(xblas_xfastpow(r, n/2, _state), _state);
        }
        else
        {
            result = r*xblas_xfastpow(r, n-1, _state);
        }
        return result;
    }
    if( n==0 )
    {
        result = 1;
    }
    if( n<0 )
    {
        result = xblas_xfastpow(1/r, -n, _state);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x3a248
movq -0x18(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x3a20b
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3a1a0
movq -0x20(%rbp), %rdi
callq 0x3c870
movsd %xmm0, -0x28(%rbp)
jmp 0x3a23c
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rdi
subq $0x1, %rdi
movq -0x20(%rbp), %rsi
callq 0x3a1a0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3a290
cmpq $0x0, -0x18(%rbp)
jne 0x3a25c
movsd 0x1adb1(%rip), %xmm0    # 0x55008
movsd %xmm0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x3a286
movsd 0x1ad9d(%rip), %xmm0    # 0x55008
divsd -0x10(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %edi
subq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a1a0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::ftbase_fftarrayresize(alglib_impl::ae_vector*, long*, long, alglib_impl::ae_state*)
static void ftbase_fftarrayresize(/* Integer */ ae_vector* a,
     ae_int_t* asize,
     ae_int_t newasize,
     ae_state *_state)
{
    ae_frame _frame_block;
    ae_vector tmp;
    ae_int_t i;

    ae_frame_make(_state, &_frame_block);
    ae_vector_init(&tmp, 0, DT_INT, _state, ae_true);

    ae_vector_set_length(&tmp, *asize, _state);
    for(i=0; i<=*asize-1; i++)
    {
        tmp.ptr.p_int[i] = a->ptr.p_int[i];
    }
    ae_vector_set_length(a, newasize, _state);
    for(i=0; i<=*asize-1; i++)
    {
        a->ptr.p_int[i] = tmp.ptr.p_int[i];
    }
    *asize = newasize;
    ae_frame_leave(_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3b0f0
movq -0x20(%rbp), %rcx
leaq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
movl $0x1, %r8d
callq 0x3b400
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x3b620
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x3a33b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x40(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x3a2fd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3b620
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0x3a392
movq -0x40(%rbp), %rax
movq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x70(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x3a354
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x3b030
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_align(void*, unsigned long)
void* ae_align(void *ptr, size_t alignment)
{
    char *result = (char*)ptr;
    if( (result-(char*)0)%alignment!=0 )
        result += alignment - (result-(char*)0)%alignment;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq $0x0, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
cmpq $0x0, %rdx
je 0x3ab01
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq $0x0, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq -0x20(%rbp), %rax
subq %rdx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_break(alglib_impl::ae_state*, alglib_impl::ae_error_type, char const*)
void ae_break(ae_state *state, ae_error_type error_type, const char *msg)
{
#ifndef AE_USE_CPP_ERROR_HANDLING
    if( state!=NULL )
    {
        ae_state_clear(state);
        state->last_error = error_type;
        state->error_msg = msg;
        if( state->break_jump!=NULL )
            longjmp(*(state->break_jump), 1);
        else
            abort();
    }
    else
        abort();
#else
    if( state!=NULL )
    {
        ae_state_clear(state);
        state->last_error = error_type;
        state->error_msg = msg;
    }
    throw error_type;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ab49
movq -0x8(%rbp), %rdi
callq 0x3ab70
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x4, %edi
callq 0x3130
movq %rax, %rdi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
leaq 0x2a006(%rip), %rsi     # 0x64b68
xorl %eax, %eax
movl %eax, %edx
callq 0x3490
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::aligned_malloc(unsigned long, unsigned long)
void* aligned_malloc(size_t size, size_t alignment)
{
    if( size==0 )
        return NULL;
    if( alignment<=1 )
    {
        /* no alignment, just call malloc */
        void *block;
        void **p; ;
        block = malloc(sizeof(void*)+size);
        if( block==NULL )
            return NULL;
        p = (void**)block;
        *p = block;
#ifdef AE_USE_ALLOC_COUNTER
        _alloc_counter++;
#endif
        return (void*)((char*)block+sizeof(void*));
    }
    else
    {
        /* align */
        void *block;
        char *result;
        block = malloc(alignment-1+sizeof(void*)+size);
        if( block==NULL )
            return NULL;
        result = (char*)block+sizeof(void*);
        /*if( (result-(char*)0)%alignment!=0 )
            result += alignment - (result-(char*)0)%alignment;*/
        result = (char*)ae_align(result, alignment);
        *((void**)(result-sizeof(void*))) = block;
#ifdef AE_USE_ALLOC_COUNTER
        _alloc_counter++;
#endif
        return result;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3abd4
movq $0x0, -0x8(%rbp)
jmp 0x3ac79
cmpq $0x1, -0x18(%rbp)
ja 0x3ac1e
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x33c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3abfd
movq $0x0, -0x8(%rbp)
jmp 0x3ac79
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x3ac79
movq -0x18(%rbp), %rdi
subq $0x1, %rdi
addq $0x8, %rdi
addq -0x10(%rbp), %rdi
callq 0x33c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3ac48
movq $0x0, -0x8(%rbp)
jmp 0x3ac79
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3aab0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::aligned_free(void*)
void aligned_free(void *block)
{
    void *p;
    if( block==NULL )
        return;
    p = *((void**)((char*)block-sizeof(void*)));
    free(p);
#ifdef AE_USE_ALLOC_COUNTER
    _alloc_counter--;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3aca5
jmp 0x3acba
movq -0x8(%rbp), %rax
movq -0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3360
addq $0x10, %rsp
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_malloc(unsigned long, alglib_impl::ae_state*)
void* ae_malloc(size_t size, ae_state *state)
{
    void *result;
    if( size==0 )
        return NULL;
    result = aligned_malloc(size,AE_DATA_ALIGN);
    if( result==NULL && state!=NULL)
        ae_break(state, ERR_OUT_OF_MEMORY, "ae_malloc(): out of memory");
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3ace1
movq $0x0, -0x8(%rbp)
jmp 0x3ad1e
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x3abb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3ad16
cmpq $0x0, -0x18(%rbp)
je 0x3ad16
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x1d3bf(%rip), %rdx     # 0x580d0
callq 0x3ab10
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_update_row_pointers(alglib_impl::ae_matrix*, void*)
void ae_matrix_update_row_pointers(ae_matrix *dst, void *storage)
{
    char *p_base;
    void **pp_ptr;
    ae_int_t i;
    if( dst->rows>0 && dst->cols>0 )
    {
        p_base = (char*)storage;
        pp_ptr = (void**)dst->data.ptr;
        dst->ptr.pp_void = pp_ptr;
        for(i=0; i<dst->rows; i++, p_base+=dst->stride*ae_sizeof(dst->datatype))
            pp_ptr[i] = p_base;
    }
    else
        dst->ptr.pp_void = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jle 0x3ae0e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x3ae0e
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x3ae0c
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ae20
movq %rax, %rcx
movq -0x30(%rbp), %rax
imulq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3adb5
jmp 0x3ae1a
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_sizeof(long)
ae_int_t ae_sizeof(ae_datatype datatype)
{
    switch(datatype)
    {
        case DT_BOOL:       return (ae_int_t)sizeof(ae_bool);
        case DT_INT:        return (ae_int_t)sizeof(ae_int_t);
        case DT_REAL:       return (ae_int_t)sizeof(double);
        case DT_COMPLEX:    return 2*(ae_int_t)sizeof(double);
        default:            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
decq %rax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x3ae75
movq -0x18(%rbp), %rax
leaq 0x1d11c(%rip), %rcx     # 0x57f60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, -0x8(%rbp)
jmp 0x3ae7d
movq $0x8, -0x8(%rbp)
jmp 0x3ae7d
movq $0x8, -0x8(%rbp)
jmp 0x3ae7d
movq $0x10, -0x8(%rbp)
jmp 0x3ae7d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_frame_leave(alglib_impl::ae_state*)
void ae_frame_leave(ae_state *state)
{
    while( state->p_top_block->ptr!=DYN_FRAME && state->p_top_block->ptr!=DYN_BOTTOM)
    {
        if( state->p_top_block->ptr!=NULL && state->p_top_block->deallocator!=NULL)
            ((ae_deallocator)(state->p_top_block->deallocator))(state->p_top_block->ptr);
        state->p_top_block = state->p_top_block->p_next;
    }
    state->p_top_block = state->p_top_block->p_next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
movl $0x2, %edx
cmpq %rdx, %rcx
movb %al, -0x9(%rbp)
je 0x3b071
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movl $0x1, %ecx
cmpq %rcx, %rax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x3b07a
jmp 0x3b0cd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq $0x0, %rax
je 0x3b0b5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x3b0b5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x3b03c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_frame_make(alglib_impl::ae_state*, alglib_impl::ae_frame*)
void ae_frame_make(ae_state *state, ae_frame *tmp)
{
    tmp->db_marker.p_next = state->p_top_block;
    tmp->db_marker.deallocator = NULL;
    tmp->db_marker.ptr = DYN_FRAME;
    state->p_top_block = &tmp->db_marker;
}

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

// Assembly:
pushq %rbp
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)
cmpq $0x0, -0x20(%rbp)
je 0x3b1b0
cmpq $0x0, -0x18(%rbp)
setge %al
movq -0x20(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x1cf40(%rip), %rsi     # 0x580eb
callq 0x3b240
cmpq $0x0, -0x18(%rbp)
jge 0x3b1bd
movb $0x0, -0x1(%rbp)
jmp 0x3b22a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3acc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, %rax
jne 0x3b1f0
cmpq $0x0, -0x18(%rbp)
je 0x3b1f0
movb $0x0, -0x1(%rbp)
jmp 0x3b22a
testb $0x1, -0x21(%rbp)
je 0x3b20c
cmpq $0x0, -0x20(%rbp)
je 0x3b20c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3b140
jmp 0x3b217
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
leaq -0x4f2(%rip), %rcx      # 0x3ad30
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_realloc(alglib_impl::ae_dyn_block*, long, alglib_impl::ae_state*)
ae_bool ae_db_realloc(ae_dyn_block *block, ae_int_t size, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(size>=0, "ae_db_realloc(): negative size", state);
    if( size<0 )
        return ae_false;
    
    /* realloc */
    if( block->ptr!=NULL )
        ((ae_deallocator)block->deallocator)(block->ptr);
    block->ptr = ae_malloc((size_t)size, state);
    if( block->ptr==NULL && size!=0 )
        return ae_false;
    block->deallocator = ae_free;
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3b2b9
cmpq $0x0, -0x18(%rbp)
setge %al
movq -0x20(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x1ce55(%rip), %rsi     # 0x58109
callq 0x3b240
cmpq $0x0, -0x18(%rbp)
jge 0x3b2c6
movb $0x0, -0x1(%rbp)
jmp 0x3b32c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, %rax
je 0x3b2e6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3acc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, %rax
jne 0x3b319
cmpq $0x0, -0x18(%rbp)
je 0x3b319
movb $0x0, -0x1(%rbp)
jmp 0x3b32c
movq -0x10(%rbp), %rax
leaq -0x5f4(%rip), %rcx      # 0x3ad30
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_free(alglib_impl::ae_dyn_block*)
void ae_db_free(ae_dyn_block *block)
{
    if( block->ptr!=NULL )
        ((ae_deallocator)block->deallocator)(block->ptr);
    block->ptr = NULL;
    block->deallocator = ae_free;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, %rax
je 0x3b36c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq -0x653(%rip), %rcx      # 0x3ad30
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_db_swap(alglib_impl::ae_dyn_block*, alglib_impl::ae_dyn_block*)
void ae_db_swap(ae_dyn_block *block1, ae_dyn_block *block2)
{
    void (*deallocator)(void*) = NULL;
    void * volatile ptr;
    ptr = block1->ptr;
    deallocator = block1->deallocator;
    block1->ptr = block2->ptr;
    block1->deallocator = block2->deallocator;
    block2->ptr = ptr;
    block2->deallocator = deallocator;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3b445
cmpq $0x0, -0x18(%rbp)
setge %al
movq -0x28(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x1cce8(%rip), %rsi     # 0x58128
callq 0x3b240
cmpq $0x0, -0x18(%rbp)
jge 0x3b452
movb $0x0, -0x1(%rbp)
jmp 0x3b4c1
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3ae20
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
imulq %rax, %rsi
movq -0x28(%rbp), %rdx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3b170
testb $0x1, %al
jne 0x3b4ad
movb $0x0, -0x1(%rbp)
jmp 0x3b4c1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_init_copy(alglib_impl::ae_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*, bool)
ae_bool ae_vector_init_copy(ae_vector *dst, ae_vector *src, ae_state *state, ae_bool make_automatic)
{
    if( !ae_vector_init(dst, src->cnt, src->datatype, state, make_automatic) )
        return ae_false;
    if( src->cnt!=0 )
        memcpy(dst->ptr.p_ptr, src->ptr.p_ptr, (size_t)(src->cnt*ae_sizeof(src->datatype)));
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x3b400
testb $0x1, %al
jne 0x3b51a
movb $0x0, -0x1(%rbp)
jmp 0x3b56d
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3b569
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3ae20
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
imulq %rax, %rdx
callq 0x3230
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_vector_set_length(alglib_impl::ae_vector*, long, alglib_impl::ae_state*)
ae_bool ae_vector_set_length(ae_vector *dst, ae_int_t newsize, ae_state *state)
{
    /* ensure that size is >=0
       two ways to exit: 1) through ae_assert, if we have non-NULL state, 2) by returning ae_false */
    if( state!=NULL )
        ae_assert(newsize>=0, "ae_vector_set_length(): negative size", state);
    if( newsize<0 )
        return ae_false;

    /* set length */
    if( dst->cnt==newsize )
        return ae_true;
    dst->cnt = newsize;
    if( !ae_db_realloc(&dst->data, newsize*ae_sizeof(dst->datatype), state) )
        return ae_false;
    dst->ptr.p_ptr = dst->data.ptr;
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3b659
cmpq $0x0, -0x18(%rbp)
setge %al
movq -0x20(%rbp), %rdx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x1caf4(%rip), %rsi     # 0x58148
callq 0x3b240
cmpq $0x0, -0x18(%rbp)
jge 0x3b666
movb $0x0, -0x1(%rbp)
jmp 0x3b6d8
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3b679
movb $0x1, -0x1(%rbp)
jmp 0x3b6d8
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3ae20
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
imulq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x3b280
testb $0x1, %al
jne 0x3b6c4
movb $0x0, -0x1(%rbp)
jmp 0x3b6d8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_swap_vectors(alglib_impl::ae_vector*, alglib_impl::ae_vector*)
void ae_swap_vectors(ae_vector *vec1, ae_vector *vec2)
{
    ae_int_t cnt;
    ae_datatype datatype;
    void *p_ptr;
    
    ae_db_swap(&vec1->data, &vec2->data);
    
    cnt = vec1->cnt;
    datatype = vec1->datatype;
    p_ptr = vec1->ptr.p_ptr;
    vec1->cnt = vec2->cnt;
    vec1->datatype = vec2->datatype;
    vec1->ptr.p_ptr = vec2->ptr.p_ptr;
    vec2->cnt = cnt;
    vec2->datatype = datatype;
    vec2->ptr.p_ptr = p_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3b390
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init_copy(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*, alglib_impl::ae_state*, bool)
ae_bool ae_matrix_init_copy(ae_matrix *dst, ae_matrix *src, ae_state *state, ae_bool make_automatic)
{
    ae_int_t i;
    if( !ae_matrix_init(dst, src->rows, src->cols, src->datatype, state, make_automatic) )
        return ae_false;
    if( src->rows!=0 && src->cols!=0 )
    {
        if( dst->stride==src->stride )
            memcpy(dst->ptr.pp_void[0], src->ptr.pp_void[0], (size_t)(src->rows*src->stride*ae_sizeof(src->datatype)));
        else
            for(i=0; i<dst->rows; i++)
                memcpy(dst->ptr.pp_void[i], src->ptr.pp_void[i], (size_t)(dst->cols*ae_sizeof(dst->datatype)));
    }
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %r8
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x3b7d0
testb $0x1, %al
jne 0x3b9d5
movb $0x0, -0x1(%rbp)
jmp 0x3badb
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3bad7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3bad7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x3ba5a
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
imulq 0x10(%rcx), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ae20
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
imulq %rax, %rdx
callq 0x3230
jmp 0x3bad5
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x3bad3
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ae20
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
imulq %rax, %rdx
callq 0x3230
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3ba62
jmp 0x3bad5
jmp 0x3bad7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_init_from_x(alglib_impl::ae_matrix*, alglib_impl::x_matrix*, alglib_impl::ae_state*, bool)
void ae_matrix_init_from_x(ae_matrix *dst, x_matrix *src, ae_state *state, ae_bool make_automatic)
{
    char *p_src_row;
    char *p_dst_row;
    ae_int_t row_size;
    ae_int_t i;
    ae_matrix_init(dst, (ae_int_t)src->rows, (ae_int_t)src->cols, (ae_datatype)src->datatype, state, make_automatic);
    if( src->rows!=0 && src->cols!=0 )
    {
        p_src_row = (char*)src->ptr;
        p_dst_row = (char*)(dst->ptr.pp_void[0]);
        row_size = ae_sizeof((ae_datatype)src->datatype)*(ae_int_t)src->cols;
        for(i=0; i<src->rows; i++, p_src_row+=src->stride*ae_sizeof((ae_datatype)src->datatype), p_dst_row+=dst->stride*ae_sizeof((ae_datatype)src->datatype))
            memcpy(p_dst_row, p_src_row, (size_t)(row_size));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %r8
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x3b7d0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3bc1b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3bc1b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ae20
movq -0x10(%rbp), %rcx
imulq 0x8(%rcx), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x3bc19
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3230
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ae20
movq %rax, %rcx
movq -0x50(%rbp), %rax
imulq %rcx, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ae20
movq %rax, %rcx
movq -0x48(%rbp), %rax
imulq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x3bb92
jmp 0x3bc1b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_matrix_clear(alglib_impl::ae_matrix*)
void ae_matrix_clear(ae_matrix *dst)
{
    dst->rows = 0;
    dst->cols = 0;
    dst->stride = 0;
    ae_db_free(&dst->data);
    dst->ptr.p_ptr = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b340
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_swap_matrices(alglib_impl::ae_matrix*, alglib_impl::ae_matrix*)
void ae_swap_matrices(ae_matrix *mat1, ae_matrix *mat2)
{
    ae_int_t rows;
    ae_int_t cols;
    ae_int_t stride;
    ae_datatype datatype;
    void *p_ptr;
    
    ae_db_swap(&mat1->data, &mat2->data);
    
    rows = mat1->rows;
    cols = mat1->cols;
    stride = mat1->stride;
    datatype = mat1->datatype;
    p_ptr = mat1->ptr.p_ptr;

    mat1->rows = mat2->rows;
    mat1->cols = mat2->cols;
    mat1->stride = mat2->stride;
    mat1->datatype = mat2->datatype;
    mat1->ptr.p_ptr = mat2->ptr.p_ptr;

    mat2->rows = rows;
    mat2->cols = cols;
    mat2->stride = stride;
    mat2->datatype = datatype;
    mat2->ptr.p_ptr = p_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x3b390
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_set_vector(alglib_impl::x_vector*, alglib_impl::ae_vector*, alglib_impl::ae_state*)
void ae_x_set_vector(x_vector *dst, ae_vector *src, ae_state *state)
{
    if( dst->cnt!=src->cnt || dst->datatype!=src->datatype )
    {
        if( dst->owner==OWN_AE )
            ae_free(dst->ptr);
        dst->ptr = ae_malloc((size_t)(src->cnt*ae_sizeof(src->datatype)), state);
        dst->last_action = ACT_NEW_LOCATION;
        dst->cnt = src->cnt;
        dst->datatype = src->datatype;
        dst->owner = OWN_AE;
    }
    else
        dst->last_action = ACT_SAME_LOCATION;
    if( src->cnt )
        memcpy(dst->ptr, src->ptr.p_ptr, (size_t)(src->cnt*ae_sizeof(src->datatype)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x3bf4a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x3bfce
movq -0x8(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jne 0x3bf62
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3ad30
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3ae20
movq -0x20(%rbp), %rdi
imulq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3acc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x3, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x2, 0x10(%rax)
jmp 0x3bfda
movq -0x8(%rbp), %rax
movq $0x2, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3c029
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3ae20
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
imulq %rax, %rdx
callq 0x3230
addq $0x40, %rsp
popq %rbp
retq
nop