LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_attach_to_vector(alglib_impl::x_vector*, alglib_impl::ae_vector*)
void ae_x_attach_to_vector(x_vector *dst, ae_vector *src)
{
    if( dst->owner==OWN_AE )
        ae_free(dst->ptr);
    dst->ptr = src->ptr.p_ptr;
    dst->last_action = ACT_NEW_LOCATION;
    dst->cnt = src->cnt;
    dst->datatype = src->datatype;
    dst->owner = OWN_CALLER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jne 0x3c248
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3ad30
movq -0x10(%rbp), %rax
movq 0x28(%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 $0x1, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_x_attach_to_matrix(alglib_impl::x_matrix*, alglib_impl::ae_matrix*)
void ae_x_attach_to_matrix(x_matrix *dst, ae_matrix *src)
{
    if( dst->owner==OWN_AE )
            ae_free(dst->ptr);
    dst->rows = src->rows;
    dst->cols = src->cols;
    dst->stride = src->stride;
    dst->datatype = src->datatype;
    dst->ptr = &(src->ptr.pp_double[0][0]);
    dst->last_action = ACT_NEW_LOCATION;
    dst->owner = OWN_CALLER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x2, 0x20(%rax)
jne 0x3c2c8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3ad30
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), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x3, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_vector_clear(alglib_impl::x_vector*)
void x_vector_clear(x_vector *dst)
{
    if( dst->owner==OWN_AE )
        aligned_free(dst->ptr);
    dst->ptr = NULL;
    dst->cnt = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jne 0x3c364
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3ac90
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_isfinite_stateless(double, long)
ae_bool ae_isfinite_stateless(double x, ae_int_t endianness)
{
    union _u
    {
        double a;
        ae_int32_t p[2];
    } u;
    ae_int32_t high;
    u.a = x;
    if( endianness==AE_LITTLE_ENDIAN )
        high = u.p[1];
    else
        high = u.p[0];
    return (high & (ae_int32_t)0x7FF00000)!=(ae_int32_t)0x7FF00000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x3c566
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c56c
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x7ff00000, %eax       # imm = 0x7FF00000
cmpl $0x7ff00000, %eax       # imm = 0x7FF00000
setne %al
andb $0x1, %al
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_isnan_stateless(double, long)
ae_bool ae_isnan_stateless(double x,    ae_int_t endianness)
{
    union _u
    {
        double a;
        ae_int32_t p[2];
    } u;
    ae_int32_t high, low;
    u.a = x;
    if( endianness==AE_LITTLE_ENDIAN )
    {
        high = u.p[1];
        low =  u.p[0];
    }
    else
    {
        high = u.p[0];
        low =  u.p[1];
    }
    return ((high &0x7FF00000)==0x7FF00000) && (((high &0x000FFFFF)!=0) || (low!=0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x3c5ac
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3c5b8
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
andl $0x7ff00000, %ecx       # imm = 0x7FF00000
xorl %eax, %eax
cmpl $0x7ff00000, %ecx       # imm = 0x7FF00000
movb %al, -0x21(%rbp)
jne 0x3c5f1
movl -0x1c(%rbp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
jne 0x3c5eb
cmpl $0x0, -0x20(%rbp)
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_isinf_stateless(double, long)
ae_bool ae_isinf_stateless(double x,    ae_int_t endianness)
{
    union _u
    {
        double a;
        ae_int32_t p[2];
    } u;
    ae_int32_t high, low;
    u.a = x;
    if( endianness==AE_LITTLE_ENDIAN )
    {
        high = u.p[1];
        low  = u.p[0];
    }
    else
    {
        high = u.p[0];
        low  = u.p[1];
    }
    
    /* 31 least significant bits of high are compared */
    return ((high&0x7FFFFFFF)==0x7FF00000) && (low==0); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x3c62c
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3c638
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpl $0x7ff00000, %ecx       # imm = 0x7FF00000
movb %al, -0x21(%rbp)
jne 0x3c658
cmpl $0x0, -0x20(%rbp)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_isposinf_stateless(double, long)
ae_bool ae_isposinf_stateless(double x, ae_int_t endianness)
{
    union _u
    {
        double a;
        ae_int32_t p[2];
    } u;
    ae_int32_t high, low;
    u.a = x;
    if( endianness==AE_LITTLE_ENDIAN )
    {
        high = u.p[1];
        low  = u.p[0];
    }
    else
    {
        high = u.p[0];
        low  = u.p[1];
    }
    
    /* all 32 bits of high are compared */
    return (high==(ae_int32_t)0x7FF00000) && (low==0); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x3c68c
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3c698
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x7ff00000, -0x1c(%rbp) # imm = 0x7FF00000
movb %al, -0x21(%rbp)
jne 0x3c6b0
cmpl $0x0, -0x20(%rbp)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_isneginf_stateless(double, long)
ae_bool ae_isneginf_stateless(double x, ae_int_t endianness)
{
    union _u
    {
        double a;
        ae_int32_t p[2];
    } u;
    ae_int32_t high, low;
    u.a = x;
    if( endianness==AE_LITTLE_ENDIAN )
    {
        high = u.p[1];
        low  = u.p[0];
    }
    else
    {
        high = u.p[0];
        low  = u.p[1];
    }
    
    /* this code is a bit tricky to avoid comparison of high with 0xFFF00000, which may be unsafe with some buggy compilers */
    return ((high&0x7FFFFFFF)==0x7FF00000) && (high!=(ae_int32_t)0x7FF00000) && (low==0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x3c6ec
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3c6f8
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpl $0x7ff00000, %ecx       # imm = 0x7FF00000
movb %al, -0x21(%rbp)
jne 0x3c726
xorl %eax, %eax
cmpl $0x7ff00000, -0x1c(%rbp) # imm = 0x7FF00000
movb %al, -0x21(%rbp)
je 0x3c726
cmpl $0x0, -0x20(%rbp)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_randomreal(alglib_impl::ae_state*)
double ae_randomreal(ae_state *state)
{
    int i1 = rand();
    int i2 = rand();
    double mx;
    while(i1==RAND_MAX)
        i1 =rand();
    while(i2==RAND_MAX)
        i2 =rand();
    mx = RAND_MAX;
    return (i1+i2/mx)/mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x30b0
movl %eax, -0xc(%rbp)
callq 0x30b0
movl %eax, -0x10(%rbp)
cmpl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
jne 0x3cb1f
callq 0x30b0
movl %eax, -0xc(%rbp)
jmp 0x3cb0c
jmp 0x3cb21
cmpl $0x7fffffff, -0x10(%rbp) # imm = 0x7FFFFFFF
jne 0x3cb34
callq 0x30b0
movl %eax, -0x10(%rbp)
jmp 0x3cb21
movsd 0x18684(%rip), %xmm0    # 0x551c0
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd -0x18(%rbp), %xmm1
addsd %xmm1, %xmm0
divsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_is_symmetric(alglib_impl::x_matrix*)
ae_bool x_is_symmetric(x_matrix *a)
{
    double mx, err;
    ae_bool nonfinite;
    ae_state _alglib_env_state;
    if( a->datatype!=DT_REAL )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    ae_state_init(&_alglib_env_state);
    mx = 0;
    err = 0;
    nonfinite = ae_false;
    is_symmetric_rec_diag_stat(a, 0, (ae_int_t)a->rows, &nonfinite, &mx, &err, &_alglib_env_state);
    if( nonfinite )
        return ae_false;
    if( mx==0 )
        return ae_true;
    return err/mx<=1.0E-14;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x3, 0x18(%rax)
je 0x3ce23
movb $0x0, -0x1(%rbp)
jmp 0x3cee0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x3ce3d
movb $0x0, -0x1(%rbp)
jmp 0x3cee0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3ce52
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3ce5b
movb $0x1, -0x1(%rbp)
jmp 0x3cee0
leaq -0x78(%rbp), %rdi
callq 0x3ae90
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x21(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x20(%rbp), %r9
leaq -0x78(%rbp), %rax
movq %rax, (%rsp)
callq 0x3cef0
testb $0x1, -0x21(%rbp)
je 0x3ceac
movb $0x0, -0x1(%rbp)
jmp 0x3cee0
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3cec2
jp 0x3cec2
movb $0x1, -0x1(%rbp)
jmp 0x3cee0
movsd -0x20(%rbp), %xmm1
divsd -0x18(%rbp), %xmm1
movsd 0x1b1d4(%rip), %xmm0    # 0x580a8
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_is_hermitian(alglib_impl::x_matrix*)
ae_bool x_is_hermitian(x_matrix *a)
{
    double mx, err;
    ae_bool nonfinite;
    ae_state _alglib_env_state;
    if( a->datatype!=DT_COMPLEX )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    ae_state_init(&_alglib_env_state);
    mx = 0;
    err = 0;
    nonfinite = ae_false;
    is_hermitian_rec_diag_stat(a, 0, (ae_int_t)a->rows, &nonfinite, &mx, &err, &_alglib_env_state);
    if( nonfinite )
        return ae_false;
    if( mx==0 )
        return ae_true;
    return err/mx<=1.0E-14;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x4, 0x18(%rax)
je 0x3d263
movb $0x0, -0x1(%rbp)
jmp 0x3d320
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x3d27d
movb $0x0, -0x1(%rbp)
jmp 0x3d320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d292
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3d29b
movb $0x1, -0x1(%rbp)
jmp 0x3d320
leaq -0x78(%rbp), %rdi
callq 0x3ae90
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x21(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x20(%rbp), %r9
leaq -0x78(%rbp), %rax
movq %rax, (%rsp)
callq 0x3d330
testb $0x1, -0x21(%rbp)
je 0x3d2ec
movb $0x0, -0x1(%rbp)
jmp 0x3d320
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3d302
jp 0x3d302
movb $0x1, -0x1(%rbp)
jmp 0x3d320
movsd -0x20(%rbp), %xmm1
divsd -0x18(%rbp), %xmm1
movsd 0x1ad94(%rip), %xmm0    # 0x580a8
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_force_symmetric(alglib_impl::x_matrix*)
ae_bool x_force_symmetric(x_matrix *a)
{
    if( a->datatype!=DT_REAL )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    force_symmetric_rec_diag_stat(a, 0, (ae_int_t)a->rows);
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x3, 0x18(%rax)
je 0x3d7bd
movb $0x0, -0x1(%rbp)
jmp 0x3d807
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x3d7d4
movb $0x0, -0x1(%rbp)
jmp 0x3d807
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d7e9
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3d7ef
movb $0x1, -0x1(%rbp)
jmp 0x3d807
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3d820
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::force_symmetric_rec_diag_stat(alglib_impl::x_matrix*, long, long)
static void force_symmetric_rec_diag_stat(x_matrix *a, ae_int_t offset, ae_int_t len)
{
    double *p, *prow, *pcol;
    ae_int_t i, j;
    
    /* try to split problem into two smaller ones */
    if( len>x_nb )
    {
        ae_int_t n1, n2;
        x_split_length(len, x_nb, &n1, &n2);
        force_symmetric_rec_diag_stat(a, offset, n1);
        force_symmetric_rec_diag_stat(a, offset+n1, n2);
        force_symmetric_rec_off_stat(a, offset+n1, offset, n2, n1);
        return;
    }
    
    /* base case */
    p = (double*)(a->ptr)+offset*a->stride+offset;
    for(i=0; i<len; i++)
    {
        pcol = p+i;
        prow = p+i*a->stride;
        for(j=0; j<i; j++,pcol+=a->stride,prow++)
            *pcol = *prow;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jle 0x3d899
movq -0x18(%rbp), %rdi
movl $0x10, %esi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x52220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x3d820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x3d820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0x52bd0
jmp 0x3d96c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x10(%rdx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x3d96c
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x10(%rdx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x3d959
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x3, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x3d911
jmp 0x3d95b
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3d8cc
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_force_hermitian(alglib_impl::x_matrix*)
ae_bool x_force_hermitian(x_matrix *a)
{
    if( a->datatype!=DT_COMPLEX )
        return ae_false;
    if( a->cols!=a->rows )
        return ae_false;
    if( a->cols==0 || a->rows==0 )
        return ae_true;
    force_hermitian_rec_diag_stat(a, 0, (ae_int_t)a->rows);
    return ae_true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x4, 0x18(%rax)
je 0x3d99d
movb $0x0, -0x1(%rbp)
jmp 0x3d9e7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x3d9b4
movb $0x0, -0x1(%rbp)
jmp 0x3d9e7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d9c9
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3d9cf
movb $0x1, -0x1(%rbp)
jmp 0x3d9e7
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3da00
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::force_hermitian_rec_diag_stat(alglib_impl::x_matrix*, long, long)
static void force_hermitian_rec_diag_stat(x_matrix *a, ae_int_t offset, ae_int_t len)
{
    ae_complex *p, *prow, *pcol;
    ae_int_t i, j;
    
    /* try to split problem into two smaller ones */
    if( len>x_nb )
    {
        ae_int_t n1, n2;
        x_split_length(len, x_nb, &n1, &n2);
        force_hermitian_rec_diag_stat(a, offset, n1);
        force_hermitian_rec_diag_stat(a, offset+n1, n2);
        force_hermitian_rec_off_stat(a, offset+n1, offset, n2, n1);
        return;
    }
    
    /* base case */
    p = (ae_complex*)(a->ptr)+offset*a->stride+offset;
    for(i=0; i<len; i++)
    {
        pcol = p+i;
        prow = p+i*a->stride;
        for(j=0; j<i; j++,pcol+=a->stride,prow++)
            *pcol = *prow;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jle 0x3da79
movq -0x18(%rbp), %rdi
movl $0x10, %esi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x52220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x3da00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x3da00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0x52db0
jmp 0x3db52
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x10(%rdx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x3db52
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x10(%rdx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x3db3f
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x4, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x3daf1
jmp 0x3db41
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3daac
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_threebytes2foursixbits(unsigned char const*, long*)
void ae_threebytes2foursixbits(const unsigned char *src, ae_int_t *dst)
{
    dst[0] = src[0] & 0x3F;
    dst[1] = (src[0]>>6) | ((src[1]&0x0F)<<2);
    dst[2] = (src[1]>>4) | ((src[2]&0x03)<<4);
    dst[3] = src[2]>>2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x3f, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
sarl $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0xf, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
sarl $0x4, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0x3, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
sarl $0x2, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_bool2str(bool, char*, alglib_impl::ae_state*)
void ae_bool2str(ae_bool v, char *buf, ae_state *state)
{
    char c = v ? '1' : '0';
    ae_int_t i;
    for(i=0; i<AE_SER_ENTRY_LENGTH; i++)
        buf[i] = c;
    buf[AE_SER_ENTRY_LENGTH] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb -0x1(%rbp), %cl
movb $0x31, %al
movb $0x30, %dl
movb %dl, -0x2a(%rbp)
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x3de2c
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0xb, -0x28(%rbp)
jge 0x3de5d
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3de3a
movq -0x10(%rbp), %rax
movb $0x0, 0xb(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_get_alloc_size(alglib_impl::ae_serializer*)
ae_int_t ae_serializer_get_alloc_size(ae_serializer *serializer)
{
    ae_int_t rows, lastrowsize, result;
    
    serializer->mode = AE_SM_READY2S;
    
    /* if no entries needes (degenerate case) */
    if( serializer->entries_needed==0 )
    {
        serializer->bytes_asked = 1;
        return serializer->bytes_asked;
    }
    
    /* non-degenerate case */
    rows = serializer->entries_needed/AE_SER_ENTRIES_PER_ROW;
    lastrowsize = AE_SER_ENTRIES_PER_ROW;
    if( serializer->entries_needed%AE_SER_ENTRIES_PER_ROW )
    {
        lastrowsize = serializer->entries_needed%AE_SER_ENTRIES_PER_ROW;
        rows++;
    }
    
    /* calculate result size */
    result  = ((rows-1)*AE_SER_ENTRIES_PER_ROW+lastrowsize)*AE_SER_ENTRY_LENGTH;
    result +=  (rows-1)*(AE_SER_ENTRIES_PER_ROW-1)+(lastrowsize-1);
    result += rows*2;
    serializer->bytes_asked = result;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x2, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3eb8b
movq -0x10(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ec3d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x5, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movq $0x5, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x5, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x3ebe3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x5, %ecx
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
imulq $0x5, %rax, %rax
addq -0x20(%rbp), %rax
imulq $0xb, %rax, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
shlq $0x2, %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq %rax, -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_serializer_sstart_str(alglib_impl::ae_serializer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void ae_serializer_sstart_str(ae_serializer *serializer, std::string *buf)
{
    serializer->mode = AE_SM_TO_CPPSTRING;
    serializer->out_cppstr = buf;
    serializer->entries_saved = 0;
    serializer->bytes_written = 0;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0xa, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_serialize_bool(alglib_impl::ae_serializer*, bool, alglib_impl::ae_state*)
void ae_serializer_serialize_bool(ae_serializer *serializer, ae_bool v, ae_state *state)
{
    char buf[AE_SER_ENTRY_LENGTH+2+1];
    const char *emsg = "ALGLIB: serialization integrity error";
    ae_int_t bytes_appended;
    
    /* prepare serialization, check consistency */
    ae_bool2str(v, buf, state);
    serializer->entries_saved++;
    if( serializer->entries_saved%AE_SER_ENTRIES_PER_ROW )
        strcat(buf, " ");
    else
        strcat(buf, "\r\n");
    bytes_appended = (ae_int_t)strlen(buf);
    if( serializer->bytes_written+bytes_appended > serializer->bytes_asked )
        ae_break(state, ERR_ASSERTION_FAILED, emsg);
    serializer->bytes_written += bytes_appended;
        
    /* append to buffer */
#ifdef AE_USE_CPP_SERIALIZATION
    if( serializer->mode==AE_SM_TO_CPPSTRING )
    {
        *(serializer->out_cppstr) += buf;
        return;
    }
#endif
    if( serializer->mode==AE_SM_TO_STRING )
    {
        strcat(serializer->out_str, buf);
        serializer->out_str += bytes_appended;
        return;
    }
    ae_break(state, ERR_ASSERTION_FAILED, emsg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x194ff(%rip), %rax     # 0x5826e
movq %rax, -0x30(%rbp)
movb -0x9(%rbp), %al
leaq -0x26(%rbp), %rsi
movq -0x18(%rbp), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x3de00
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x5, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x3edc2
leaq -0x26(%rbp), %rdi
leaq 0x162a8(%rip), %rsi     # 0x55063
callq 0x34e0
jmp 0x3edd2
leaq -0x26(%rbp), %rdi
leaq 0x194c7(%rip), %rsi     # 0x58294
callq 0x34e0
leaq -0x26(%rbp), %rdi
callq 0x3110
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0x3ee07
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x3, %esi
callq 0x3ab10
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0xb, (%rax)
jne 0x3ee34
leaq -0x26(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x32c0
jmp 0x3ee73
movq -0x8(%rbp), %rax
cmpq $0xa, (%rax)
jne 0x3ee61
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x26(%rbp), %rsi
callq 0x34e0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
jmp 0x3ee73
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x3, %esi
callq 0x3ab10
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_serializer_serialize_double(alglib_impl::ae_serializer*, double, alglib_impl::ae_state*)
void ae_serializer_serialize_double(ae_serializer *serializer, double v, ae_state *state)
{
    char buf[AE_SER_ENTRY_LENGTH+2+1];
    const char *emsg = "ALGLIB: serialization integrity error";
    ae_int_t bytes_appended;
    
    /* prepare serialization, check consistency */
    ae_double2str(v, buf, state);
    serializer->entries_saved++;
    if( serializer->entries_saved%AE_SER_ENTRIES_PER_ROW )
        strcat(buf, " ");
    else
        strcat(buf, "\r\n");
    bytes_appended = (ae_int_t)strlen(buf);
    if( serializer->bytes_written+bytes_appended > serializer->bytes_asked )
        ae_break(state, ERR_ASSERTION_FAILED, emsg);
    serializer->bytes_written += bytes_appended;
        
    /* append to buffer */
#ifdef AE_USE_CPP_SERIALIZATION
    if( serializer->mode==AE_SM_TO_CPPSTRING )
    {
        *(serializer->out_cppstr) += buf;
        return;
    }
#endif
    if( serializer->mode==AE_SM_TO_STRING )
    {
        strcat(serializer->out_str, buf);
        serializer->out_str += bytes_appended;
        return;
    }
    ae_break(state, ERR_ASSERTION_FAILED, emsg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x192a2(%rip), %rax     # 0x5826e
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
leaq -0x26(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e420
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x5, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x3f01c
leaq -0x26(%rbp), %rdi
leaq 0x1604e(%rip), %rsi     # 0x55063
callq 0x34e0
jmp 0x3f02c
leaq -0x26(%rbp), %rdi
leaq 0x1926d(%rip), %rsi     # 0x58294
callq 0x34e0
leaq -0x26(%rbp), %rdi
callq 0x3110
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0x3f061
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x3, %esi
callq 0x3ab10
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0xb, (%rax)
jne 0x3f08e
leaq -0x26(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x32c0
jmp 0x3f0cd
movq -0x8(%rbp), %rax
cmpq $0xa, (%rax)
jne 0x3f0bb
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x26(%rbp), %rsi
callq 0x34e0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
jmp 0x3f0cd
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x3, %esi
callq 0x3ab10
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_abs(alglib_impl::ae_complex, alglib_impl::ae_state*)
double ae_c_abs(ae_complex z, ae_state *state)
{
    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 $0x60, %rsp
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x18dde(%rip), %xmm1    # 0x580b0
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movaps 0x18dc9(%rip), %xmm1    # 0x580b0
pand %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
jbe 0x3f308
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x3f312
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3f338
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
jmp 0x3f342
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3f368
jp 0x3f368
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3f3b1
movsd -0x40(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x48(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x15c71(%rip), %xmm1    # 0x55008
addsd %xmm1, %xmm0
callq 0x3200
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_eq(alglib_impl::ae_complex, alglib_impl::ae_complex)
ae_bool ae_c_eq(ae_complex lhs,   ae_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
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x41(%rbp)
jne 0x3f430
jp 0x3f430
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_neq(alglib_impl::ae_complex, alglib_impl::ae_complex)
ae_bool ae_c_neq(ae_complex lhs,  ae_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
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x41(%rbp)
jne 0x3f4b0
jp 0x3f4b0
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_div(alglib_impl::ae_complex, alglib_impl::ae_complex)
ae_complex ae_c_div(ae_complex lhs,   ae_complex rhs)
{
    ae_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
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movaps 0x18abc(%rip), %xmm0    # 0x580b0
pand %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movaps 0x18aac(%rip), %xmm2    # 0x580b0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3f69b
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3f71f
movsd -0x30(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_eq_d(alglib_impl::ae_complex, double)
ae_bool ae_c_eq_d(ae_complex lhs,  double rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs;
    volatile double y1 = lhs.y;
    volatile double y2 = 0;
    return x1==x2 && y1==y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x39(%rbp)
jne 0x3f799
jp 0x3f799
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_neq_d(alglib_impl::ae_complex, double)
ae_bool ae_c_neq_d(ae_complex lhs, double rhs)
{
    volatile double x1 = lhs.x;
    volatile double x2 = rhs;
    volatile double y1 = lhs.y;
    volatile double y2 = 0;
    return x1!=x2 || y1!=y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x39(%rbp)
jne 0x3f809
jp 0x3f809
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_c_d_div(double, alglib_impl::ae_complex)
ae_complex ae_c_d_div(double lhs,   ae_complex rhs)
{
    ae_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
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm1
movaps 0x18711(%rip), %xmm0    # 0x580b0
pand %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
movaps 0x18701(%rip), %xmm2    # 0x580b0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3fa20
movsd -0x18(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3fa85
movsd -0x20(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_cmuld(alglib_impl::ae_complex*, long, long, double)
void ae_v_cmuld(ae_complex *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->x *= alpha;
            vdst->y *= alpha;
        }
    }
    else
    {
        /*
         * optimized case
         */
        for(i=0; i<n; i++, vdst++)
        {
            vdst->x *= alpha;
            vdst->y *= 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 0x41722
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x41720
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd 0x8(%rax), %xmm0
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 0x416d4
jmp 0x41774
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x41772
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd 0x8(%rax), %xmm0
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 0x4172a
jmp 0x41774
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::ae_v_cmulc(alglib_impl::ae_complex*, long, long, alglib_impl::ae_complex)
void ae_v_cmulc(ae_complex *vdst, ae_int_t stride_dst, ae_int_t n, ae_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
    {
        /*
         * highly 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
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
cmpq $0x1, -0x20(%rbp)
je 0x41870
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x4186b
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x50(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x48(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x417c1
jmp 0x41934
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x41932
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x58(%rbp), %xmm0
movsd -0x68(%rbp), %xmm2
movsd -0x60(%rbp), %xmm1
mulsd -0x70(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
movsd -0x70(%rbp), %xmm2
movsd -0x60(%rbp), %xmm1
mulsd -0x68(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x4188c
jmp 0x41934
popq %rbp
retq
nopw %cs:(%rax,%rax)