LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_alloc
matrix matrix_alloc(int row, int col)
{ 
 /*!Last Changed 02.02.2004 added safemalloc*/
 matrix temp;
 temp.values = (double **)safecalloc_2d(sizeof(double *), sizeof(double), row, col, "matrix_alloc", 3);
 temp.row = row; 
 temp.col = col; 
 return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x8eaa9(%rip), %r8      # 0xe6a84
movl $0x8, %esi
movl $0x3, %r9d
movq %rsi, %rdi
callq 0x52fa0
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: cholesky_decomposition
int cholesky_decomposition(matrix a, matrix* b)
{
 /*!Last Changed 27.04.2007*/
 int i, j, k;
 double sum;
 *b = matrix_alloc(a.row, a.col);
 for (i = 0; i < a.row; i++) 
   for (j = i; j < a.row; j++) 
    {
     sum = a.values[i][j];
     for (k = i - 1; k >= 0; k--) 
       sum -= a.values[i][k] * a.values[j][k];
     if (i == j) 
      {
       if (sum <= 0.0)
         return 0;
       b->values[i][i] = sqrt(sum);
      } 
     else 
       b->values[j][i] = sum / b->values[i][i];
    }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x57fc0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5819b
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5818b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x58101
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5809d
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x58144
xorps %xmm0, %xmm0
ucomisd -0x38(%rbp), %xmm0
jb 0x5811f
movl $0x0, -0x4(%rbp)
jmp 0x581a2
movsd -0x38(%rbp), %xmm0
callq 0x42a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x5817b
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
divsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x5817d
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5806e
jmp 0x5818d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5805c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_copy
matrix matrix_copy(matrix source)
{
 int i;
 matrix temp = matrix_alloc(source.row, source.col);
 for (i = 0; i < source.row; i++)
		 memcpy(temp.values[i], source.values[i], source.col * sizeof(double));
 return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x585b2
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x1c(%rbp), %rdx
shlq $0x3, %rdx
callq 0x42b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5857a
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_partial
matrix matrix_partial(matrix a, int rowstart, int rowend, int colstart, int colend)
{
 int i,j;
 matrix result = matrix_alloc(rowend - rowstart + 1, colend - colstart + 1);
 for (i = rowstart; i <= rowend; i++)
   for (j = colstart; j <= colend; j++)
     result.values[i - rowstart][j - colstart] = a.values[i][j];
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
movl %ecx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movl -0x28(%rbp), %edi
subl -0x24(%rbp), %edi
addl $0x1, %edi
movl -0x30(%rbp), %esi
subl -0x2c(%rbp), %esi
addl $0x1, %esi
callq 0x57fc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0x59e85
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0x59e78
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x38(%rbp), %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x59e31
jmp 0x59e7a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x59e23
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_transpose
matrix matrix_transpose(matrix a)
{
 int i, j;
 matrix result = matrix_alloc(a.col, a.row);
 for (i = 0; i < a.row; i++)
   for (j = 0; j < a.col; j++)
     result.values[j][i] = a.values[i][j];
 return result;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x57fc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x59f53
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x59f46
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x59f09
jmp 0x59f48
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x59efa
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: identity
matrix identity(int n)
{
 int i;
 matrix result = matrix_alloc(n, n);
 for (i = 0; i < n; i++)
   result.values[i][i] = 1;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x57fc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x59fc5
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd 0x88063(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x59f95
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_multiply
matrix matrix_multiply(matrix a, matrix b)
{
 int i, j, k;
 matrix result;
 if (!matrix_multiplication_check(a, b))
   return a;
 result = matrix_alloc(a.row, b.col);
 for (i = 0; i < a.row; i++)
   for (k = 0; k < b.col; k++)
    {
     result.values[i][k] = 0;
     for (j = 0; j < a.col; j++)
       result.values[i][k] += a.values[i][j] * b.values[j][k];
    }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5abf0
cmpl $0x0, %eax
jne 0x5a027
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5a11e
movl -0x20(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5a10e
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x5a0fe
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5a0ee
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5a08f
jmp 0x5a0f0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5a064
jmp 0x5a100
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5a051
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: random_matrix
matrix random_matrix(int row, int col, double start, double end)
{
	/*!Last Changed 02.02.2005*/
	int i, j;
	matrix tmp;
	tmp = matrix_alloc(row, col);
 for (i = 0; i < row; i++)
		 for (j = 0; j < col; j++)
				 tmp.values[i][j] = produce_random_value(start, end);
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x57fc0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5a1c5
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5a1b8
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x545a0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5a181
jmp 0x5a1ba
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a172
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: read_matrix_filehandle
matrix read_matrix_filehandle(FILE *infile)
{
 int row, col, i, j;
	matrix tmp;
 if (!infile)
	 {
   tmp = matrix_alloc(1, 1);
			tmp.values[0][0] = 0;
		 return tmp;
	 }
	fscanf(infile, "%d%d", &row, &col);
 tmp = matrix_alloc(row, col);
 for (i = 0; i < row; i++)
		 for (j = 0; j < col; j++)
				 fscanf(infile, "%lf", &(tmp.values[i][j]));
 return(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a22a
movl $0x1, %esi
movl %esi, %edi
callq 0x57fc0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x5a2c8
movq -0x18(%rbp), %rdi
leaq 0x8c6f4(%rip), %rsi     # 0xe6929
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0x4070
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x57fc0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5a2c6
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5a2b9
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x8c521(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5a27d
jmp 0x5a2bb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a26e
jmp 0x5a2c8
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: read_matrix_without_header
matrixptr read_matrix_without_header(char* fname)
{
 /*!Last Changed 25.01.2009*/
 FILE* infile;
 int row, col, i, j;
 matrixptr tmp;
 row = file_length(fname);
 col = number_of_floats_in_file(fname);
 tmp = safemalloc(sizeof(matrix), "read_matrix_without_header", 6);
 *tmp = matrix_alloc(row, col);
 infile = fopen(fname, "r"); 
 for (i = 0; i < row; i++)
   for (j = 0; j < col; j++)
     fscanf(infile, "%lf", &(tmp->values[i][j]));
 fclose(infile);
 return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50f90
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51200
movl %eax, -0x18(%rbp)
movl $0x10, %edi
leaq 0x8c747(%rip), %rsi     # 0xe6a57
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x57fc0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
leaq 0x8de4c(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5a3c6
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5a3b9
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x8c421(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5a379
jmp 0x5a3bb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5a36a
movq -0x10(%rbp), %rdi
callq 0x4250
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: read_matrix
matrix read_matrix(char* fname)
{
	/*!Last Changed 24.03.2006 by Aydin*/
	FILE* infile;
	matrix tmp;
	infile = fopen(fname, "r");
	tmp = read_matrix_filehandle(infile);
	fclose(infile);
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x8ddaf(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5a1e0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4250
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_print
void matrix_print(matrix m)
{
 /*!Last Changed 21.08.2007*/
 int i, j;
 for (i = 0; i < m.row; i++)
  {
   for (j = 0; j < m.col; j++)
     printf("%.6f ", m.values[i][j]);
   printf("\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5a4a5
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5a48c
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x92977(%rip), %rdi     # 0xecdf1
movb $0x1, %al
callq 0x4030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5a456
leaq 0x8b8a8(%rip), %rdi     # 0xe5d3b
movb $0x0, %al
callq 0x4030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a447
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: write_matrix
void write_matrix(char* fname, matrix m, int writeheader)
{
	/*!Last Changed 11.04.2005 added writeheader*/
	/*!Last Changed 02.02.2005*/
	FILE* outfile;
	int i, j;
	char pst[READLINELENGTH];
	outfile = fopen(fname, "w");
	if (!outfile)
		 return;
	if (writeheader)
  	fprintf(outfile, "%d %d\n", m.row, m.col);
	for (i = 0; i < m.row; i++)
	 {
		 for (j = 0; j < m.col; j++)
			 {
     set_precision(pst, NULL, " ");
				 fprintf(outfile, pst, m.values[i][j]);
			 }
			fprintf(outfile, "\n");
	 }
	fclose(outfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x8dce9(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5a4ea
jmp 0x5a595
cmpl $0x0, -0x1c(%rbp)
je 0x5a508
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x885c3(%rip), %rsi     # 0xe2ac4
movb $0x0, %al
callq 0x4280
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5a58c
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5a56f
leaq -0x7a150(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x8ad4d(%rip), %rdx     # 0xe5285
callq 0x53310
movq -0x28(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movb $0x1, %al
callq 0x4280
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5a51e
movq -0x28(%rbp), %rdi
leaq 0x8b7c1(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a50f
movq -0x28(%rbp), %rdi
callq 0x4250
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: initialize_partial_matrix
void initialize_partial_matrix(matrix* M, int startrow, int endrow, int startcol, int endcol, double c)
{
	/*!Last Changed 17.04.2007*/
	int i, j;
	for (i = startrow; i <= endrow; i++)
		 for (j = startcol; j <= endcol; j++)
		  	M->values[i][j] = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x5a60c
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x5a5ff
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5a5ce
jmp 0x5a601
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a5c0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: initialize_matrix
void initialize_matrix(matrix* M, double c)
{
	int i, j;
	for (i = 0; i < M->row; i++)
		 for (j = 0; j < M->col; j++)
		  	M->values[i][j] = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5a678
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5a66b
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5a636
jmp 0x5a66d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a624
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: is_symmetric
BOOLEAN is_symmetric(matrix M)
{
 int i, j;
 if (M.row != M.col)
   return BOOLEAN_FALSE;
 for (i = 0; i < M.row; i++)
   for (j = i + 1; j < M.col; j++)
     if (M.values[i][j] != M.values[j][i])
       return BOOLEAN_FALSE;
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x5a69d
movl $0x0, -0x4(%rbp)
jmp 0x5a717
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5a710
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5a703
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jne 0x5a6ed
jp 0x5a6ed
jmp 0x5a6f6
movl $0x0, -0x4(%rbp)
jmp 0x5a717
jmp 0x5a6f8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5a6b5
jmp 0x5a705
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5a6a4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: assign_partial_random_weights
void assign_partial_random_weights(matrix* M, int startrow, int endrow, int startcol, int endcol, double randrange)
{
	/*!Last Changed 17.04.2007*/
	int i, j;
	for (i = startrow; i <= endrow; i++)
		 for (j = startcol; j <= endcol; j++)
			  M->values[i][j] = (((double) myrand() / RANDOM_MAX) * randrange * 2) - randrange;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x5a7d2
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x5a7c2
movb $0x0, %al
callq 0x54550
cvtsi2sd %eax, %xmm0
movsd 0x8789f(%rip), %xmm1    # 0xe2010
divsd %xmm1, %xmm0
mulsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5a756
jmp 0x5a7c4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a744
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5a88e
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5a87e
movb $0x0, %al
callq 0x54550
cvtsi2sd %eax, %xmm0
movsd 0x877e3(%rip), %xmm1    # 0xe2010
divsd %xmm1, %xmm0
mulsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5a80e
jmp 0x5a880
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a7f8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
movl %ecx, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x5a95b
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x5a8f6
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5a8f4
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a8d0
jmp 0x5a8f6
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
shlq $0x3, %rsi
movl -0x24(%rbp), %edx
callq 0x52d10
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5a959
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5a957
movslq -0x28(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x8c13f(%rip), %rsi     # 0xe6a72
movl $0x1c, %edx
callq 0x52d70
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a91c
jmp 0x5a959
jmp 0x5a95b
movl -0x1c(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x5a9aa
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5a9a8
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movslq -0x28(%rbp), %rsi
shlq $0x3, %rsi
movl -0x28(%rbp), %edx
callq 0x52d10
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a96a
jmp 0x5a9aa
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5aa3d
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5aa30
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5a9f6
jmp 0x5aa32
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a9e4
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5aab1
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5aaa4
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5aa66
jmp 0x5aaa6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5aa54
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5ab26
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5ab19
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd 0x8750f(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5aae1
jmp 0x5ab1b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5aacf
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5ab91
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5ab84
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5ab51
jmp 0x5ab86
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5ab3f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_addition_check
BOOLEAN matrix_addition_check(matrix a, matrix b)
{
 /*!Last Changed 26.12.2006*/
 if (a.row != b.row || a.col != b.col)
  {
   printf(m1363);
   return BOOLEAN_FALSE;
  }
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x5abc8
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x5abdf
leaq 0x8bec2(%rip), %rdi     # 0xe6a91
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x5abe6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_multiplication_check
int matrix_multiplication_check(matrix a, matrix b)
{
 /*!Last Changed 26.12.2006*/
 if (a.col != b.row)
  {
   printf(m1364);
   return 0;
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x5ac27
leaq 0x8bf09(%rip), %rdi     # 0xe6b20
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x5ac2e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0x5aba0
cmpl $0x0, %eax
jne 0x5ac73
jmp 0x5ace3
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5ace3
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5acd6
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5ac8c
jmp 0x5acd8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ac7a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5aba0
cmpl $0x0, %eax
jne 0x5ad37
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5addf
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5adcf
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5adc2
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5ad70
jmp 0x5adc4
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5ad61
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0x5aba0
cmpl $0x0, %eax
jne 0x5ae23
jmp 0x5ae97
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5ae97
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5ae8a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5ae3c
jmp 0x5ae8c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ae2a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5aba0
cmpl $0x0, %eax
jne 0x5aee7
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5af8f
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5af7f
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5af72
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5af20
jmp 0x5af74
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5af11
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x58550
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5b073
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x5afa0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5b04f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_cell_power
void matrix_cell_power(matrix* a, double power)
{
 /*!Last Changed 17.01.2008*/
 int i, j;
 for (i = 0; i < a->row; i++)
   for (j = 0; j < a->col; j++)
     a->values[i][j] = pow(a->values[i][j], power);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5b11a
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5b10d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x4290
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b0ba
jmp 0x5b10f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b0a8
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5b1b3
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5b1a3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5b141
jmp 0x5b1a5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5b12f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5b22e
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5b1f9
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5b2a9
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5b29c
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b26a
jmp 0x5b29e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b25b
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x5b2ef
leaq 0x8b8db(%rip), %rdi     # 0xe6bb2
leaq 0x8b8fc(%rip), %rsi     # 0xe6bda
movb $0x0, %al
callq 0x4030
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5b332
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5b328
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5b2f6
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5b3d0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b39e
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
leaq 0x8b7e0(%rip), %rdx     # 0xe6be0
movl $0x2, %ecx
callq 0x52f40
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5b46b
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5b45e
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b424
jmp 0x5b460
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b415
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5b4a0
cvtsi2sdl -0x10(%rbp), %xmm1
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b472
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)