LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: assignTwoDimRandomWeights
void assignTwoDimRandomWeights(matrix* M, double randrange)
{
	int i, j;
	for (i = 0; i < M->row; i++)
		 for (j = 0; j < M->col; j++)
			  M->values[i][j] = (((double) myrand() / RANDOM_MAX) * randrange * 2) - randrange;
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x3e403
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movapd 0x64e47(%rip), %xmm2    # 0xa31d0
xorpd %xmm0, %xmm2
xorl %r14d, %r14d
movapd %xmm0, 0x10(%rsp)
movapd %xmm2, (%rsp)
cmpl $0x0, 0x4(%rbx)
jle 0x3e3ef
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x39f18
movsd 0x64165(%rip), %xmm3    # 0xa2518
movapd (%rsp), %xmm2
movapd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
addsd %xmm2, %xmm1
movsd %xmm1, (%rax,%r15,8)
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x3e3a4
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x3e39b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: reallocate_matrix
matrix reallocate_matrix(matrix M, int newRow, int newColumn)
{
	/*!Last Changed 17.04.2007*/
 int i;
	if (M.row != newRow)
	 {
		 if (M.row > newRow)
     for (i = newRow; i < M.row; i++)
       safe_free(M.values[i]);
   M.values = alloc(M.values, newRow * sizeof(double *), newRow);
			if (M.row < newRow)
     for (i = M.row; i < newRow; i++)
       M.values[i] = safemalloc(newColumn * sizeof(double), "reallocate_matrix", 28);
	 }
	if (M.col != newColumn)
   for (i = 0; i < M.row; i++)
     M.values[i] = alloc(M.values[i], newColumn * sizeof(double), newColumn);
 M.row = newRow;
	M.col = newColumn;
	return M;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, %rax
shrq $0x20, %rax
movl %r15d, %r13d
subl %edx, %r13d
movl %edx, 0x4(%rsp)
je 0x3e4b7
movq %rax, 0x10(%rsp)
movq %rbp, 0x8(%rsp)
movslq %edx, %r12
jle 0x3e457
leaq (%r14,%r12,8), %rbx
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %rdi
callq 0x39194
incq %rbp
cmpl %ebp, %r13d
jne 0x3e446
shlq $0x3, %r12
movq %r14, %rdi
movq %r12, %rsi
movl 0x4(%rsp), %ebx
movl %ebx, %edx
callq 0x390c8
movq %rax, %r14
cmpl %ebx, %r15d
jge 0x3e4ad
movslq 0x8(%rsp), %r12
shlq $0x3, %r12
movslq %r15d, %rax
leaq (%r14,%rax,8), %rbp
movl %ebx, %r13d
subl %r15d, %r13d
xorl %ebx, %ebx
movq %r12, %rdi
leaq 0x68a24(%rip), %rsi     # 0xa6eba
movl $0x1c, %edx
callq 0x390f5
movq %rax, (%rbp,%rbx,8)
incq %rbx
cmpl %ebx, %r13d
jne 0x3e48c
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %rax
cmpl %ebp, %eax
sete %al
testl %r15d, %r15d
setle %cl
orb %al, %cl
jne 0x3e4f0
movslq %ebp, %r12
shlq $0x3, %r12
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x390c8
movq %rax, (%r14,%rbx,8)
incq %rbx
cmpq %rbx, %r15
jne 0x3e4d6
shlq $0x20, %rbp
movl 0x4(%rsp), %eax
orq %rbp, %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_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_multiply_constant
void matrix_multiply_constant(matrix *a, double cons)
{ 
 int i, j; 
 for (i = 0; i < a->row; i++)
   for (j = 0; j < a->col; j++)     
     a->values[i][j] *= cons;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3e549
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x3e541
movq 0x8(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x3e529
incq %rdx
cmpq %rax, %rdx
jne 0x3e51a
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_divide_constant
void matrix_divide_constant(matrix *a, double cons)
{
 int i, j;
 for (i = 0; i < a->row; i++)
   for (j = 0; j < a->col; j++)     
     a->values[i][j] /= cons;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3e586
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x3e57e
movq 0x8(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x3e566
incq %rdx
cmpq %rax, %rdx
jne 0x3e557
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_ones
void matrix_ones(matrix *a)
{
 int i, j; 
 for (i = 0; i < a->row; i++)   
   for (j = 0; j < a->col; j++)     
     a->values[i][j] = 1;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3e5c1
movl 0x4(%rdi), %ecx
xorl %edx, %edx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
testl %ecx, %ecx
jle 0x3e5b9
movq 0x8(%rdi), %r8
movq (%r8,%rdx,8), %r8
xorl %r9d, %r9d
movq %rsi, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x3e5ad
incq %rdx
cmpq %rax, %rdx
jne 0x3e59e
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_zeros
void matrix_zeros(matrix *a)
{
 int i, j; 
 for (i = 0; i < a->row; i++)   
   for (j = 0; j < a->col; j++)     
     a->values[i][j] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rdi), %r15
testq %r15, %r15
jle 0x3e603
movq %rdi, %rbx
movl 0x4(%rdi), %r12d
movq %r12, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r12d, %r12d
jle 0x3e5fb
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x4050
incq %r13
cmpq %r13, %r15
jne 0x3e5e4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_add
void matrix_add(matrix *a, matrix b)
{
 int i, j; 
 if (!matrix_addition_check(*a, b))
   return;
 for (i = 0; i < a->row; i++)
   for (j = 0; j < a->col; j++)
     a->values[i][j] += b.values[i][j];
}

// Assembly:
cmpq %rsi, (%rdi)
jne 0x3e694
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3e693
movl 0x4(%rdi), %ecx
xorl %esi, %esi
testl %ecx, %ecx
jle 0x3e68b
movq (%rdx,%rsi,8), %r8
movq 0x8(%rdi), %r9
movq (%r9,%rsi,8), %r9
xorl %r10d, %r10d
movsd (%r8,%r10,8), %xmm0
addsd (%r9,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x3e671
incq %rsi
cmpq %rax, %rsi
jne 0x3e65e
retq
leaq 0x68a78(%rip), %rdi     # 0xa7113
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_sum
matrix matrix_sum(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, %r14
movq %rdi, %rbx
cmpq %rdx, %rdi
jne 0x3e727
movq %rcx, %r15
movq %rbx, %r12
shrq $0x20, %r12
leaq 0x68808(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %r12d, %ecx
movl $0x3, %r9d
callq 0x39245
testl %ebx, %ebx
jle 0x3e722
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r12d, %r12d
jle 0x3e71a
movq (%r14,%rdx,8), %rsi
movq (%r15,%rdx,8), %rdi
movq (%rax,%rdx,8), %r8
xorl %r9d, %r9d
movsd (%rsi,%r9,8), %xmm0
addsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %r12
jne 0x3e700
incq %rdx
cmpq %rcx, %rdx
jne 0x3e6ec
movq %rax, %r14
jmp 0x3e733
leaq 0x689e5(%rip), %rdi     # 0xa7113
callq 0x4090
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_subtract
void matrix_subtract(matrix *a, matrix b)
{
 int i, j;
 if (!matrix_addition_check(*a, b))
   return; 
 for (i = 0; i < a->row; i++)
   for (j = 0; j < a->col; j++)
     a->values[i][j] -= b.values[i][j];
}

// Assembly:
cmpq %rsi, (%rdi)
jne 0x3e78d
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3e78c
movl 0x4(%rdi), %ecx
xorl %esi, %esi
testl %ecx, %ecx
jle 0x3e784
movq (%rdx,%rsi,8), %r8
movq 0x8(%rdi), %r9
movq (%r9,%rsi,8), %r9
xorl %r10d, %r10d
movsd (%r9,%r10,8), %xmm0
subsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x3e76a
incq %rsi
cmpq %rax, %rsi
jne 0x3e757
retq
leaq 0x6897f(%rip), %rdi     # 0xa7113
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
cmpq %rdx, %rdi
jne 0x3e820
movq %rcx, %r15
movq %rbx, %r12
shrq $0x20, %r12
leaq 0x6870f(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %r12d, %ecx
movl $0x3, %r9d
callq 0x39245
testl %ebx, %ebx
jle 0x3e81b
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r12d, %r12d
jle 0x3e813
movq (%r14,%rdx,8), %rsi
movq (%r15,%rdx,8), %rdi
movq (%rax,%rdx,8), %r8
xorl %r9d, %r9d
movsd (%rsi,%r9,8), %xmm0
subsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %r12
jne 0x3e7f9
incq %rdx
cmpq %rcx, %rdx
jne 0x3e7e5
movq %rax, %r14
jmp 0x3e82c
leaq 0x688ec(%rip), %rdi     # 0xa7113
callq 0x4090
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3dc8b
movq %rax, %r14
movq %rdx, %r15
movl (%rbx), %esi
movq 0x8(%rbx), %rdi
callq 0x3915f
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ca3c
movq %rax, %r12
movq %rdx, %r13
cmpl $0x2, %ebx
jl 0x3e8d1
decl %ebx
movq %r15, (%rsp)
movq %r14, %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq (%rsp), %rcx
callq 0x3dc8b
movq %rax, %rbp
movq %rdx, %r14
movq %r13, %rdi
movl %r12d, %esi
callq 0x3915f
movq %rbp, %r12
movq %r14, %r13
decl %ebx
jne 0x3e8a2
jmp 0x3e8d7
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_O1/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:
cmpl $0x0, (%rdi)
jle 0x3e956
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movsd %xmm0, 0x8(%rsp)
cmpl $0x0, 0x4(%rbx)
jle 0x3e942
xorl %r15d, %r15d
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
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x3e90f
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x3e906
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e993
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x3e98b
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 0x3e973
incq %rdx
cmpq %rax, %rdx
jne 0x3e964
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68529(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ebp, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %rdx
movl %ebp, %ecx
testl %ebp, %ebp
jle 0x3e9dd
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm0
movq (%rdx,%rax,8), %rsi
movsd %xmm0, (%rsi,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x3e9c7
movq %rcx, %rax
shlq $0x20, %rax
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ea27
movq %rdi, %rax
shrq $0x20, %rax
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
testl %eax, %eax
jle 0x3ea1e
movq (%rsi,%rcx,8), %rdx
xorl %r8d, %r8d
addsd (%rdx,%r8,8), %xmm0
incq %r8
cmpq %r8, %rax
jne 0x3ea10
incq %rcx
cmpq %rdi, %rcx
jne 0x3ea05
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ea5a
testl %edi, %edi
jle 0x3ea6f
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 0x3ea47
jmp 0x3ea73
leaq 0x68478(%rip), %rdi     # 0xa6ed9
leaq 0x68499(%rip), %rsi     # 0xa6f01
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3eab3
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 0x3eaa1
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68433(%rip), %rdx     # 0xa6f07
movl $0x8, %esi
movl $0x2, %ecx
callq 0x39210
testl %ebx, %ebx
jle 0x3eb1b
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r15d, %r15d
jle 0x3eb13
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 0x3eafc
incq %rdx
cmpq %rcx, %rdx
jne 0x3eaf1
testl %r15d, %r15d
jle 0x3eb3f
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 0x3eb29
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x683ad(%rip), %rdx     # 0xa6f07
movl $0x8, %esi
movq %r15, %rdi
movl $0x2, %ecx
callq 0x39210
testl %r15d, %r15d
jle 0x3ebcd
movq %r14, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %edx, %edx
movq $0x0, (%rax,%rdx,8)
cmpl $0x2, %ecx
jl 0x3ebc5
movq (%rbx,%rdx,8), %rsi
movsd (%rax,%rdx,8), %xmm0
movl $0x1, %edi
cvttsd2si %xmm0, %r8d
movslq %r8d, %r8
movsd (%rsi,%rdi,8), %xmm1
ucomisd (%rsi,%r8,8), %xmm1
jbe 0x3ebbd
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x3eb9c
incq %rdx
cmpq %r14, %rdx
jne 0x3eb81
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3eab7
movq %rax, %rbx
movq %r15, %rdi
sarq $0x20, %rdi
leaq 0x6831b(%rip), %rdx     # 0xa6f1e
movl $0x8, %esi
movl $0x2, %ecx
callq 0x39210
movq %rax, %r14
testl %r15d, %r15d
jle 0x3ec59
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %r13d, %r13d
jle 0x3ec51
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 0x3ec2f
incq %rcx
cmpq %rax, %rcx
jne 0x3ec24
testl %r13d, %r13d
jle 0x3eca6
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 0x3ec89
sqrtsd %xmm0, %xmm0
jmp 0x3ec98
callq 0x4300
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
movsd %xmm0, (%r14,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x3ec73
movq %rbx, %rdi
callq 0x39194
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ece2
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 0x3ecd4
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r12
shrq $0x20, %r12
movslq %ebx, %r15
leaq 0x6822e(%rip), %rdx     # 0xa6f33
movl $0x8, %esi
movq %r15, %rdi
movl $0x2, %ecx
callq 0x39210
testl %r15d, %r15d
jle 0x3ed50
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r12d, %r12d
jle 0x3ed48
movq (%r14,%rdx,8), %rsi
movsd (%rax,%rdx,8), %xmm0
xorl %edi, %edi
addsd (%rsi,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdi
cmpq %rdi, %r12
jne 0x3ed36
incq %rdx
cmpq %rcx, %rdx
jne 0x3ed26
testl %ebx, %ebx
jle 0x3ed7a
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %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 0x3ed64
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3edd4
movq %rdi, %rax
shrq $0x20, %rax
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %eax, %eax
jle 0x3edc3
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 0x3edab
jmp 0x3edc7
movapd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rdi, %rcx
jne 0x3eda0
retq
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3eeb7
movq %rdi, %r15
shrq $0x20, %rbx
cmpl $0x0, (%rdi)
jle 0x3eea9
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 0x3ee9e
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 0x3ee8c
incq %r12
movslq (%r15), %rax
cmpq %rax, %r12
jl 0x3ee51
addl %ebx, 0x4(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6819b(%rip), %rdi     # 0xa7059
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/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 0x3ef8f
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movslq (%r15), %rsi
movq %rax, (%rsp)
movslq %eax, %rbx
addq %rbx, %rsi
shlq $0x3, %rsi
callq 0x42d0
movq %rax, 0x8(%r15)
testl %ebx, %ebx
jle 0x3ef79
movq (%rsp), %rbp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %ebx, %ebx
leaq 0x68021(%rip), %r12     # 0xa6f47
movslq 0x4(%r15), %rdi
shlq $0x3, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x390f5
movslq (%r15), %rdx
movslq %ebx, %rcx
addq %rdx, %rcx
movq 0x8(%r15), %rdx
movq %rax, (%rdx,%rcx,8)
testl %r13d, %r13d
jle 0x3ef71
movq (%r14,%rbx,8), %rax
movq 0x8(%r15), %rdx
movq (%rdx,%rcx,8), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x3ef5f
incq %rbx
cmpq %rbp, %rbx
jne 0x3ef26
movq (%rsp), %rax
addl %eax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68120(%rip), %rdi     # 0xa70b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/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 0x3f030
movq %rsi, %r14
xorl %r12d, %r12d
cmpl $0x0, 0x4(%rbx)
movl $0x0, %r13d
jle 0x3f007
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %r14, %rdi
movl %r15d, %esi
callq 0x3113e
testl %eax, %eax
je 0x3effb
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 0x3efd2
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 0x3efc0
jmp 0x3f030
movl %r13d, 0x4(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x67e6e(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %r14d, %edx
movl %r14d, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3eab7
movq %rax, (%r13)
testl %ebx, %ebx
jle 0x3f0e9
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r14d, %r14d
jle 0x3f0e1
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 0x3f0ab
incq %rdi
cmpq %r14, %rdi
jne 0x3f0a4
incq %rdx
cmpq %rcx, %rdx
jne 0x3f099
testl %r14d, %r14d
jle 0x3f11e
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 0x3f100
incq %rax
cmpq %r14, %rax
jne 0x3f0fa
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_O1/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
movl %r9d, %r12d
movq %r8, %r14
movq %rcx, %r15
movl %edx, %r13d
callq 0x3ca3c
movq %rdx, %rbx
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ca3c
movq %rax, %r14
movq %rdx, %r15
movslq 0x8(%rsp), %rbp
testq %rbp, %rbp
jle 0x3f1bb
leal -0x1(%r13), %eax
cvtsi2sd %eax, %xmm0
movl 0xc(%rsp), %eax
xorl %ecx, %ecx
testl %eax, %eax
jle 0x3f1b3
movq (%rbx,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3f19d
incq %rcx
cmpq %rbp, %rcx
jne 0x3f193
testl %r14d, %r14d
jle 0x3f206
leal -0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq %r14, %rax
shrq $0x20, %rax
movl %r14d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %eax, %eax
jle 0x3f1fe
movq (%r15,%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 0x3f1e8
incq %rdx
cmpq %rcx, %rdx
jne 0x3f1de
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3e64c
testl %ebp, %ebp
jle 0x3f256
leal (%r12,%r13), %eax
addl $-0x2, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movl 0xc(%rsp), %eax
xorl %ecx, %ecx
testl %eax, %eax
jle 0x3f24e
movq (%rbx,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3f238
incq %rcx
cmpq %rbp, %rcx
jne 0x3f22e
movq %r15, %rdi
movl %r14d, %esi
callq 0x3915f
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f03e
movq %rax, 0x8(%rsp)
movq %rdx, %r14
movq (%r15), %rdi
callq 0x39194
testl %r12d, %r12d
jle 0x3f366
leaq -0x1(%r12), %r15
xorl %ebx, %ebx
xorpd %xmm2, %xmm2
leaq 0x1(%rbx), %rbp
cmpq %r12, %rbp
jae 0x3f348
movq %rbx, %r13
movq (%r14,%rbx,8), %rax
movsd (%rax,%rbx,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x3f2dd
jnp 0x3f301
movq 0x8(%r14,%r13,8), %rcx
movsd 0x8(%rcx,%r13,8), %xmm1
ucomisd %xmm2, %xmm1
jne 0x3f2f1
jnp 0x3f301
mulsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x3f30c
sqrtsd %xmm0, %xmm0
jmp 0x3f315
movq $0x0, 0x8(%rax,%r13,8)
jmp 0x3f32b
callq 0x4300
xorpd %xmm2, %xmm2
movq (%r14,%rbx,8), %rax
movsd 0x8(%rax,%r13,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rax,%r13,8)
movq (%r14,%rbx,8), %rax
movsd 0x8(%rax,%r13,8), %xmm0
movq 0x8(%r14,%r13,8), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %r13
cmpq %r13, %r15
jne 0x3f2cc
movq (%r14,%rbx,8), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%rbx,8)
movq %rbp, %rbx
cmpq %r12, %rbp
jne 0x3f2c0
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_O1/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 0x3f3a1
movq %r14, %rax
shrq $0x20, %rax
cmpl %eax, 0x4(%r15)
je 0x3f3ad
leaq 0x67d6b(%rip), %rdi     # 0xa7113
callq 0x4090
testl %r14d, %r14d
jle 0x3f3e3
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 0x3f3c7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f430
movq %rsi, %rbx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd 0x67a5d(%rip), %xmm1    # 0xa6e70
callq 0x39f62
movq (%rbx,%r15,8), %rax
addsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x3f407
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f4f5
callq 0x3ca3c
movq %rdx, %rdi
testl %eax, %eax
jle 0x3f50f
movq %rax, %rcx
shrq $0x20, %rcx
movq %rax, %rdx
sarq $0x20, %rdx
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movsd 0x630a4(%rip), %xmm4    # 0xa2520
movl $0x1, %r8d
xorl %r9d, %r9d
xorpd %xmm0, %xmm0
movq (%rdi,%r9,8), %r11
mulsd (%r11,%r9,8), %xmm4
ucomisd %xmm0, %xmm4
jne 0x3f49b
jnp 0x3f517
movq %r9, %r10
incq %r9
cmpq %rsi, %r9
jae 0x3f4eb
movq %r8, %rbx
cmpq %rdx, %r10
jge 0x3f4e3
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 0x3f4c1
incq %rbx
cmpq %rsi, %rbx
jne 0x3f4a9
incq %r8
cmpq %rsi, %r9
jne 0x3f489
jmp 0x3f517
leaq 0x679dd(%rip), %rdi     # 0xa6ed9
leaq 0x67a59(%rip), %rsi     # 0xa6f5c
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
jmp 0x3f52a
movsd 0x63009(%rip), %xmm4    # 0xa2520
movsd %xmm4, 0x8(%rsp)
movl %eax, %esi
callq 0x3915f
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movq %r9, %r13
movq %r8, %rbp
callq 0x3e799
movq %rax, %r15
movq %rdx, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0x3dbba
movq %rax, %rbx
movq %rdx, %r14
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3ca3c
movq %rax, %r13
movq %rdx, %rbp
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x3f648
testl %eax, %eax
je 0x3f605
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x3dc8b
movq %rax, %r13
movq %rdx, %rbp
movq %r12, %rdi
movl %r15d, %esi
callq 0x3915f
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0x3915f
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3dc8b
movq %rax, %r15
movq %rdx, %r12
movq %rbp, %rdi
movl %r13d, %esi
callq 0x3915f
movq %r14, %rdi
movl %ebx, %esi
callq 0x3915f
movq (%r12), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movl %r15d, %esi
callq 0x3915f
movsd (%rsp), %xmm0
jmp 0x3f639
movq %rbp, %rdi
movl %r13d, %esi
callq 0x3915f
movq %r14, %rdi
movl %ebx, %esi
callq 0x3915f
movq %r12, %rdi
movl %r15d, %esi
callq 0x3915f
leaq 0x65391(%rip), %rdi     # 0xa49bd
callq 0x4090
movsd 0x6376f(%rip), %xmm0    # 0xa2da8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4013b
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 0x40117
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x40207
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 0x40176
movl %r10d, %r11d
cmpq %r11, %r9
je 0x401f6
movslq %r10d, %r10
movsd %xmm0, (%rdx,%r10,8)
movsd %xmm1, (%rdx,%r9,8)
movq (%rsi), %r11
testl %r11d, %r11d
jle 0x401f6
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 0x401d2
incq %rdi
cmpq %rcx, %r8
jne 0x4015c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x40436
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x4042e
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 0x40415
incq %rdx
cmpq %rax, %rdx
jne 0x40406
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4074b
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 0x406c2
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 0x406a1
movl (%rcx,%rax,4), %r15d
cmpq %r15, %rax
je 0x40721
movslq %r15d, %r15
cmpq %r9, %rax
jge 0x4070b
movq 0x8(%rdi), %r13
movq (%r13,%rax,8), %r12
addq %rbx, %r12
movq (%r13,%r15,8), %r13
addq %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 0x406e9
movq 0x8(%rdi), %r14
movq (%r14,%r15,8), %r14
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
movq %r15, (%r14,%rax,8)
leaq -0x1(%rax), %r14
decq %r8
addq $-0x8, %r11
addq $-0x8, %rdx
addq $-0x8, %rbx
cmpq $0x1, %rax
movq %r14, %rax
jg 0x40692
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, (%rsp)
leaq 0x65a16(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %r15d, %edx
movl $0x3, %r9d
callq 0x39245
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x40208
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x40437
testl %r15d, %r15d
jle 0x4151c
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 0x4150c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x40652
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4074c
movq %rax, (%rsp)
testq %rax, %rax
je 0x4155f
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x403f9
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4013c
jmp 0x41562
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f9d7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4013c
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x8(%rsp)
movq %rcx, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq $0x0, (%r15)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3f9d7
movq %r15, %rdi
movq %r14, %rsi
callq 0x4013c
movslq (%r14), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
jle 0x41603
movq (%rsp), %rcx
xorl %edx, %edx
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x415f6
leal -0x1(%rax), %ecx
testl %eax, %eax
movsd 0x8(%rsp), %xmm3
jle 0x41639
movq (%rsp), %rsi
xorpd %xmm1, %xmm1
xorl %edx, %edx
addsd (%rsi,%rdx,8), %xmm1
movapd %xmm1, %xmm2
divsd %xmm0, %xmm2
ucomisd %xmm3, %xmm2
ja 0x41637
incq %rdx
cmpq %rdx, %rax
jne 0x4161a
jmp 0x41639
movl %edx, %ecx
movl %ecx, (%rbx)
movq (%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)