LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3ee2f
movq %rax, %r14
movq %rdx, %r15
movl (%rbx), %esi
movq 0x8(%rbx), %rdi
callq 0x3a14b
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3dae3
movq %rax, %r12
movq %rdx, %r13
cmpl $0x2, %ebx
jl 0x3fc28
decl %ebx
movq %r15, (%rsp)
movq %r14, %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq (%rsp), %rcx
callq 0x3ee2f
movq %rax, %rbp
movq %rdx, %r14
movq %r13, %rdi
movl %r12d, %esi
callq 0x3a14b
movq %rbp, %r12
movq %r14, %r13
decl %ebx
jne 0x3fbf9
jmp 0x3fc2e
movq %r12, %rbp
movq %r13, %r14
movq %rbp, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x3fcb1
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %eax
xorl %r14d, %r14d
movsd %xmm0, 0x8(%rsp)
testl %eax, %eax
jle 0x3fc9d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rcx
xorl %r15d, %r15d
movsd (%rcx,%r15,8), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x42f0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rcx
movsd %xmm0, (%rcx,%r15,8)
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x3fc70
movl (%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x3fc61
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3fcee
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x3fce6
movq 0x8(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x3fcce
incq %rdx
cmpq %rax, %rdx
jne 0x3fcbf
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x6a26e(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ebp, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %rdx
movl %ebp, %ecx
testl %ebp, %ebp
jle 0x3fd38
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm0
movq (%rdx,%rax,8), %rsi
movsd %xmm0, (%rsi,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x3fd22
movq %rcx, %rax
shlq $0x20, %rax
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edi, %edi
jle 0x3fd82
movq %rdi, %rax
shrq $0x20, %rax
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
testl %eax, %eax
jle 0x3fd79
movq (%rsi,%rcx,8), %rdx
xorl %r8d, %r8d
addsd (%rdx,%r8,8), %xmm0
incq %r8
cmpq %r8, %rax
jne 0x3fd6b
incq %rcx
cmpq %rdi, %rcx
jne 0x3fd60
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3fdb5
testl %edi, %edi
jle 0x3fdca
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorpd %xmm0, %xmm0
xorl %eax, %eax
movq (%rsi,%rax,8), %rcx
addsd (%rcx,%rax,8), %xmm0
incq %rax
cmpq %rax, %rdi
jne 0x3fda2
jmp 0x3fdce
leaq 0x6a1bd(%rip), %rdi     # 0xa9f79
leaq 0x6a1de(%rip), %rsi     # 0xa9fa1
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edi, %edi
jle 0x3fe0e
movslq %edx, %rax
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movq (%rsi,%rcx,8), %rdx
addsd (%rdx,%rax,8), %xmm0
incq %rcx
cmpq %rcx, %rdi
jne 0x3fdfc
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6a178(%rip), %rdx     # 0xa9fa7
movl $0x8, %esi
movl $0x2, %ecx
callq 0x3a1fc
testl %ebx, %ebx
jle 0x3fe76
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r15d, %r15d
jle 0x3fe6e
movq (%r14,%rdx,8), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
addsd (%rax,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %r15
jne 0x3fe57
incq %rdx
cmpq %rcx, %rdx
jne 0x3fe4c
testl %r15d, %r15d
jle 0x3fe9a
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x3fe84
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6a0f2(%rip), %rdx     # 0xa9fa7
movl $0x8, %esi
movq %r15, %rdi
movl $0x2, %ecx
callq 0x3a1fc
testl %r15d, %r15d
jle 0x3ff27
movq %r14, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %edx, %edx
movq $0x0, (%rax,%rdx,8)
cmpl $0x2, %ecx
jl 0x3ff1f
movq (%rbx,%rdx,8), %rsi
xorpd %xmm0, %xmm0
movl $0x1, %edi
cvttsd2si %xmm0, %r8d
movslq %r8d, %r8
movsd (%rsi,%rdi,8), %xmm1
ucomisd (%rsi,%r8,8), %xmm1
jbe 0x3ff17
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x3fef6
incq %rdx
cmpq %r14, %rdx
jne 0x3fedc
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3fe12
movq %rax, %rbx
movq %r15, %rdi
sarq $0x20, %rdi
leaq 0x6a061(%rip), %rdx     # 0xa9fbe
movl $0x8, %esi
movl $0x2, %ecx
callq 0x3a1fc
movq %rax, %r14
testl %r15d, %r15d
jle 0x3ffb3
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %r13d, %r13d
jle 0x3ffab
movq (%r12,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
subsd (%rbx,%rsi,8), %xmm0
mulsd %xmm0, %xmm0
addsd (%r14,%rsi,8), %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %r13
jne 0x3ff89
incq %rcx
cmpq %rax, %rcx
jne 0x3ff7e
testl %r13d, %r13d
jle 0x40000
leal -0x1(%r15), %eax
cvtsi2sd %eax, %xmm1
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movsd %xmm1, 0x8(%rsp)
movsd (%r14,%r15,8), %xmm0
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x3ffe3
sqrtsd %xmm0, %xmm0
jmp 0x3fff2
callq 0x4300
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
movsd %xmm0, (%r14,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x3ffcd
movq %rbx, %rdi
callq 0x3a180
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testl %edi, %edi
jle 0x4003c
movslq %edx, %rax
movq (%rsi,%rax,8), %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rax,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rdi
jne 0x4002e
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %rbx
movslq %ebx, %r15
leaq 0x69f7e(%rip), %rdx     # 0xa9fd3
movl $0x8, %esi
movq %r15, %rdi
movl $0x2, %ecx
callq 0x3a1fc
testl %r15d, %r15d
jle 0x400d1
movq %rbx, %rcx
shrq $0x20, %rcx
movl %ebx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
testl %ecx, %ecx
jle 0x400a0
movq (%r14,%rsi,8), %rdi
movsd (%rax,%rsi,8), %xmm0
xorl %r8d, %r8d
addsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %r8
cmpq %r8, %rcx
jne 0x4008d
incq %rsi
cmpq %rdx, %rsi
jne 0x4007d
testl %ebx, %ebx
jle 0x400d1
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x400bb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 (%rsi), %rax
movsd (%rax), %xmm1
testl %edi, %edi
jle 0x40125
movq %rdi, %rax
shrq $0x20, %rax
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %eax, %eax
jle 0x40114
movq (%rsi,%rcx,8), %rdx
xorl %r8d, %r8d
movsd (%rdx,%r8,8), %xmm0
maxsd %xmm1, %xmm0
incq %r8
movapd %xmm0, %xmm1
cmpq %r8, %rax
jne 0x400fc
jmp 0x40118
movapd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rdi, %rcx
jne 0x400f1
retq
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpl %ebx, (%rdi)
jne 0x40209
movq %rdi, %r15
movl %ebx, %eax
shrq $0x20, %rbx
testl %eax, %eax
jle 0x401fb
movq %rdx, %r14
xorl %r12d, %r12d
movslq %ebx, %r13
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rdi
movslq 0x4(%r15), %rsi
addq %r13, %rsi
shlq $0x3, %rsi
callq 0x42d0
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%r12,8)
testl %r13d, %r13d
jle 0x401f0
movq (%r14,%r12,8), %rax
movq 0x8(%r15), %rdx
movslq 0x4(%r15), %rcx
shlq $0x3, %rcx
addq (%rdx,%r12,8), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rbx
jne 0x401de
incq %r12
movslq (%r15), %rax
cmpq %rax, %r12
jl 0x401a3
addl %ebx, 0x4(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x69ee9(%rip), %rdi     # 0xaa0f9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 0x402d2
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movslq (%rbx), %rsi
movslq %r12d, %r14
addq %r14, %rsi
shlq $0x3, %rsi
callq 0x42d0
movq %rax, 0x8(%rbx)
testl %r14d, %r14d
movq %r12, (%rsp)
jle 0x402ec
movl %r12d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
leaq 0x69d6a(%rip), %r12     # 0xa9fe7
movslq 0x4(%rbx), %rdi
shlq $0x3, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x3a0e1
movl (%rbx), %ecx
leal (%r14,%rcx), %edx
movq 0x8(%rbx), %rsi
movslq %edx, %rdx
movq %rax, (%rsi,%rdx,8)
testl %r13d, %r13d
jle 0x402c8
movq (%r15,%r14,8), %rax
movq 0x8(%rbx), %rsi
movq (%rsi,%rdx,8), %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %r13
jne 0x402b6
incq %r14
cmpq %rbp, %r14
jne 0x4027d
jmp 0x402ee
leaq 0x69e7d(%rip), %rdi     # 0xaa156
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
movl (%rbx), %ecx
addl (%rsp), %ecx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x40389
movq %rsi, %r14
xorl %r12d, %r12d
cmpl $0x0, 0x4(%rbx)
movl $0x0, %r13d
jle 0x40360
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %r14, %rdi
movl %r15d, %esi
callq 0x31a3e
testl %eax, %eax
je 0x40354
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movsd (%rax,%r15,8), %xmm0
movslq %r13d, %r13
movsd %xmm0, (%rax,%r13,8)
incl %r13d
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x4032b
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
movslq %r13d, %rsi
shlq $0x3, %rsi
callq 0x42d0
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x40319
jmp 0x40389
movl %r13d, 0x4(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rdi, %r14
shrq $0x20, %r14
leaq 0x69bb5(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %r14d, %edx
movl %r14d, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3fe12
movq %rax, (%r13)
testl %ebx, %ebx
jle 0x40442
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r14d, %r14d
jle 0x4043a
movq (%r12,%rdx,8), %rsi
xorl %edi, %edi
movq (%r15,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%rsi,%rdi,8), %xmm0
subsd (%rax,%rdi,8), %xmm0
movsd (%rsi,%r9,8), %xmm1
subsd (%rax,%r9,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r8,%r9,8), %xmm1
movsd %xmm1, (%r8,%r9,8)
incq %r9
cmpq %r9, %r14
jne 0x40404
incq %rdi
cmpq %r14, %rdi
jne 0x403fd
incq %rdx
cmpq %rcx, %rdx
jne 0x403f2
testl %r14d, %r14d
jle 0x40477
leal -0x1(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x40459
incq %rax
cmpq %r14, %rax
jne 0x40453
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %rbx
orq %r14, %rbx
movq %rbx, %rax
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
callq 0x3dae3
movq %rax, %r13
movq %rdx, %r14
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x3dae3
movq %rax, %r15
movq %rdx, %r12
movq %r13, %rbx
shrq $0x20, %rbx
testl %r13d, %r13d
jle 0x4051c
leal -0x1(%rbp), %eax
cvtsi2sd %eax, %xmm0
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %ebx, %ebx
jle 0x40514
movq (%r14,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rbx
jne 0x404fe
incq %rcx
cmpq %rax, %rcx
jne 0x404f4
testl %r15d, %r15d
jle 0x40568
movq (%rsp), %rax
decl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq %r15, %rax
shrq $0x20, %rax
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %eax, %eax
jle 0x40560
movq (%r12,%rdx,8), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x4054a
incq %rdx
cmpq %rcx, %rdx
jne 0x40540
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3f993
testl %r13d, %r13d
jle 0x405bf
movq (%rsp), %rax
addl %ebp, %eax
addl $-0x2, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %ebx, %ebx
jle 0x405b7
movq (%r14,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rbx
jne 0x405a1
incq %rcx
cmpq %rax, %rcx
jne 0x40597
movq %r12, %rdi
movl %r15d, %esi
callq 0x3a14b
movq %r13, %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_O3/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 0x40397
movq %rax, 0x8(%rsp)
movq %rdx, %r14
movq (%r15), %rdi
callq 0x3a180
testl %r12d, %r12d
jle 0x406be
movl $0x1, %r13d
xorl %ebp, %ebp
xorpd %xmm2, %xmm2
leaq 0x1(%rbp), %rbx
movq (%r14,%rbp,8), %rax
cmpq %r12, %rbx
jae 0x406a1
movq %r13, %r15
movsd (%rax,%rbp,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x40643
jnp 0x40665
movq (%r14,%r15,8), %rcx
movsd (%rcx,%r15,8), %xmm1
ucomisd %xmm2, %xmm1
jne 0x40655
jnp 0x40665
mulsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x40673
sqrtsd %xmm0, %xmm0
jmp 0x4067c
movq $0x0, (%rax,%r15,8)
xorpd %xmm1, %xmm1
jmp 0x40690
callq 0x4300
xorpd %xmm2, %xmm2
movq (%r14,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r15,8)
movq (%r14,%r15,8), %rcx
movsd %xmm1, (%rcx,%rbp,8)
incq %r15
cmpq %r15, %r12
jne 0x40636
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%rbp,8)
incq %r13
movq %rbx, %rbp
cmpq %r12, %rbx
jne 0x40626
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_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl %r14d, (%rdi)
jne 0x406f9
movq %r14, %rax
shrq $0x20, %rax
cmpl %eax, 0x4(%r15)
je 0x40705
leaq 0x69ab3(%rip), %rdi     # 0xaa1b3
callq 0x4090
testl %r14d, %r14d
jle 0x4073b
movq %r14, %r12
sarq $0x1d, %r12
andq $-0x8, %r12
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rdi
movq (%rbx,%r13,8), %rsi
movq %r12, %rdx
callq 0x4310
incq %r13
cmpq %r13, %r14
jne 0x4071f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: matrix_perturbate
void matrix_perturbate(matrix matrix1)
{
	/*!Last Changed 06.08.2007*/
	int i;
	for (i = 0; i < matrix1.row; i++)
		 matrix1.values[i][i] += produce_random_value(0, 0.00001);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testl %r14d, %r14d
jle 0x40788
movq %rsi, %rbx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd 0x69775(%rip), %xmm1    # 0xa9ee0
callq 0x3af6a
movq (%rbx,%r15,8), %rax
addsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x4075f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rax
shrq $0x20, %rax
cmpl %eax, %edi
jne 0x4084d
callq 0x3dae3
movq %rdx, %rdi
testl %eax, %eax
jle 0x40867
movq %rax, %rcx
shrq $0x20, %rcx
movq %rax, %rdx
sarq $0x20, %rdx
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movsd 0x64d4c(%rip), %xmm4    # 0xa5520
movl $0x1, %r8d
xorl %r9d, %r9d
xorpd %xmm0, %xmm0
movq (%rdi,%r9,8), %r11
mulsd (%r11,%r9,8), %xmm4
ucomisd %xmm0, %xmm4
jne 0x407f3
jnp 0x4086f
movq %r9, %r10
incq %r9
cmpq %rsi, %r9
jae 0x40843
movq %r8, %rbx
cmpq %rdx, %r10
jge 0x4083b
movq (%rdi,%rbx,8), %r14
movsd (%r14,%r10,8), %xmm1
divsd (%r11,%r10,8), %xmm1
movq %r10, %r15
movsd (%r14,%r15,8), %xmm2
movsd (%r11,%r15,8), %xmm3
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm2
movsd %xmm2, (%r14,%r15,8)
incq %r15
cmpq %r15, %rcx
jne 0x40819
incq %rbx
cmpq %rsi, %rbx
jne 0x40801
incq %r8
cmpq %rsi, %r9
jne 0x407e1
jmp 0x4086f
leaq 0x69725(%rip), %rdi     # 0xa9f79
leaq 0x697a1(%rip), %rsi     # 0xa9ffc
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
jmp 0x40882
movsd 0x64cb1(%rip), %xmm4    # 0xa5520
movsd %xmm4, 0x8(%rsp)
movl %eax, %esi
callq 0x3a14b
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3faf0
movq %rax, %r15
movq %rdx, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0x3ed5e
movq %rax, %rbx
movq %rdx, %r14
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3dae3
movq %rax, %r13
movq %rdx, %rbp
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x409b7
testl %eax, %eax
je 0x40974
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x3ee2f
movq %rbx, 0x8(%rsp)
movq %rax, %rbx
movq %r14, 0x10(%rsp)
movq %rdx, %r14
movq %r12, %rdi
movl %r15d, %esi
callq 0x3a14b
movq %rbp, %rdi
movl %r13d, %esi
callq 0x3a14b
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %r13
movq %r13, %rdx
movq 0x10(%rsp), %rbp
movq %rbp, %rcx
callq 0x3ee2f
movq %rax, %r15
movq %rdx, %r12
movq %r14, %rdi
movl %ebx, %esi
callq 0x3a14b
movq %rbp, %rdi
movl %r13d, %esi
callq 0x3a14b
movq (%r12), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %r15d, %esi
callq 0x3a14b
movsd 0x8(%rsp), %xmm0
jmp 0x409a8
movq %rbp, %rdi
movl %r13d, %esi
callq 0x3a14b
movq %r14, %rdi
movl %ebx, %esi
callq 0x3a14b
movq %r12, %rdi
movl %r15d, %esi
callq 0x3a14b
leaq 0x67062(%rip), %rdi     # 0xa79fd
callq 0x4090
movsd 0x65400(%rip), %xmm0    # 0xa5da8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edi, %edi
jle 0x41403
movslq %edx, %rax
movslq %ecx, %rcx
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %edx, %edx
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
cmpq %rdx, %rdi
jne 0x413df
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq (%rsi), %rax
cmpq $0x2, %rax
jl 0x414cf
pushq %r15
pushq %r14
pushq %rbx
leal -0x1(%rax), %ecx
movq (%rdi), %rdx
movl $0x1, %edi
xorl %r8d, %r8d
movq %r8, %r9
movsd (%rdx,%r8,8), %xmm0
incq %r8
movq %rdi, %r11
movapd %xmm0, %xmm1
movl %r9d, %r10d
movapd %xmm0, %xmm2
movsd (%rdx,%r11,8), %xmm3
ucomisd %xmm1, %xmm3
cmovael %r11d, %r10d
cmpnlesd %xmm3, %xmm2
movapd %xmm2, %xmm4
andnpd %xmm3, %xmm4
andpd %xmm1, %xmm2
orpd %xmm4, %xmm2
movapd %xmm2, %xmm1
incq %r11
cmpq %r11, %rax
jne 0x4143e
movl %r10d, %r11d
cmpq %r11, %r9
je 0x414be
movslq %r10d, %r10
movsd %xmm0, (%rdx,%r10,8)
movsd %xmm1, (%rdx,%r9,8)
movq (%rsi), %r11
testl %r11d, %r11d
jle 0x414be
movq 0x8(%rsi), %rbx
andl $0x7fffffff, %r11d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq (%rbx,%r14,8), %r15
movsd (%r15,%r9,8), %xmm0
movsd (%r15,%r10,8), %xmm1
movsd %xmm1, (%r15,%r9,8)
movsd %xmm0, (%r15,%r10,8)
incq %r14
cmpq %r14, %r11
jne 0x4149a
incq %rdi
cmpq %rcx, %r8
jne 0x41424
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x41778
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x41770
movq 0x8(%rdi), %r8
movq (%r8,%rdx,8), %r8
xorl %r9d, %r9d
movsd (%rsi,%rdx,8), %xmm0
mulsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x41757
incq %rdx
cmpq %rax, %rdx
jne 0x41748
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x3, %esi
jl 0x41a86
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addl %esi, %eax
leal -0x1(%rsi), %r8d
movl %esi, %r9d
andl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
leaq -0x1(%r9), %r10
leaq (,%r8,8), %r11
leaq (%rdx,%r8,8), %rdx
leaq (,%rax,8), %rbx
cmpq %r10, %rax
jge 0x41a06
movq 0x8(%rdi), %r15
addq %r11, %r15
xorl %r12d, %r12d
movq (%rdx,%r12,8), %r13
movsd -0x8(%r13,%rax,8), %xmm0
movq (%r15,%r12,8), %r13
movsd %xmm0, (%r13,%rax,8)
incq %r12
leal (%r8,%r12), %ebp
cmpl %esi, %ebp
jl 0x419e5
movl (%rcx,%rax,4), %r15d
cmpq %r15, %rax
je 0x41a5c
movslq %r15d, %r15
movq 0x8(%rdi), %r12
movq (%r12,%r15,8), %r15
cmpq %r9, %rax
jge 0x41a4e
movq (%r12,%rax,8), %r12
addq %rbx, %r12
leaq (%r15,%rbx), %r13
xorl %ebp, %ebp
movsd (%r13,%rbp,8), %xmm0
movsd %xmm0, (%r12,%rbp,8)
movq $0x0, (%r13,%rbp,8)
incq %rbp
leal (%rax,%rbp), %r14d
cmpl %esi, %r14d
jl 0x41a2c
movabsq $0x3ff0000000000000, %r14 # imm = 0x3FF0000000000000
movq %r14, (%r15,%rax,8)
leaq -0x1(%rax), %r14
decq %r8
addq $-0x8, %r11
addq $-0x8, %rdx
addq $-0x8, %rbx
cmpq $0x1, %rax
movq %r14, %rax
jg 0x419d6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %rcx
shrq $0x20, %rcx
leaq 0x67739(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %r15d, %edx
movl $0x3, %r9d
callq 0x3a231
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x414d0
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x41779
testl %r15d, %r15d
jle 0x42899
movq 0x8(%rbx), %rcx
movl %r15d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
movq (%rcx,%rsi,8), %r8
movq %rdi, (%r8,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x42889
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x41996
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x41a87
movq %rax, %r14
movq %rax, (%rsp)
testq %rax, %rax
je 0x428da
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4173b
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x41404
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, (%r14)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x40d23
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41404
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, (%r15)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x40d23
movq %r15, %rdi
movq %r14, %rsi
callq 0x41404
movslq (%r14), %rcx
movq (%r15), %rax
testq %rcx, %rcx
jle 0x429aa
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd (%rax,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x4296e
leal -0x1(%rcx), %edx
testl %ecx, %ecx
movsd (%rsp), %xmm3
jle 0x429b2
xorpd %xmm1, %xmm1
xorl %esi, %esi
addsd (%rax,%rsi,8), %xmm1
movapd %xmm1, %xmm2
divsd %xmm0, %xmm2
ucomisd %xmm3, %xmm2
ja 0x429b0
incq %rsi
cmpq %rsi, %rcx
jne 0x4298d
jmp 0x429b2
decl %ecx
movl %ecx, %edx
jmp 0x429b2
movl %esi, %edx
movl %edx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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)
movq %rdx, (%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x92ab7(%rip), %r14     # 0xd5870
movq (%r14), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x674fd(%rip), %rsi     # 0xaa2c8
movl $0x2, %edx
callq 0x3a0e1
movq %rax, 0x8(%rsp)
movq (%r14), %rax
cmpl $0x0, 0x10(%rax)
jle 0x42eee
movq (%rsp), %rax
addl $0xfffffc18, %eax       # imm = 0xFFFFFC18
cltq
leaq (%rax,%rax,4), %r13
shlq $0x3, %r13
addq 0x911af(%rip), %r13     # 0xd3fb0
leaq 0x18(%rsp), %rbp
leaq 0x10(%rsp), %rbx
xorl %r15d, %r15d
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl %r15d, %edx
callq 0x30cbb
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x30cbb
movq (%r14), %rdi
callq 0x12e26
movq %rax, %r12
movq (%r14), %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 *(%r13)
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movl 0x10(%r12), %eax
movq (%r14), %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 0x1376b
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x3e9, %edx            # imm = 0x3E9
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
jne 0x42edb
movq 0x18(%rsp), %rdi
callq 0x2ff55
movq 0x10(%rsp), %rdi
callq 0x2ff55
incq %r15
movq (%r14), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r15
jl 0x42e0e
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x8(%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
leaq 0x92941(%rip), %rbx     # 0xd5870
movq (%rbx), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x67387(%rip), %rsi     # 0xaa2c8
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbp
movq (%rbx), %rax
movslq 0x10(%rax), %rbx
testq %rbx, %rbx
jle 0x42fc4
addq $0x10, %rax
addl $0xfffffc18, %r14d      # imm = 0xFFFFFC18
movslq %r14d, %rcx
leaq (%rcx,%rcx,4), %rcx
leaq 0x9124d(%rip), %rdx     # 0xd41c0
leaq (%rdx,%rcx,8), %r14
addq $0x8, %r14
xorl %r15d, %r15d
movl $0x2, (%rax)
movq (%r12,%r15,8), %rdx
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rcx
movq %rbp, %r8
callq *(%r14)
leaq 0x928ce(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl %ebx, 0x10(%rax)
addq $0x10, %rax
movsd (%rbp), %xmm0
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rcx,%r15,8)
incq %r15
cmpq %rbx, %r15
jb 0x42f7e
movq %rbp, %rdi
callq 0x3a180
leaq 0x9289d(%rip), %r14     # 0xd5870
movq (%r14), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x38695
movq (%r14), %rax
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0x38362
movq 0x10(%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_O3/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 0x67263(%rip), %rdi     # 0xaa296
callq 0x54920
movl %eax, %r15d
movslq %eax, %rbx
leaq (,%rbx,8), %rdi
leaq 0x6728c(%rip), %rsi     # 0xaa2d9
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r13
testl %ebx, %ebx
jle 0x430e2
leal -0x3e8(%r14), %eax
cltq
leaq (%rax,%rax,4), %rbp
shlq $0x3, %rbp
addq 0x90f36(%rip), %rbp     # 0xd3fb0
movl %r15d, %r15d
xorl %ebx, %ebx
movq (%r12), %rdi
callq 0x307e8
movq %rax, 0x10(%rsp)
movl %r14d, %edi
callq 0x595b
testl %eax, %eax
je 0x430a8
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x307e8
jmp 0x430aa
xorl %eax, %eax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *(%rbp)
movq %rax, (%r13,%rbx,8)
movq 0x10(%rsp), %rdi
callq 0x2ff55
movq 0x8(%rsp), %rdi
callq 0x2ff55
incq %rbx
cmpq %rbx, %r15
jne 0x4307f
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_O3/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 0x67178(%rip), %rdi     # 0xaa296
callq 0x54920
movl %eax, %r15d
movslq %eax, %rbp
leaq 0x671c6(%rip), %rdx     # 0xaa2f6
movl $0x4, %esi
movq %rbp, %rdi
movl $0x3, %ecx
callq 0x3a1fc
movq %rax, %r13
leaq 0x92724(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %esi
movl %ebp, %edi
callq 0x3d79d
movq %rax, (%rsp)
movq %rdx, %rbx
testl %ebp, %ebp
jle 0x431b4
addl $0xfffffc18, %r14d      # imm = 0xFFFFFC18
movslq %r14d, %rax
leaq (%rax,%rax,4), %rax
leaq 0x91047(%rip), %rcx     # 0xd41c0
leaq (%rcx,%rax,8), %r14
addq $0x8, %r14
movl %r15d, %r15d
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rdx
movq (%rbx,%rbp,8), %r8
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rcx
callq *(%r14)
movl 0x28(%rsp), %eax
movl %eax, (%r13,%rbp,4)
incq %rbp
cmpq %rbp, %r15
jne 0x43186
leaq 0x67157(%rip), %rdi     # 0xaa312
callq 0x54afc
cltq
leaq 0x91db7(%rip), %rcx     # 0xd4f80
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 0x3a180
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ed51
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq