LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_difference
matrix matrix_difference(matrix a, matrix b)
{
 int i, j;
	matrix result;
 if (!matrix_addition_check(a, b))
   return a; 
 result = matrix_alloc(a.row,a.col);
 for (i = 0; i < a.row; i++)
   for (j = 0; j < a.col; j++)
     result.values[i][j] = a.values[i][j] - b.values[i][j];
 return result;    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdx, %rdi
jne 0x39d33
movq %rcx, %r15
movq %r14, %r12
shrq $0x20, %r12
movl %r14d, %edi
movl %r12d, %esi
callq 0x380d3
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %r14, %rcx
je 0x39d41
xorl %esi, %esi
cmpq %rsi, %r12
je 0x39d2e
movq (%rbx,%rcx,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%r15,%rcx,8), %rdi
subsd (%rdi,%rsi,8), %xmm0
movq (%rdx,%rcx,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0x39d09
incq %rcx
jmp 0x39d02
leaq 0x603a9(%rip), %rdi     # 0x9a0e3
callq 0x4090
jmp 0x39d47
movq %rax, %r14
movq %rdx, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_product
void matrix_product(matrix* a, matrix b)
{
	/*!Last Changed 23.12.2006*/
	matrix result;
	result = matrix_multiply(*a, b);
	matrix_free(*a);
	*a = result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x3933d
movq %rax, %r14
movq %rdx, %r15
movl (%rbx), %esi
movq 0x8(%rbx), %rdi
callq 0x34fc3
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_power
matrix matrix_power(matrix a, int power)
{
 int i;
	matrix result;
 result = matrix_copy(a);
 for (i = 1; i < power; i++)
   matrix_product(&result, a);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x383f4
movq %rsp, %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
pushq $0x1
popq %rbp
cmpl %ebx, %ebp
jge 0x39dcf
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x39d59
incl %ebp
jmp 0x39db9
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_cell_power
void matrix_cell_power(matrix* a, double power)
{
 /*!Last Changed 17.01.2008*/
 int i, j;
 for (i = 0; i < a->row; i++)
   for (j = 0; j < a->col; j++)
     a->values[i][j] = pow(a->values[i][j], power);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x39e3f
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x39e3a
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%r15,8), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x42f0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x39e05
incq %r14
jmp 0x39dfa
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_cell_square
void matrix_cell_square(matrix* a)
{
 /*!Last Changed 17.01.2008*/
 int i, j;
 for (i = 0; i < a->row; i++)
   for (j = 0; j < a->col; j++)
     a->values[i][j] = a->values[i][j] * a->values[i][j];
}

// Assembly:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x39e8b
movl 0x4(%rdi), %esi
testl %esi, %esi
cmovlel %ecx, %esi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x39e86
movq 0x8(%rdi), %r9
movq (%r9,%rdx,8), %r9
movsd (%r9,%r8,8), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x39e64
incq %rdx
jmp 0x39e54
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_diagonal
matrix matrix_diagonal(double* values, int size)
{
 /*!Last Changed 17.01.2008*/
 int i;
 matrix result;
 result = matrix_alloc(size, size);
 for (i = 0; i < size; i++)
   result.values[i][i] = values[i];
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x380d3
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x39ebc
movsd (%r14,%rcx,8), %xmm0
movq (%rdx,%rcx,8), %rsi
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
jmp 0x39ea3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_sum_of_elements
double matrix_sum_of_elements(matrix a)
{
	/*!Last Changed 23.12.2006*/
	int i, j;
	double sum = 0.0;
 for (i = 0; i < a.row; i++)
		 for (j = 0; j < a.col; j++)
				 sum += a.values[i][j];
	return sum;
}

// Assembly:
movq %rdi, %rax
shrq $0x20, %rax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
testl %edi, %edi
movl $0x0, %edx
cmovgl %edi, %edx
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
je 0x39f00
xorl %edi, %edi
cmpq %rdi, %rax
je 0x39efb
movq (%rsi,%rcx,8), %r8
addsd (%r8,%rdi,8), %xmm0
incq %rdi
jmp 0x39ee7
incq %rcx
jmp 0x39ee0
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_trace
double matrix_trace(matrix a)
{
	/*!Last Changed 23.12.2006*/
	int i;
	double sum = 0.0;
 if (a.row != a.col)
  {
   printf(m1365, "Trace");
   return 0;
  }
 for (i = 0; i < a.row; i++)
		 sum += a.values[i][i];
	return sum;
}

// Assembly:
pushq %rax
movq %rdi, %rax
shrq $0x20, %rax
cmpl %eax, %edi
jne 0x39f30
xorl %eax, %eax
testl %edi, %edi
movl $0x0, %ecx
cmovgl %edi, %ecx
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x39f49
movq (%rsi,%rax,8), %rdx
addsd (%rdx,%rax,8), %xmm0
incq %rax
jmp 0x39f1d
leaq 0x5ff72(%rip), %rdi     # 0x99ea9
leaq 0x5ff93(%rip), %rsi     # 0x99ed1
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_sum_column
double matrix_sum_column(matrix a, int index)
{
 /*!Last Changed 19.01.2008*/
 int i;
 double sum = 0.0;
 for (i = 0; i < a.row; i++)
   sum += a.values[i][index];
 return sum;
}

// Assembly:
movslq %edx, %rax
xorl %ecx, %ecx
testl %edi, %edi
cmovlel %ecx, %edi
xorpd %xmm0, %xmm0
cmpq %rcx, %rdi
je 0x39f85
movq (%rsi,%rcx,8), %rdx
addsd (%rdx,%rax,8), %xmm0
incq %rcx
jmp 0x39f72
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_average_columns
double* matrix_average_columns(matrix a)
{
	/*!Last Changed 23.12.2006*/
	int i, j;
	double* result = safecalloc(a.col, sizeof(double), "matrix_average_columns", 2);
	for (i = 0; i < a.row; i++)
		 for (j = 0; j < a.col; j++)
				 result[j] += a.values[i][j];
	for (j = 0; j < a.col; j++)
		 result[j] /= a.row;
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
shrq $0x20, %r15
sarq $0x20, %rdi
leaq 0x5ff34(%rip), %rdx     # 0x99ed7
pushq $0x8
popq %rsi
pushq $0x2
popq %rcx
callq 0x35067
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
cmpq %rdx, %rcx
je 0x39fea
xorl %esi, %esi
cmpq %rsi, %r15
je 0x39fe5
movq (%r14,%rcx,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
addsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
jmp 0x39fc8
incq %rcx
jmp 0x39fc1
cvtsi2sd %ebx, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x3a008
movsd (%rax,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rcx,8)
incq %rcx
jmp 0x39ff0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_max_rows
double* matrix_max_rows(matrix a)
{
	int i, j;
	double* result = safecalloc(a.row, sizeof(double), "matrix_average_columns", 2);
	for (i = 0; i < a.row; i++)
  {
   result[i] = 0;
   for (j = 1; j < a.col; j++)
     if (a.values[i][(int)result[i]] < a.values[i][j])
       result[i] = j;
  }
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %r14d, %r15
leaq 0x5feb4(%rip), %rdx     # 0x99ed7
pushq $0x8
popq %rsi
pushq $0x2
popq %rcx
movq %r15, %rdi
callq 0x35067
sarq $0x20, %r14
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
pushq $0x1
popq %rdx
cmpq %r15, %rcx
je 0x3a083
andq $0x0, (%rax,%rcx,8)
xorpd %xmm0, %xmm0
movq %rdx, %rsi
cmpq %r14, %rsi
jge 0x3a07e
movq (%rbx,%rcx,8), %rdi
cvttsd2si %xmm0, %r8d
movslq %r8d, %r8
movsd (%rdi,%rsi,8), %xmm1
ucomisd (%rdi,%r8,8), %xmm1
jbe 0x3a079
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rsi
jmp 0x3a052
incq %rcx
jmp 0x3a041
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_stdev_columns
double* matrix_stdev_columns(matrix a)
{
 /*!Last Changed 28.02.2009*/
 int i, j;
 double* average = matrix_average_columns(a);
 double* result = safecalloc(a.col, sizeof(double), "matrix_stdev_columns", 2);
 for (i = 0; i < a.row; i++)
   for (j = 0; j < a.col; j++)
     result[j] += (a.values[i][j] - average[j]) * (a.values[i][j] - average[j]);
 for (j = 0; j < a.col; j++)
   result[j] = sqrt(result[j] / (a.row - 1));
 safe_free(average);
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq %rdi, %r13
shrq $0x20, %r13
callq 0x39f86
movq %rax, %rbx
movq %r15, %rdi
sarq $0x20, %rdi
leaq 0x5fe35(%rip), %rdx     # 0x99eee
pushq $0x8
popq %rsi
pushq $0x2
popq %rcx
callq 0x35067
movq %rax, %r14
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
cmpq %rcx, %rax
je 0x3a110
xorl %edx, %edx
cmpq %rdx, %r13
je 0x3a10b
movq (%r12,%rax,8), %rsi
movsd (%rsi,%rdx,8), %xmm0
subsd (%rbx,%rdx,8), %xmm0
mulsd %xmm0, %xmm0
addsd (%r14,%rdx,8), %xmm0
movsd %xmm0, (%r14,%rdx,8)
incq %rdx
jmp 0x3a0e3
incq %rax
jmp 0x3a0dc
leal -0x1(%r15), %eax
cvtsi2sd %eax, %xmm1
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movsd %xmm1, 0x8(%rsp)
cmpq %r15, %r13
je 0x3a15a
movsd (%r14,%r15,8), %xmm0
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x3a140
sqrtsd %xmm0, %xmm0
jmp 0x3a14f
callq 0x4300
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
movsd %xmm0, (%r14,%r15,8)
incq %r15
jmp 0x3a125
movq %rbx, %rdi
callq 0x34ff7
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_sum_row
double matrix_sum_row(matrix a, int index)
{
 /*!Last Changed 19.01.2008*/
 int j;
 double sum = 0.0;
 for (j = 0; j < a.col; j++)
   sum += a.values[index][j];
 return sum;
}

// Assembly:
shrq $0x20, %rdi
movslq %edx, %rax
xorl %ecx, %ecx
testl %edi, %edi
cmovlel %ecx, %edi
xorpd %xmm0, %xmm0
cmpq %rcx, %rdi
je 0x3a198
movq (%rsi,%rax,8), %rdx
addsd (%rdx,%rcx,8), %xmm0
incq %rcx
jmp 0x3a185
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_average_rows
double* matrix_average_rows(matrix a)
{
	/*!Last Changed 23.12.2006*/
	int i, j;
	double* result = safecalloc(a.row, sizeof(double), "matrix_average_rows", 2);
	for (i = 0; i < a.row; i++)
		 for (j = 0; j < a.col; j++)
				 result[i] += a.values[i][j];
	for (i = 0; i < a.row; i++)
		 result[i] /= a.col;
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movslq %edi, %rbx
movq %rdi, %r15
shrq $0x20, %r15
leaq 0x5fd51(%rip), %rdx     # 0x99f03
pushq $0x8
popq %rsi
pushq $0x2
popq %rcx
movq %rbx, %rdi
callq 0x35067
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rbx, %rcx
je 0x3a1fc
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x3a1f7
movq (%r14,%rcx,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rsi
jmp 0x3a1da
incq %rcx
jmp 0x3a1d3
cvtsi2sd %r15d, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x3a21b
movsd (%rax,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rcx,8)
incq %rcx
jmp 0x3a203
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_max
double matrix_max(matrix a)
{
 /*!Last Changed 07.04.2008*/
 int i, j;
 double result = a.values[0][0];
 for (i = 0; i < a.row; i++)
   for (j = 0; j < a.col; j++)
     if (a.values[i][j] > result)
       result = a.values[i][j];
 return result;
}

// Assembly:
movq %rdi, %rax
shrq $0x20, %rax
movq (%rsi), %rcx
movsd (%rcx), %xmm0
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
testl %edi, %edi
movl $0x0, %edx
cmovgl %edi, %edx
cmpq %rdx, %rcx
je 0x3a268
xorl %edi, %edi
cmpq %rdi, %rax
je 0x3a263
movq (%rsi,%rcx,8), %r8
movsd (%r8,%rdi,8), %xmm1
maxsd %xmm0, %xmm1
incq %rdi
movapd %xmm1, %xmm0
jmp 0x3a247
incq %rcx
jmp 0x3a240
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_columnwise_merge
void matrix_columnwise_merge(matrix* a, matrix b)
{
	/*!Last Changed 23.12.2006*/
	int i, j;
 if (a->row != b.row)
  {
   printf(m1366);
   return;
  }
	for (i = 0; i < a->row; i++)
	 {
		 a->values[i] = realloc(a->values[i], (a->col + b.col) * sizeof(double));
			for (j = 0; j < b.col; j++)
				 a->values[i][a->col + j] = b.values[i][j];
	 }
	a->col += b.col;
}

// Assembly:
cmpl %esi, (%rdi)
jne 0x3a33d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %r15
shrq $0x20, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
movl $0x0, %r13d
cmovgl %r15d, %r13d
movslq %r15d, %rbp
movslq %esi, %rax
cmpq %rax, %r12
jge 0x3a349
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
movslq 0x4(%r14), %rsi
addq %rbp, %rsi
shlq $0x3, %rsi
callq 0x42d0
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r12,8)
xorl %eax, %eax
cmpq %rax, %r13
je 0x3a335
movq (%rbx,%r12,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq 0x8(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movslq 0x4(%r14), %rdx
addq %rax, %rdx
movsd %xmm0, (%rcx,%rdx,8)
incq %rax
jmp 0x3a30e
incq %r12
movl (%r14), %esi
jmp 0x3a2e4
leaq 0x5fce5(%rip), %rdi     # 0x9a029
jmp 0x4090
addl %r15d, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_rowwise_merge
void matrix_rowwise_merge(matrix* a, matrix b)
{
	int i, j;
 if (a->col != b.col)
  {
   printf(m1484);
   return;
  }
 a->values = realloc(a->values, (a->row + b.row) * sizeof(double*));
	for (i = 0; i < b.row; i++)
  {
   a->values[a->row + i] = safemalloc(a->col * sizeof(double), "matrix_rowwise_merge", 10);
   for (j = 0; j < b.col; j++)
     a->values[a->row + i][j] = b.values[i][j];
  }
	a->row += b.row;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
shrq $0x20, %r13
cmpl %r13d, 0x4(%rdi)
jne 0x3a40b
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movslq (%r15), %rsi
movslq %ebp, %r12
addq %r12, %rsi
shlq $0x3, %rsi
callq 0x42d0
movq %rax, 0x8(%r15)
xorl %ebx, %ebx
testl %r13d, %r13d
cmovlel %ebx, %r13d
testl %r12d, %r12d
movl $0x0, %r12d
movq %rbp, (%rsp)
cmovgl %ebp, %r12d
pushq $0xa
popq %rbp
cmpq %r12, %rbx
je 0x3a425
movslq 0x4(%r15), %rdi
shlq $0x3, %rdi
leaq 0x5fb4b(%rip), %rsi     # 0x99f17
movl %ebp, %edx
callq 0x34f59
movq 0x8(%r15), %rdx
movslq (%r15), %rsi
movslq %ebx, %rcx
addq %rsi, %rcx
movq %rax, (%rdx,%rcx,8)
xorl %eax, %eax
cmpq %rax, %r13
je 0x3a406
movq (%r14,%rbx,8), %rdx
movsd (%rdx,%rax,8), %xmm0
movq 0x8(%r15), %rdx
movq (%rdx,%rcx,8), %rdx
movsd %xmm0, (%rdx,%rax,8)
incq %rax
jmp 0x3a3e6
incq %rbx
jmp 0x3a3b8
leaq 0x5fc74(%rip), %rdi     # 0x9a086
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
movq (%rsp), %rax
addl %eax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_resize
void matrix_resize(matrix* a, Intervalptr interval)
{
 /*!Last Changed 22.12.2006*/
 int i, j, k; 
 for (i = 0; i < a->row; i++)
  {
   k = 0;
   for (j = 0; j < a->col; j++)
     if (is_in_interval(interval, j))
      {
       a->values[i][k] = a->values[i][j];
       k++;
      }
   a->values[i] = realloc(a->values[i], k * sizeof(double));
  }
 a->col = k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movslq (%rbx), %rax
cmpq %rax, %r13
jge 0x3a4b7
xorl %r15d, %r15d
xorl %ebp, %ebp
movslq 0x4(%rbx), %rax
movslq %ebp, %r12
cmpq %rax, %r15
jge 0x3a496
movq %r14, %rdi
movl %r15d, %esi
callq 0x2d8b6
testl %eax, %eax
je 0x3a491
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rax,%r12,8)
incl %r12d
movl %r12d, %ebp
incq %r15
jmp 0x3a45c
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
shlq $0x3, %r12
movq %r12, %rsi
callq 0x42d0
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x3a44f
movl %ebp, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_covariance
matrix matrix_covariance(matrix a, double** averages)
{
	/*!Last Changed 23.12.2006*/
	matrix result;
	int i, j, k;
	result = matrix_alloc(a.col, a.col);
	*averages = matrix_average_columns(a);
 for (i = 0; i < a.row; i++)
		 for (j = 0; j < a.col; j++)
				 for (k = 0; k < a.col; k++)
						 result.values[j][k] += (a.values[i][j] - (*averages)[j]) * (a.values[i][k] - (*averages)[k]);
 for (j = 0; j < a.col; j++)
		 for (k = 0; k < a.col; k++)
				 result.values[j][k] /= (a.row - 1);
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r12
movq %rdi, %rbx
shrq $0x20, %rbx
movl %ebx, %edi
movl %ebx, %esi
callq 0x380d3
movq %rax, %r14
movq %rdx, %r15
movq %r12, %rdi
movq %r13, %rsi
callq 0x39f86
movq %rax, (%rbp)
xorl %edx, %edx
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
testl %r12d, %r12d
movl $0x0, %esi
cmovgl %r12d, %esi
cmpq %rsi, %rdx
je 0x3a56d
xorl %edi, %edi
cmpq %rcx, %rdi
je 0x3a568
xorl %r8d, %r8d
cmpq %r8, %rbx
je 0x3a563
movq (%r13,%rdx,8), %r9
movsd (%r9,%rdi,8), %xmm0
subsd (%rax,%rdi,8), %xmm0
movsd (%r9,%r8,8), %xmm1
subsd (%rax,%r8,8), %xmm1
mulsd %xmm0, %xmm1
movq (%r15,%rdi,8), %r9
addsd (%r9,%r8,8), %xmm1
movsd %xmm1, (%r9,%r8,8)
incq %r8
jmp 0x3a529
incq %rdi
jmp 0x3a521
incq %rdx
jmp 0x3a51a
leal -0x1(%r12), %eax
cvtsi2sd %eax, %xmm0
xorl %eax, %eax
cmpq %rcx, %rax
je 0x3a5a0
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x3a59b
movq (%r15,%rax,8), %rsi
movsd (%rsi,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdx,8)
incq %rdx
jmp 0x3a57f
incq %rax
jmp 0x3a578
movq %r14, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: pooled_covariance
matrix pooled_covariance(matrix a, int na, matrix b, int nb)
{
 /*!Last Changed 12.01.2009*/
 matrix result, tmp;
 result = matrix_copy(a);
 tmp = matrix_copy(b);
 matrix_multiply_constant(&result, na - 1);
 matrix_multiply_constant(&tmp, nb - 1);
 matrix_add(&result, tmp);
 matrix_divide_constant(&result, na + nb - 2);
 matrix_free(tmp);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r15d
movq %r8, %rbx
movq %rcx, %rbp
movl %edx, %r12d
callq 0x383f4
movq %rax, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
leaq 0x28(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x383f4
movq %rax, %rbp
movq %rdx, %rbx
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leal -0x1(%r12), %eax
cvtsi2sd %eax, %xmm0
movq %r13, %rdi
callq 0x39a42
leal -0x1(%r15), %eax
cvtsi2sd %eax, %xmm0
movq %r14, %rdi
callq 0x39a42
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x39b81
leal (%r12,%r15), %eax
addl $-0x2, %eax
cvtsi2sd %eax, %xmm0
movq %r13, %rdi
callq 0x39a85
movq %rbx, %rdi
movl %ebp, %esi
callq 0x34fc3
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_correlation
matrix matrix_correlation(matrix a)
{
	/*!Last Changed 23.12.2006*/
	matrix result;
	double* dummy;
	int i, j;
	result = matrix_covariance(a, &dummy);
	safe_free(dummy);
 for (i = 0; i < a.col; i++)
	 {
		 for (j = i + 1; j < a.col; j++)
			 {
     if (result.values[i][i] != 0.0 && result.values[j][j] != 0.0)
  				 result.values[i][j] /= sqrt(result.values[i][i] * result.values[j][j]);
     else
       result.values[i][j] = 0.0;
			  result.values[j][i] = result.values[i][j];
			 }
			result.values[i][i] = 1.0;
	 }
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
shrq $0x20, %r12
leaq 0x10(%rsp), %r15
movq %r15, %rdx
callq 0x3a4c9
movq %rax, 0x8(%rsp)
movq %rdx, %r14
movq (%r15), %rdi
callq 0x34ff7
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %r15d
cmovgl %r12d, %r15d
pushq $0x1
popq %rbx
xorpd %xmm2, %xmm2
cmpq %r15, %r13
je 0x3a74c
movq %rbx, %rbp
cmpl %r12d, %ebp
jge 0x3a72f
movq (%r14,%r13,8), %rax
movsd (%rax,%r13,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x3a6d9
jnp 0x3a6fa
movq (%r14,%rbp,8), %rcx
movsd (%rcx,%rbp,8), %xmm1
ucomisd %xmm2, %xmm1
jne 0x3a6ea
jnp 0x3a6fa
mulsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x3a705
sqrtsd %xmm0, %xmm0
jmp 0x3a70e
andq $0x0, (%rax,%rbp,8)
xorpd %xmm1, %xmm1
jmp 0x3a720
callq 0x4300
xorpd %xmm2, %xmm2
movq (%r14,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rbp,8)
movq (%r14,%rbp,8), %rax
movsd %xmm1, (%rax,%r13,8)
incq %rbp
jmp 0x3a6c2
movq (%r14,%r13,8), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%r13,8)
incq %r13
incq %rbx
jmp 0x3a6b6
movq 0x8(%rsp), %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_identical
void matrix_identical(matrix* dest, matrix source)
{
	int i;
 if (dest->row != source.row || dest->col != source.col)
   printf(m1363);
 for (i = 0; i < source.row; i++)
		 memcpy(dest->values[i], source.values[i], source.col * sizeof(double));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
cmpl %r12d, (%rdi)
jne 0x3a789
movq %r12, %rax
shrq $0x20, %rax
cmpl %eax, 0x4(%r14)
je 0x3a795
leaq 0x5f953(%rip), %rdi     # 0x9a0e3
callq 0x4090
movq %r12, %r15
sarq $0x1d, %r15
andq $-0x8, %r15
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %ebp
cmovgl %r12d, %ebp
cmpq %r13, %rbp
je 0x3a7cd
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rdi
movq (%rbx,%r13,8), %rsi
movq %r15, %rdx
callq 0x4310
incq %r13
jmp 0x3a7af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_determinant
double matrix_determinant(matrix matrix1)
{
 /*!Last Changed 25.02.2007*/
 int i, j, k;
 matrix mat;
 double ratio, det = 1.0;
 if (matrix1.row != matrix1.col)
  {
   printf(m1365, "Determinant");
   return 0;
  } 
 mat = matrix_copy(matrix1);
 for (i = 0; i < mat.row; i++) 
  {
   det *= mat.values[i][i];
   if (det == 0.0)
     break;
   for (j = i + 1; j < mat.row; j++)
    {
     ratio = mat.values[j][i] / mat.values[i][i];
     for (k = i; k < mat.col; k++)
       mat.values[j][k] = mat.values[j][k] - mat.values[i][k] * ratio;
    } 
  }
 matrix_free(mat);
 return det;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
shrq $0x20, %rax
cmpl %eax, %edi
jne 0x3a8cc
callq 0x383f4
movq %rax, %rcx
shrq $0x20, %rcx
xorl %esi, %esi
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
movq %rdx, %rdi
movsd 0x5acc6(%rip), %xmm4    # 0x95520
pushq $0x1
popq %rdx
xorpd %xmm0, %xmm0
cmpl %ecx, %esi
movl %ecx, %r9d
cmovgl %esi, %r9d
cmpq %r8, %rsi
je 0x3a8e6
movq (%rdi,%rsi,8), %r10
mulsd (%r10,%rsi,8), %xmm4
ucomisd %xmm0, %xmm4
jne 0x3a881
jnp 0x3a8e6
movq %rdx, %r11
cmpl %eax, %r11d
jge 0x3a8c4
movq (%rdi,%r11,8), %rbx
movsd (%rbx,%rsi,8), %xmm1
divsd (%r10,%rsi,8), %xmm1
movq %rsi, %r14
cmpq %r14, %r9
je 0x3a8bf
movsd (%rbx,%r14,8), %xmm2
movsd (%r10,%r14,8), %xmm3
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm2
movsd %xmm2, (%rbx,%r14,8)
incq %r14
jmp 0x3a89b
incq %r11
jmp 0x3a884
incq %rsi
incq %rdx
jmp 0x3a861
leaq 0x5f5d6(%rip), %rdi     # 0x99ea9
leaq 0x5f652(%rip), %rsi     # 0x99f2c
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
jmp 0x3a8f7
movsd %xmm4, (%rsp)
movl %eax, %esi
callq 0x34fc3
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: mahalanobis_distance
double mahalanobis_distance(matrix x, matrix y, matrix S)
{
 /*!Last Changed 12.01.2009*/
 int reversed;
 matrix diff, difftranspose, covinverse;
 double result;
 /* (x - mu) */
 diff = matrix_difference(x, y); 
 /* (x - mu)T */
 difftranspose = matrix_transpose(diff); 
 covinverse = matrix_copy(S);
 reversed = matrix_inverse(&covinverse); 
 if (!reversed)
  {
   matrix_free(covinverse);
   matrix_free(difftranspose);
   matrix_free(diff);
   printf("Matrix inverse problem\n");
   return -1;
  }
 /*(x - mu) sigma-1 (x - mu)T*/
 matrix_product(&diff, covinverse);
 matrix_free(covinverse);
 matrix_product(&diff, difftranspose); 
 matrix_free(difftranspose);
 result = diff.values[0][0];
 matrix_free(diff);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, %rbp
callq 0x39cca
movq %rax, %r15
movq %rdx, %r12
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rax, %rdi
movq %rdx, %rsi
callq 0x392ac
movq %rax, %rbx
movq %rdx, %r14
movq %rbp, %rdi
movq %r13, %rsi
callq 0x383f4
movq %rax, %r13
movq %rdx, %rbp
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x3a9f7
testl %eax, %eax
je 0x3a9b4
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x39d59
movq %rbp, %rdi
movl %r13d, %esi
callq 0x34fc3
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x39d59
movq %r14, %rdi
movl %ebx, %esi
callq 0x34fc3
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movl (%r15), %esi
callq 0x34fc3
movsd (%rsp), %xmm0
jmp 0x3a9e8
movq %rbp, %rdi
movl %r13d, %esi
callq 0x34fc3
movq %r14, %rdi
movl %ebx, %esi
callq 0x34fc3
movq %r12, %rdi
movl %r15d, %esi
callq 0x34fc3
leaq 0x5cfa2(%rip), %rdi     # 0x9797d
callq 0x4090
movsd 0x5b3c8(%rip), %xmm0    # 0x95db0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_exchange_columns
void matrix_exchange_columns(matrix a, int col1, int col2)
{
 /*!Last Changed 02.02.2005*/
	double tmp;
	int i;
	for (i = 0; i < a.row; i++)
	 {
		 tmp = a.values[i][col1];
   a.values[i][col1] = a.values[i][col2];
			a.values[i][col2] = tmp;
	 }
}

// Assembly:
movslq %edx, %rax
movslq %ecx, %rcx
xorl %edx, %edx
testl %edi, %edi
cmovlel %edx, %edi
cmpq %rdx, %rdi
je 0x3b340
movq (%rsi,%rdx,8), %r8
movsd (%r8,%rax,8), %xmm0
movsd (%r8,%rcx,8), %xmm1
movsd %xmm1, (%r8,%rax,8)
movsd %xmm0, (%r8,%rcx,8)
incq %rdx
jmp 0x3b31a
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: eigensort
void eigensort(double **eigenvalues, matrix *eigenvectors)
{
 int k, j, i, n = (*eigenvectors).row;
 double p;
 for (i = 0; i < n - 1; i++)
  {
   k = i;
   p = (*eigenvalues)[i];
   for (j = i + 1; j < n; j++)
    {
     if ((*eigenvalues)[j] >= p)
      {
       k = j;
       p = (*eigenvalues)[j];
      }
    }
   if (k != i)
    {
     (*eigenvalues)[k] = (*eigenvalues)[i];
     (*eigenvalues)[i] = p;
     matrix_exchange_columns(*eigenvectors, i, k);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %r12d
cmpl $0x2, %r12d
pushq $0x1
popq %r13
cmovgel %r12d, %r13d
movq %rdi, %r14
decl %r13d
pushq $0x1
popq %rbp
xorl %r15d, %r15d
cmpq %r13, %r15
je 0x3b3e1
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbp, %rdx
movl %r15d, %ecx
movapd %xmm0, %xmm1
cmpq %rdx, %r12
je 0x3b3b5
movsd (%rax,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
cmovael %edx, %ecx
movapd %xmm1, %xmm3
cmpnlesd %xmm2, %xmm3
movapd %xmm3, %xmm4
andnpd %xmm2, %xmm4
andpd %xmm1, %xmm3
orpd %xmm4, %xmm3
incq %rdx
movapd %xmm3, %xmm1
jmp 0x3b382
movl %ecx, %edx
cmpq %rdx, %r15
je 0x3b3d9
movslq %ecx, %rdx
movsd %xmm0, (%rax,%rdx,8)
movsd %xmm1, (%rax,%r15,8)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movl %r15d, %edx
callq 0x3b30d
incq %r15
incq %rbp
jmp 0x3b36a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: balbak
void balbak(matrix* eigenvectors, double* scale)
{
 int i, j;
 for (i = 0; i < eigenvectors->row; i++) 
   for (j = 0; j < eigenvectors->col; j++)
     eigenvectors->values[i][j] *= scale[i];
}

// Assembly:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x3b609
movl 0x4(%rdi), %r8d
testl %r8d, %r8d
cmovlel %ecx, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x3b604
movsd (%rsi,%rdx,8), %xmm0
movq 0x8(%rdi), %r10
movq (%r10,%rdx,8), %r10
mulsd (%r10,%r9,8), %xmm0
movsd %xmm0, (%r10,%r9,8)
incq %r9
jmp 0x3b5e1
incq %rdx
jmp 0x3b5ce
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: eltran
void eltran(matrix* eigenvectors, matrix a, int* perm)
{
 int mp, k, i, j;
 for (mp = a.row - 2; mp > 0; mp--)
  {
   for (k = mp + 1; k < a.row; k++)
     eigenvectors->values[k][mp] = a.values[k][mp - 1];
   i = perm[mp];
   if (i != mp)
    {
     for (j = mp; j < a.row; j++)
      {
       eigenvectors->values[mp][j] = eigenvectors->values[i][j];
       eigenvectors->values[i][j] = 0.0;
      }
     eigenvectors->values[i][mp] = 1.0;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
leal -0x2(%rsi), %eax
leaq 0x1(%rax), %r8
movabsq $0x3ff0000000000000, %r9 # imm = 0x3FF0000000000000
testl %eax, %eax
jle 0x3b8a5
movq %r8, %r10
cmpl %esi, %r10d
jge 0x3b864
movq (%rdx,%r10,8), %r11
movsd -0x8(%r11,%rax,8), %xmm0
movq 0x8(%rdi), %r11
movq (%r11,%r10,8), %r11
movsd %xmm0, (%r11,%rax,8)
incq %r10
jmp 0x3b841
movl (%rcx,%rax,4), %r10d
cmpq %r10, %rax
je 0x3b89d
movslq %r10d, %r10
movq 0x8(%rdi), %r11
movq (%r11,%r10,8), %r10
movq %rax, %rbx
cmpl %esi, %ebx
jge 0x3b899
movsd (%r10,%rbx,8), %xmm0
movq (%r11,%rax,8), %r14
movsd %xmm0, (%r14,%rbx,8)
andq $0x0, (%r10,%rbx,8)
incq %rbx
jmp 0x3b87b
movq %r9, (%r10,%rax,8)
decq %rax
decq %r8
jmp 0x3b83a
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: find_eigenvalues_eigenvectors_unsymmetric
double* find_eigenvalues_eigenvectors_unsymmetric(matrix* eigenvectors, matrix a)
{
 double *eigenvalues = NULL, *scale;
 int i, *permutation;
 (*eigenvectors) = matrix_alloc(a.row, a.col); 
 scale = balance(a); 
 permutation = elmhes(a); 
 for (i = 0; i < a.row; i++) 
   eigenvectors->values[i][i] = 1.0;
 eltran(eigenvectors, a, permutation); 
 eigenvalues = hqr2(eigenvectors, a);
 if (eigenvalues == NULL)
   return NULL; 
 balbak(eigenvectors, scale); 
 eigensort(&eigenvalues, eigenvectors);
	return eigenvalues;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
shrq $0x20, %rsi
movl %r15d, %edi
callq 0x380d3
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b3f0
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b60a
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
cmpq %rcx, %rdx
je 0x3c571
movq 0x8(%rbx), %rdi
movq (%rdi,%rcx,8), %rdi
movq %rsi, (%rdi,%rcx,8)
incq %rcx
jmp 0x3c55b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x3b826
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3b8a9
movq %rax, %r14
movq %rax, (%rsp)
testq %rax, %rax
je 0x3c5b2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b5c3
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3b341
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: find_eigenvalues_eigenvectors_symmetric
double* find_eigenvalues_eigenvectors_symmetric(matrix* eigenvectors, matrix a)
{
 double *eigenvalues = NULL;
 jacobi(a, &eigenvalues, eigenvectors);
 eigensort(&eigenvalues, eigenvectors);
	return eigenvalues;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3ada1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b341
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: find_eigenvalues_eigenvectors
double* find_eigenvalues_eigenvectors(matrix* eigenvectors, matrix cov, int* newdimension, double range)
{
 int i, howmany;
 double total = 0 ,sum = 0, *eigenvalues = NULL;
 jacobi(cov, &eigenvalues, eigenvectors);
 eigensort(&eigenvalues, eigenvectors);
 for (i = 0; i < eigenvectors->row; i++)
   total += eigenvalues[i];
	howmany = eigenvectors->row - 1;
 for (i = 0; i < eigenvectors->row; i++)
  {
   sum += eigenvalues[i];
   if ((sum / total) > range)
    {
     howmany = i;
     break;
    }
  }
	*newdimension = howmany;
	return eigenvalues;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ada1
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b341
movl (%r14), %ecx
movq (%r15), %rax
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
xorpd %xmm0, %xmm0
cmpq %rsi, %rdx
je 0x3c654
addsd (%rax,%rsi,8), %xmm0
incq %rsi
jmp 0x3c645
decl %ecx
xorpd %xmm1, %xmm1
xorl %esi, %esi
movsd (%rsp), %xmm3
cmpq %rsi, %rdx
je 0x3c680
addsd (%rax,%rsi,8), %xmm1
movapd %xmm1, %xmm2
divsd %xmm0, %xmm2
ucomisd %xmm3, %xmm2
ja 0x3c67e
incq %rsi
jmp 0x3c661
movl %esi, %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/metaclassification.c
// Function: test_one_vs_one
Prediction test_one_vs_one(Instanceptr data, void** model, int algorithm, void* parameters, double* posterior)
{
 int i, j, k = 0, *votes, tmp;
 Prediction result, prediction;
 double* tmp_posteriors;
 tmp_posteriors = safemalloc(current_dataset->classno * sizeof(double), "test_one_vs_one", 3);
 votes = safecalloc(current_dataset->classno, sizeof(int), "test_one_vs_one", 4);
 tmp = current_dataset->classno;
 for (i = 0; i < current_dataset->classno; i++)
   for (j = i + 1; j < current_dataset->classno; j++)
    {
     current_dataset->classno = 2;
     prediction = classification_algorithms[algorithm - SELECTMAX].test_algorithm(data, model[k], parameters, tmp_posteriors);
     current_dataset->classno = tmp;
     if (prediction.classno == 0)
       votes[i]++;
     else
       votes[j]++;
     k++;
    }
 safe_free(tmp_posteriors);
 result.classno = find_max_in_list(votes, current_dataset->classno);
 normalize_array(votes, posterior, current_dataset->classno);
 safe_free(votes);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x38(%rsp)
movl %ecx, %r15d
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x90fe3(%rip), %rbx     # 0xcd870
movq (%rbx), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x5d949(%rip), %rbp     # 0x9a1e8
pushq $0x3
popq %rdx
movq %rbp, %rsi
callq 0x34f59
movq %rax, 0x8(%rsp)
movq (%rbx), %rax
movslq 0x10(%rax), %rdi
pushq $0x4
popq %rsi
pushq $0x4
popq %rcx
movq %rbp, %rdx
callq 0x35067
movq %rax, %r14
movq (%rbx), %rax
movl 0x10(%rax), %ebx
addl $0xfffffc18, %r15d      # imm = 0xFFFFFC18
movslq %r15d, %rcx
imulq $0x28, %rcx, %rcx
leaq 0x8f8de(%rip), %rdx     # 0xcc1c0
leaq (%rdx,%rcx), %r15
addq $0x8, %r15
pushq $0x1
popq %rbp
xorl %r12d, %r12d
movl %ebx, %ecx
xorl %r13d, %r13d
movslq %ecx, %rdx
cmpq %rdx, %r12
jge 0x3c965
movslq %r13d, %r13
movq %rbp, 0x20(%rsp)
cmpl %ebp, %ecx
jle 0x3c958
movl $0x2, 0x10(%rax)
movq 0x30(%rsp), %rax
movq (%rax,%r13,8), %rdx
leaq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *(%r15)
cmpl $0x0, 0x48(%rsp)
leaq 0x90f34(%rip), %rax     # 0xcd870
movq (%rax), %rax
movq %rbp, %rcx
cmoveq %r12, %rcx
movl %ebx, 0x10(%rax)
incl (%r14,%rcx,4)
incq %r13
incq %rbp
movl 0x10(%rax), %ecx
jmp 0x3c905
incq %r12
movq 0x20(%rsp), %rbp
incq %rbp
jmp 0x3c8f5
movq 0x8(%rsp), %rdi
callq 0x34ff7
leaq 0x90efa(%rip), %r15     # 0xcd870
movq (%r15), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x336b5
movq 0x18(%rsp), %rbx
movl %eax, 0x8(%rbx)
movq (%r15), %rax
movl 0x10(%rax), %edx
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x33b8f
movq %r14, %rdi
callq 0x34ff7
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/metaclassification.c
// Function: train_one_vs_rest
void** train_one_vs_rest(Instanceptr* trdata, Instanceptr* cvdata, int algorithm, void* parameters)
{
 Datasetptr tmp;
 int i;
 void** model;
 Instanceptr train = NULL, cv = NULL;
 model = safemalloc(sizeof(void*) * current_dataset->classno, "test_one_vs_rest", 2);
 for (i = 0; i < current_dataset->classno; i++)
  {
   divide_instancelist_one_vs_rest_with_copy(*trdata, &train, i);
   divide_instancelist_one_vs_rest_with_copy(*cvdata, &cv, i);
   tmp = copy_of_dataset(current_dataset);
   current_dataset->classno = 2;
   current_dataset->classcounts[0] = tmp->classcounts[i];
   current_dataset->classcounts[1] = tmp->datacount - tmp->classcounts[i];
   model[i] = classification_algorithms[algorithm - SELECTMAX].train_algorithm(&train, &cv, parameters);
   current_dataset->classno = tmp->classno;
   current_dataset->classcounts[0] = tmp->classcounts[0];
   current_dataset->classcounts[1] = tmp->classcounts[1];
   free_dataset(tmp);
   if (!in_list(algorithm, 1, KNN))
    {
     deallocate(train);
     deallocate(cv);
    }
  }
 return model;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x30(%rsp)
movl %edx, %r14d
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
leaq 0x90e7e(%rip), %r13     # 0xcd870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x5d7f3(%rip), %rsi     # 0x9a1f8
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, (%rsp)
movq %r14, 0x18(%rsp)
leal -0x3e8(%r14), %eax
cltq
imulq $0x28, %rax, %r14
addq 0x8f586(%rip), %r14     # 0xcbfb0
xorl %r15d, %r15d
movq (%r13), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r15
jge 0x3cb1d
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x10(%rsp), %rbp
movq %rbp, %rsi
movl %r15d, %edx
callq 0x2ccb4
movq 0x28(%rsp), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
movl %r15d, %edx
callq 0x2ccb4
movq (%r13), %rdi
callq 0x11e73
movq %rax, %r12
movq (%r13), %rax
movl $0x2, 0x10(%rax)
movl 0x1407140(%r12,%r15,4), %ecx
movl %ecx, 0x1407140(%rax)
movl 0x1407120(%r12), %edx
subl %ecx, %edx
movl %edx, 0x1407144(%rax)
movq %rbp, %rdi
movq %rbx, %rsi
movq 0x30(%rsp), %rdx
callq *(%r14)
movq (%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movl 0x10(%r12), %eax
movq (%r13), %rcx
movl %eax, 0x10(%rcx)
movl 0x1407140(%r12), %eax
movl %eax, 0x1407140(%rcx)
movl 0x1407144(%r12), %eax
movl %eax, 0x1407144(%rcx)
movq %r12, %rdi
callq 0x12723
movq 0x18(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0x3e9, %edx            # imm = 0x3E9
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
jne 0x3cb15
movq 0x10(%rsp), %rdi
callq 0x2c010
movq 0x8(%rsp), %rdi
callq 0x2c010
incq %r15
jmp 0x3ca2d
movq (%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/metaclassification.c
// Function: test_one_vs_rest
Prediction test_one_vs_rest(Instanceptr data, void** model, int algorithm, void* parameters, double* posterior)
{
 int i, tmp;
 double* tmp_posteriors;
 Prediction result;
 tmp_posteriors = safemalloc(current_dataset->classno * sizeof(double), "test_one_vs_rest", 3);
 tmp = current_dataset->classno;
 for (i = 0; i < current_dataset->classno; i++)
  {
   current_dataset->classno = 2;
   classification_algorithms[algorithm - SELECTMAX].test_algorithm(data, model[i], parameters, tmp_posteriors);
   current_dataset->classno = tmp;
   posterior[i] = tmp_posteriors[0];
  }
 safe_free(tmp_posteriors);
 normalize_array_of_doubles(posterior, current_dataset->classno);
 result.classno = findMaxOutput(posterior, current_dataset->classno);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, (%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, %r14d
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
leaq 0x90d12(%rip), %rbx     # 0xcd870
movq (%rbx), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x5d688(%rip), %rsi     # 0x9a1f8
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %rbp
movq (%rbx), %rax
movl 0x10(%rax), %ebx
addl $0xfffffc18, %r14d      # imm = 0xFFFFFC18
movslq %r14d, %rcx
imulq $0x28, %rcx, %rcx
leaq 0x8f62a(%rip), %rdx     # 0xcc1c0
leaq (%rdx,%rcx), %r14
addq $0x8, %r14
movslq %ebx, %r15
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x3cbed
movl $0x2, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %rdx
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rcx
movq %rbp, %r8
callq *(%r14)
leaq 0x90c9d(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl %ebx, 0x10(%rax)
movsd (%rbp), %xmm0
movq (%rsp), %rcx
movsd %xmm0, (%rcx,%r12,8)
incq %r12
jmp 0x3cba4
movq %rbp, %rdi
callq 0x34ff7
leaq 0x90c74(%rip), %r14     # 0xcd870
movq (%r14), %rax
movl 0x10(%rax), %esi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x33c59
movq (%r14), %rax
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0x339b7
movq 0x8(%rsp), %rcx
movl %eax, 0x8(%rcx)
movq %rcx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/metaclassification.c
// Function: train_bagging_classification
void** train_bagging_classification(Instanceptr* trdata, Instanceptr* cvdata, int algorithm, void* parameters)
{
 int i, learner_count;
 Instanceptr traindata, validationdata;
 void** model;
 learner_count = get_parameter_i("weaklearnercount");
 model = safemalloc(sizeof(void*) * learner_count, "train_bagging_classification", 4);
 for (i = 0; i < learner_count; i++)
  {
   traindata = bootstrap_sample_without_stratification(*trdata);
   if (is_cvdata_needed(algorithm))
     validationdata = bootstrap_sample_without_stratification(*cvdata);
   else
     validationdata = NULL;
   model[i] = classification_algorithms[algorithm - SELECTMAX].train_algorithm(&traindata, &validationdata, parameters);
   deallocate(traindata);
   deallocate(validationdata);
  }
 return model;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movl %edx, %r14d
movq %rsi, 0x18(%rsp)
movq %rdi, %r12
leaq 0x5d56b(%rip), %rdi     # 0x9a1c6
callq 0x4cd35
movslq %eax, %rbp
leaq (,%rbp,8), %rdi
leaq 0x5d597(%rip), %rsi     # 0x9a209
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r13
leal -0x3e8(%r14), %eax
cltq
imulq $0x28, %rax, %r15
addq 0x8f31f(%rip), %r15     # 0xcbfb0
xorl %ebx, %ebx
testl %ebp, %ebp
cmovlel %ebx, %ebp
cmpq %rbx, %rbp
je 0x3ccfd
movq (%r12), %rdi
callq 0x2c859
movq %rax, 0x10(%rsp)
movl %r14d, %edi
callq 0x591a
testl %eax, %eax
je 0x3ccc6
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x2c859
jmp 0x3ccc8
xorl %eax, %eax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *(%r15)
movq %rax, (%r13,%rbx,8)
movq 0x10(%rsp), %rdi
callq 0x2c010
movq 0x8(%rsp), %rdi
callq 0x2c010
incq %rbx
jmp 0x3cc98
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/metaclassification.c
// Function: test_bagging_classification
Prediction test_bagging_classification(Instanceptr data, void** model, int algorithm, void* parameters, double* posterior)
{
 int i, learner_count;
 int* predictions;
 matrix posteriors;
 Prediction result, prediction;
 learner_count = get_parameter_i("weaklearnercount");
 predictions = safecalloc(learner_count, sizeof(int), "test_bagging_classification", 3);
 posteriors = matrix_alloc(learner_count, current_dataset->classno);
 for (i = 0; i < learner_count; i++)
  {
   prediction = classification_algorithms[algorithm - SELECTMAX].test_algorithm(data, model[i], parameters, posteriors.values[i]);
   predictions[i] = prediction.classno;
  }
 result.classno = combination_algorithms[get_parameter_l("combinationtype")](predictions, posteriors);
 safe_free(predictions);
 matrix_free(posteriors);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x18(%rsp)
movl %ecx, %r14d
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
leaq 0x5d48d(%rip), %rdi     # 0x9a1c6
callq 0x4cd35
movslq %eax, %rbp
leaq 0x5d4de(%rip), %rdx     # 0x9a226
pushq $0x4
popq %rsi
pushq $0x3
popq %rcx
movq %rbp, %rdi
callq 0x35067
movq %rax, %r13
leaq 0x90b10(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %esi
movl %ebp, %edi
callq 0x380d3
movq %rax, (%rsp)
movq %rdx, %rbx
addl $0xfffffc18, %r14d      # imm = 0xFFFFFC18
movslq %r14d, %rax
imulq $0x28, %rax, %rax
leaq 0x8f437(%rip), %rcx     # 0xcc1c0
leaq (%rcx,%rax), %r14
addq $0x8, %r14
xorl %r15d, %r15d
testl %ebp, %ebp
cmovlel %r15d, %ebp
cmpq %r15, %rbp
je 0x3cdca
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rdx
movq (%rbx,%r15,8), %r8
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rcx
callq *(%r14)
movl 0x28(%rsp), %eax
movl %eax, (%r13,%r15,4)
incq %r15
jmp 0x3cd9a
leaq 0x5d471(%rip), %rdi     # 0x9a242
callq 0x4cf11
cltq
leaq 0x901a1(%rip), %rcx     # 0xccf80
movq %r13, %rdi
movq (%rsp), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq *(%rcx,%rax,8)
movq 0x8(%rsp), %r14
movl %eax, 0x8(%r14)
movq %r13, %rdi
callq 0x34ff7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3929f
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq