LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_qdaclass
void* load_model_qdaclass(FILE* infile, Datasetptr d)
{
 /*!Last Changed 05.08.2007*/
 Model_qdaclassptr m;
 int i;
 m = safemalloc(sizeof(Model_qdaclass), "load_model_qdaclass", 3);
 m->w0 = load_array(infile, d->classno);
 m->priors = load_array(infile, d->classno);
 m->W = safemalloc(d->classno * sizeof(matrix), "load_model_qdaclass", 5);
 for (i = 0; i < d->classno; i++)
   m->W[i] = load_matrix(infile, d->multifeaturecount - 1, d->multifeaturecount - 1);
 m->w = safemalloc(d->classno * sizeof(matrix), "load_model_qdaclass", 8);
 for (i = 0; i < d->classno; i++)
   m->w[i] = load_matrix(infile, 1, d->multifeaturecount - 1);
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6d880(%rip), %r12     # 0xa9d87
movl $0x20, %edi
movq %r12, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r15
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b5a4
movq %rax, 0x10(%r15)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b5a4
movq %rax, 0x18(%r15)
movslq 0x10(%rbx), %rdi
shlq $0x4, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, (%r15)
movslq 0x10(%rbx), %rdi
testq %rdi, %rdi
jle 0x3c593
movl $0x8, %r12d
xorl %r13d, %r13d
movq (%r15), %rbp
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3b518
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
movslq 0x10(%rbx), %rdi
addq $0x10, %r12
cmpq %rdi, %r13
jl 0x3c564
shlq $0x4, %rdi
leaq 0x6d7e9(%rip), %rsi     # 0xa9d87
movl $0x8, %edx
callq 0x3a0e1
movq %rax, 0x8(%r15)
cmpl $0x0, 0x10(%rbx)
jle 0x3c5ee
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rbp
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3b518
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
movslq 0x10(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x3c5bb
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_ldaclass
void* load_model_ldaclass(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 Model_ldaclassptr m;
 int i;
 m = safemalloc(sizeof(Model_ldaclass), "load_model_ldaclass", 2);
 fscanf(infile, "%d %d", &(m->newfeaturecount), &(m->oldfeaturecount));
 m->w0 = load_array(infile, d->classno);
 m->w = safemalloc(d->classno * sizeof(matrix), "load_model_ldaclass", 5);
 for (i = 0; i < d->classno; i++)
   m->w[i] = load_matrix(infile, 1, m->newfeaturecount - 1);
 m->eigenvectors = load_matrix(infile, d->multifeaturecount - 1, d->multifeaturecount - 1);
 m->eigenvalues = NULL;
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x6d783(%rip), %r12     # 0xa9d9b
movl $0x30, %edi
movq %r12, %rsi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x4(%rax), %rcx
leaq 0x6c326(%rip), %rsi     # 0xa895e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%r15), %esi
movq %r14, %rdi
callq 0x3b5a4
movq %rax, 0x8(%rbx)
movslq 0x10(%r15), %rdi
shlq $0x4, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, 0x10(%rbx)
cmpl $0x0, 0x10(%r15)
jle 0x3c6ad
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rbp
movl (%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3b518
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
movslq 0x10(%r15), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x3c67e
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3b518
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_condition
Decisionconditionptr load_condition(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 Decisionconditionptr condition;
 condition = safemalloc(sizeof(Decisioncondition), "load_condition", 2);
 fscanf(infile, "%d %c", &(condition->featureindex), &(condition->comparison));
 if (condition->featureindex >= 0)
  {
   if (condition->comparison != '*')
     fscanf(infile, "%lf", &(condition->value));
   else
    {
     fscanf(infile, "%lf", &(condition->lowerlimit));
     fscanf(infile, "%lf", &(condition->upperlimit));
    }
  }
 else
  {
   fscanf(infile, "%lf", &(condition->w0));
   condition->w = load_matrix(infile, 1, d->multifeaturecount - 1);
  }
 condition->next = NULL;
 return condition;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x6d518(%rip), %rsi     # 0xa9dbe
movl $0x70, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x4(%rax), %r12
leaq 0x6d50a(%rip), %rsi     # 0xa9dcd
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
cmpl $0x0, (%rbx)
js 0x3c906
cmpb $0x2a, (%r12)
jne 0x3c93e
leaq 0x18(%rbx), %rdx
leaq 0x6d396(%rip), %r15     # 0xa9c80
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4070
movq %rbx, %rdx
addq $0x10, %rdx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x3c94f
movq %rbx, %rdx
addq $0x30, %rdx
leaq 0x6d36c(%rip), %rsi     # 0xa9c80
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3b518
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
jmp 0x3c956
movq %rbx, %rdx
addq $0x8, %rdx
leaq 0x6d334(%rip), %rsi     # 0xa9c80
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq $0x0, 0x48(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_rule
Decisionruleptr load_rule(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 int i;
 Decisionruleptr rule;
 Decisionconditionptr tmp, tmpbefore;
 rule = safemalloc(sizeof(Decisionrule), "load_rule", 4);
 fscanf(infile, "%d%d%d%d", &(rule->classno), &(rule->decisioncount), &(rule->falsepositives), &(rule->covered));
 rule->counts = load_array_int(infile, d->classno);
 rule->start = load_condition(infile, d);
 tmpbefore = rule->start;
 tmp = rule->start;
 for (i = 1; i < rule->decisioncount; i++)
  {
   tmp = load_condition(infile, d);
   tmpbefore->next = tmp;
   tmpbefore = tmp;
  }
 rule->end = tmp;
 rule->next = NULL;
 return rule;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6d44e(%rip), %rsi     # 0xa9dd3
movl $0x38, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x28(%rax), %r12
leaq 0x8(%rax), %r8
leaq 0x4(%rax), %r9
leaq 0x6d433(%rip), %rsi     # 0xa9ddd
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b610
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c891
movq %rax, %r13
movq %rax, 0x18(%r15)
cmpl $0x2, 0x28(%r15)
jl 0x3ca03
movl $0x1, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c891
movq %rax, 0x48(%r13)
incl %ebp
movq %rax, %r13
cmpl (%r12), %ebp
jl 0x3c9e7
jmp 0x3ca06
movq %r13, %rax
movq %rax, 0x20(%r15)
movq $0x0, 0x30(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_ripper
void* load_model_ripper(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 int i;
 Rulesetptr m;
 Decisionruleptr tmp, tmpbefore;
 m = safemalloc(sizeof(Ruleset), "load_model_ripper", 4);
 fscanf(infile, "%d%d", &(m->defaultclass), &(m->rulecount));
 m->counts = load_array_int(infile, d->classno);
 if (m->rulecount > 0)
  {
   m->start = load_rule(infile, d);
   tmpbefore = m->start;
   tmp = m->start;
   for (i = 1; i < m->rulecount; i++)
    {
     tmp = load_rule(infile, d);
     tmpbefore->next = tmp;
     tmpbefore = tmp;
    }
   m->end = tmp;
  }
 else
  {
   m->start = NULL;
   m->end = NULL;
  }
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x6d3aa(%rip), %rsi     # 0xa9de6
movl $0x28, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x14(%rax), %rdx
leaq 0x10(%rax), %r12
leaq 0x6d384(%rip), %rsi     # 0xa9de1
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x3b610
movq %rax, 0x18(%rbx)
cmpl $0x0, 0x10(%rbx)
jle 0x3cab8
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c96d
movq %rax, %r13
movq %rax, (%rbx)
cmpl $0x2, 0x10(%rbx)
jl 0x3cac0
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c96d
movq %rax, 0x30(%r13)
incl %ebp
movq %rax, %r13
cmpl (%r12), %ebp
jl 0x3ca9c
jmp 0x3cac3
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x3cac7
movq %r13, %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_rise
void* load_model_rise(FILE* infile, Datasetptr d)
{
 int i;
 Model_riseptr m;
 Decisionruleptr tmp, tmpbefore;
 m = safemalloc(sizeof(Model_rise), "load_model_rise", 4);
 fscanf(infile, "%d", &(m->rules.rulecount));
 m->counts = load_array_int(infile, d->classno);
 if (m->rules.rulecount > 0)
  {
   m->rules.start = load_rule(infile, d);
   tmpbefore = m->rules.start;
   tmp = m->rules.start;
   for (i = 1; i < m->rules.rulecount; i++)
    {
     tmp = load_rule(infile, d);
     tmpbefore->next = tmp;
     tmpbefore = tmp;
    }
   m->rules.end = tmp;
  }
 else
  {
   m->rules.start = NULL;
   m->rules.end = NULL;
  }
 m->svdm = safemalloc(d->featurecount * sizeof(matrix), "load_model_rise", 20);
 for (i = 0; i < d->featurecount; i++)
   if (d->features[i].type == STRING)
     m->svdm[i] = load_matrix(infile, d->features[i].valuecount, d->features[i].valuecount);  
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6d307(%rip), %rsi     # 0xa9df8
movl $0x38, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x10(%rax), %r12
leaq 0x740e7(%rip), %rsi     # 0xb0bf5
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b610
movq %rax, 0x30(%r15)
cmpl $0x0, 0x10(%r15)
jle 0x3cb6a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c96d
movq %rax, %r13
movq %rax, (%r15)
cmpl $0x2, 0x10(%r15)
jl 0x3cb73
movl $0x1, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c96d
movq %rax, 0x30(%r13)
incl %ebp
movq %rax, %r13
cmpl (%r12), %ebp
jl 0x3cb4e
jmp 0x3cb76
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0x3cb7a
movq %r13, %rax
movq %rax, 0x8(%r15)
movslq 0x1bc(%rbx), %rdi
shlq $0x4, %rdi
leaq 0x6d26c(%rip), %rsi     # 0xa9df8
movl $0x14, %edx
callq 0x3a0e1
movq %rax, 0x28(%r15)
movl 0x1bc(%rbx), %eax
testl %eax, %eax
jle 0x3cc06
leaq 0x30f20(%rbx), %r12
movl $0x8, %r13d
xorl %ebp, %ebp
movq %rbx, (%rsp)
cmpl $0x1, -0x18(%r12)
jne 0x3cbf0
movq %r14, %rbx
movq %r15, %r14
movq 0x28(%r15), %r15
movl (%r12), %edx
movq %rbx, %rdi
movl %edx, %esi
callq 0x3b518
movq %rax, -0x8(%r15,%r13)
movq %rdx, (%r15,%r13)
movq %r14, %r15
movq %rbx, %r14
movq (%rsp), %rbx
movl 0x1bc(%rbx), %eax
incq %rbp
movslq %eax, %rcx
addq $0x10, %r13
addq $0x340, %r12            # imm = 0x340
cmpq %rcx, %rbp
jl 0x3cbb7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_linearreg
void* load_model_linearreg(FILE* infile, Datasetptr d)
{
 /*!Last Changed 27.12.2005*/
	Model_linearregressionptr m;
	m = safemalloc(sizeof(Model_linearregression), "load_model_linearreg", 2);
	fscanf(infile, "%lf", &(m->b));
	m->w = load_matrix(infile, 1, d->multifeaturecount - 1);
	return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6cfce(%rip), %rsi     # 0xa9e5b
movl $0x18, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x6cdda(%rip), %rsi     # 0xa9c80
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3b518
movq %rax, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_quantizereg
void* load_model_quantizereg(FILE* infile, Datasetptr d)
{
 /*!Last Changed 27.12.2005*/
	Model_quantizeregptr m;
	m = safemalloc(sizeof(Model_quantizereg), "load_model_quantizereg", 2);
	fscanf(infile, "%d", &(m->partitioncount));
	if (d->multifeaturecount == 2)
	 {
		 fscanf(infile, "%lf%lf", &(m->binx), &(m->minx));
			m->meansone = load_array(infile, m->partitioncount);
	 }
	else
	 {
		 fscanf(infile, "%lf%lf%lf%lf", &(m->binx), &(m->minx), &(m->biny), &(m->miny));
			m->meanstwo = load_array_two(infile, m->partitioncount, m->partitioncount);
			m->eigenvectors = load_matrix(infile, d->multifeaturecount - 1, d->multifeaturecount - 1);
	 }
	return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x6cf85(%rip), %rsi     # 0xa9e70
movl $0x48, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x40(%rax), %rdx
leaq 0x73ced(%rip), %rsi     # 0xb0bf5
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
leaq 0x8(%rbx), %rdx
cmpl $0x2, 0x1c0(%r15)
jne 0x3cf46
leaq 0x6cf14(%rip), %rsi     # 0xa9e3b
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3b5a4
movl $0x20, %ecx
jmp 0x3cf98
leaq 0x18(%rbx), %r8
movq %rbx, %r9
addq $0x10, %r9
leaq 0x6cf2f(%rip), %rsi     # 0xa9e87
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x40(%rbx), %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3b67c
movq %rax, 0x28(%rbx)
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3b518
movq %rax, %rcx
movq %rdx, %rax
movq %rcx, 0x30(%rbx)
movl $0x38, %ecx
movq %rax, (%rbx,%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_gprocessreg
void* load_model_gprocessreg(FILE* infile, Datasetptr d)
{
 /*!Last Changed 15.01.2009*/
 int i;
 Model_gprocessregressionptr m;
 Instanceptr tmp, tmpbefore = NULL, head;
 m = safemalloc(sizeof(Model_gprocessregression), "load_model_gprocessreg", 2);
 fscanf(infile, "%d", &(m->size));
 for (i = 0; i < m->size; i++)
  {
   tmp = safemalloc(sizeof(Instance), "load_model_gprocessreg", 6);
   *tmp = load_instance(infile, d, BOOLEAN_TRUE);
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     head = tmp;
   tmpbefore = tmp;
  }
 tmp->next = NULL;
 m->data = head;
 m->weights = load_array(infile, m->size);
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, %rbx
leaq 0x6c8d6(%rip), %rsi     # 0xa9eb6
movl $0x18, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
leaq 0x735fc(%rip), %rsi     # 0xb0bf5
xorl %r12d, %r12d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
xorl %r13d, %r13d
movl $0x30, %edi
leaq 0x6c89e(%rip), %rsi     # 0xa9eb6
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %rbp
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x3b857
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%rbp)
movups %xmm1, 0x10(%rbp)
movups %xmm0, (%rbp)
movq %rbp, %rax
testq %r12, %r12
je 0x3d661
movq %rbp, 0x10(%r12)
movq %r15, %rax
incl %r13d
movl (%r14), %esi
movq %rax, %r15
movq %rbp, %r12
cmpl %esi, %r13d
jl 0x3d60c
movq $0x0, 0x10(%rbp)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x3b5a4
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: matrix_merge_rows
matrix matrix_merge_rows(matrix a, matrix b)
{
 /*!Last Changed 13.02.2005*/
	int mincol, i, j;
	matrix result;
	mincol = imin(a.col, b.col);
	result = matrix_alloc(a.row + b.row, mincol);
 for (i = 0; i < a.row; i++)
		 for (j = 0; j < mincol; j++)
				 result.values[i][j] = a.values[i][j];
	for (i = a.row; i < a.row + b.row; i++)
		 for (j = 0; j < mincol; j++)
				 result.values[i][j] = b.values[i - a.row][j];
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
shrq $0x20, %rdi
movq %rdx, %rsi
shrq $0x20, %rsi
callq 0x39b49
movl %eax, %r14d
leal (%r12,%r15), %ebp
leaq 0x6c883(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %eax, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %rdx
movl %r14d, %eax
testl %r15d, %r15d
jle 0x3d745
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %esi, %esi
testl %r14d, %r14d
jle 0x3d73d
movq (%r13,%rsi,8), %rdi
movq (%rdx,%rsi,8), %r8
xorl %r9d, %r9d
movsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0x3d729
incq %rsi
cmpq %rcx, %rsi
jne 0x3d718
testl %r12d, %r12d
jle 0x3d785
movslq %r15d, %rcx
movslq %ebp, %rsi
movq %rcx, %rdi
testl %r14d, %r14d
jle 0x3d77d
movq %rdi, %r8
subq %rcx, %r8
movq (%rbx,%r8,8), %r8
movq (%rdx,%rdi,8), %r9
xorl %r10d, %r10d
movsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rax
jne 0x3d769
incq %rdi
cmpq %rsi, %rdi
jl 0x3d753
shlq $0x20, %r14
movl %ebp, %eax
orq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, %rcx
shrq $0x20, %rcx
leaq 0x6c773(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %r15d, %edx
movl $0x3, %r9d
callq 0x3a231
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x1, %ecx
testl %r15d, %r15d
jle 0x3d8cb
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movl $0x1, %r12d
xorl %ebp, %ebp
xorpd %xmm2, %xmm2
movq %rbp, %r13
movq (%r14,%rbp,8), %rcx
movsd (%rcx,%r13,8), %xmm0
testq %rbp, %rbp
je 0x3d86c
movq (%r14,%r13,8), %rdx
movq %r12, %rsi
leal -0x2(%rsi), %edi
movsd (%rcx,%rdi,8), %xmm1
mulsd (%rdx,%rdi,8), %xmm1
subsd %xmm1, %xmm0
decq %rsi
cmpq $0x1, %rsi
jg 0x3d852
cmpq %r13, %rbp
jne 0x3d883
ucomisd %xmm0, %xmm2
jae 0x3d8c9
ucomisd %xmm2, %xmm0
jb 0x3d892
sqrtsd %xmm0, %xmm0
jmp 0x3d89b
movq (%rax,%rbp,8), %rcx
divsd (%rcx,%rbp,8), %xmm0
leaq (%rax,%r13,8), %rcx
jmp 0x3d8a3
callq 0x4300
xorpd %xmm2, %xmm2
movq 0x8(%rbx), %rax
leaq (%rax,%rbp,8), %rcx
movq (%rcx), %rcx
movsd %xmm0, (%rcx,%rbp,8)
incq %r13
cmpq %r15, %r13
jne 0x3d83c
incq %rbp
incq %r12
cmpq %r15, %rbp
jne 0x3d839
movl $0x1, %ecx
jmp 0x3d8cb
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: matrix_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %rcx
shrq $0x20, %rcx
leaq 0x6c46a(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %r15
testl %ebx, %ebx
jle 0x3db4f
movq %rbx, %r12
sarq $0x1d, %r12
andq $-0x8, %r12
movl %ebx, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rdi
movq (%r14,%rbp,8), %rsi
movq %r12, %rdx
callq 0x4310
incq %rbp
cmpq %rbp, %r13
jne 0x3db37
movq %rbx, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movl %ecx, %eax
subl %edx, %eax
leal 0x1(%rax), %edx
movl %r9d, %r14d
subl %r8d, %r14d
incl %r14d
leaq 0x6b29e(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %edx, 0x4(%rsp)
movl %r14d, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %rdx
cmpl %r12d, %r15d
jl 0x3ed37
movslq %ebp, %rax
movslq %r12d, %rcx
incl %r15d
shlq $0x3, %rax
movq %rcx, %rsi
cmpl %ebp, %ebx
jl 0x3ed2f
movq %rsi, %rdi
subq %rcx, %rdi
movq (%rdx,%rdi,8), %rdi
movq (%r13,%rsi,8), %r8
addq %rax, %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%rdi,%r9,8)
incq %r9
cmpl %r9d, %r14d
jne 0x3ed1b
incq %rsi
cmpl %esi, %r15d
jne 0x3ed02
shlq $0x20, %r14
movl 0x4(%rsp), %eax
orq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: matrix_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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rdi, %r14
shrq $0x20, %r14
leaq 0x6b1f5(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %r14d, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %rdx
testl %ebx, %ebx
jle 0x3edcb
movl %ebx, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %r14d, %r14d
jle 0x3edc3
movq (%r15,%rcx,8), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
movq (%rdx,%rdi,8), %r8
movsd %xmm0, (%r8,%rcx,8)
incq %rdi
cmpq %rdi, %r14
jne 0x3edac
incq %rcx
cmpq %rax, %rcx
jne 0x3eda1
shlq $0x20, %rbx
orq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %ebx
leaq 0x6b187(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %rdx
movl %ebx, %ecx
testl %ebx, %ebx
jle 0x3ee23
xorl %eax, %eax
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
movq (%rdx,%rax,8), %rdi
movq %rsi, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x3ee13
movq %rcx, %rax
shlq $0x20, %rax
orq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %rbp
shrq $0x20, %rbp
cmpl %r13d, %ebp
jne 0x3eef7
movq %rcx, %r15
movq %r13, %r12
shrq $0x20, %r12
leaq 0x6b108(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %r12d, %ecx
movl $0x3, %r9d
callq 0x3a231
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
andq %r13, %rdx
movl %ebx, %ecx
orq %rdx, %rcx
testl %ebx, %ebx
jle 0x3eeef
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r12d, %r12d
jle 0x3eee7
movq (%rax,%rdx,8), %rsi
xorl %edi, %edi
movq $0x0, (%rsi,%rdi,8)
testl %ebp, %ebp
jle 0x3eedf
movq (%r14,%rdx,8), %r8
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm1
movq (%r15,%r9,8), %r10
mulsd (%r10,%rdi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %r9
cmpq %r9, %rbp
jne 0x3eebe
incq %rdi
cmpq %r12, %rdi
jne 0x3eea7
incq %rdx
cmpq %rbx, %rdx
jne 0x3ee9c
movq %rcx, %rbx
movq %rax, %r14
jmp 0x3ef03
leaq 0x6b16a(%rip), %rdi     # 0xaa068
callq 0x4090
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movl %edi, %ebp
leaq 0x6b02f(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %r14
movl %ebp, %r15d
testl %ebp, %ebp
jle 0x3ef96
movl %ebx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x3ef8e
xorl %ebp, %ebp
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x3af6a
movq (%r14,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r12
jne 0x3ef6c
incq %r13
cmpq %r15, %r13
jne 0x3ef66
shlq $0x20, %rbx
orq %r15, %rbx
movq %rbx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x3f07c
movq %rdi, %rbx
leaq 0x6ae0e(%rip), %rsi     # 0xa9de1
leaq 0xc(%rsp), %r12
leaq 0x8(%rsp), %r14
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x4070
movl (%r12), %r13d
movl (%r14), %r14d
leaq 0x6af74(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %r13d, %edx
movl %r14d, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %r15
shlq $0x20, %r14
orq %r13, %r14
movq %r14, 0x10(%rsp)
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x3f075
movl 0x8(%rsp), %eax
leaq 0x6ac4b(%rip), %r12     # 0xa9c80
xorl %r13d, %r13d
testl %eax, %eax
jle 0x3f06a
xorl %ebp, %ebp
xorl %r14d, %r14d
movq (%r15,%r13,8), %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4070
incq %r14
movslq 0x8(%rsp), %rax
addq $0x8, %rbp
cmpq %rax, %r14
jl 0x3f041
movl 0xc(%rsp), %ecx
incq %r13
movslq %ecx, %rdx
cmpq %rdx, %r13
jl 0x3f038
movq 0x10(%rsp), %rax
jmp 0x3f0b9
leaq 0x6aee9(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x3, %r9d
callq 0x3a231
movq %rax, %r15
movq (%rax), %rax
movq $0x0, (%rax)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x38a4a
movl %eax, %ebp
movq %r14, %rdi
callq 0x38c1c
movl %eax, %r15d
leaq 0x6ae4a(%rip), %rsi     # 0xa9f3f
movl $0x10, %edi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x6ae5e(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %r15d, %ecx
movl $0x3, %r9d
callq 0x3a231
movl %r15d, %ecx
movq %rcx, 0x8(%rsp)
shlq $0x20, %rcx
movl %ebp, %edx
movq %rdx, 0x10(%rsp)
orq %rdx, %rcx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
leaq 0x6c80f(%rip), %rsi     # 0xab95b
movq %r14, %rdi
callq 0x40f0
movq %rax, %r14
testl %ebp, %ebp
jle 0x3f1a3
movq 0x8(%rsp), %rbp
shlq $0x3, %rbp
leaq 0x6ab15(%rip), %r15     # 0xa9c80
xorl %r12d, %r12d
cmpl $0x0, 0x8(%rsp)
jle 0x3f199
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
addq %r13, %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
cmpq %r13, %rbp
jne 0x3f178
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x3f16e
movq %r14, %rdi
callq 0x42a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: matrix_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %r14d, %r14d
jle 0x3f255
movq %rsi, %rbx
movq %r14, %r12
shrq $0x20, %r12
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x71560(%rip), %r15     # 0xb0781
testl %r12d, %r12d
jle 0x3f243
xorl %ebp, %ebp
movq (%rbx,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x4030
incq %rbp
cmpq %rbp, %r12
jne 0x3f228
movl $0xa, %edi
callq 0x40d0
incq %r13
cmpq %r14, %r13
jne 0x3f221
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r13
leaq 0x6c6e9(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x3f347
movq %rax, %r15
movq %rbx, 0x18(%rsp)
movq %r13, %rbx
shrq $0x20, %rbx
testl %ebp, %ebp
je 0x3f2bb
leaq 0x66b80(%rip), %rsi     # 0xa5e2c
movq %r15, %rdi
movl %r13d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x42e0
testl %r13d, %r13d
jle 0x3f33f
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq %r13, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
testl %ebx, %ebx
leaq 0x69408(%rip), %r12     # 0xa86e5
movq %r15, %rbx
movq 0x18(%rsp), %r15
leaq 0x20(%rsp), %rbp
jle 0x3f31d
xorl %r13d, %r13d
movq %rbp, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3a535
movq (%r15,%r14,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movq %rbp, %rsi
movb $0x1, %al
callq 0x42e0
incq %r13
cmpq %r13, 0x8(%rsp)
jne 0x3f2ef
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
incq %r14
movq 0x10(%rsp), %r13
cmpq %r13, %r14
movq %rbx, %r15
movq 0x8(%rsp), %rbx
jne 0x3f2d4
movq %r15, %rdi
callq 0x42a0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: 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:
cmpl %edx, %esi
jg 0x3f41c
pushq %rbx
movslq %ecx, %r9
movslq %esi, %rax
incl %edx
movl %r8d, %r10d
subl %r9d, %r10d
leaq 0x2(%r10), %rsi
andq $-0x2, %rsi
movq %r10, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
leaq 0x8(,%r9,8), %r9
movdqa 0x670ae(%rip), %xmm2    # 0xa6440
movdqa 0x670b6(%rip), %xmm3    # 0xa6450
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
cmpl %ecx, %r8d
jl 0x3f414
movq 0x8(%rdi), %r10
movq (%r10,%rax,8), %r10
addq %r9, %r10
xorl %r11d, %r11d
movq %r11, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
por %xmm2, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm1, %xmm6
pcmpeqd %xmm1, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %ebx
notl %ebx
testb $0x1, %bl
je 0x3f3f7
movsd %xmm0, -0x8(%r10,%r11,8)
pxor %xmm4, %xmm5
pextrw $0x4, %xmm5, %ebx
testb $0x1, %bl
je 0x3f40b
movsd %xmm0, (%r10,%r11,8)
addq $0x2, %r11
cmpq %r11, %rsi
jne 0x3f3b5
incq %rax
cmpl %eax, %edx
jne 0x3f3a2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3f4e6
movl 0x4(%rdi), %ecx
leal 0x1(%rcx), %edx
movq %rcx, %rsi
decq %rsi
movq %rsi, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
shrl %edx
shlq $0x4, %rdx
xorl %esi, %esi
movdqa 0x66ff1(%rip), %xmm2    # 0xa6440
movdqa 0x66ff9(%rip), %xmm3    # 0xa6450
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movdqa 0x67029(%rip), %xmm5    # 0xa6490
testl %ecx, %ecx
jle 0x3f4de
movq 0x8(%rdi), %r8
movq (%r8,%rsi,8), %r8
xorl %r9d, %r9d
movdqa %xmm2, %xmm6
movdqa %xmm6, %xmm7
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm1, %xmm8
pcmpeqd %xmm1, %xmm7
pshufd $0xf5, %xmm7, %xmm9     # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7     # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %r10d
notl %r10d
testb $0x1, %r10b
je 0x3f4ba
movsd %xmm0, (%r8,%r9)
pxor %xmm4, %xmm7
pextrw $0x4, %xmm7, %r10d
testb $0x1, %r10b
je 0x3f4d1
movsd %xmm0, 0x8(%r8,%r9)
paddq %xmm5, %xmm6
addq $0x10, %r9
cmpq %r9, %rdx
jne 0x3f47a
incq %rsi
cmpq %rax, %rsi
jne 0x3f467
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
shrq $0x20, %rax
cmpl %eax, %edi
jne 0x3f554
movl $0x1, %eax
testl %edi, %edi
jle 0x3f556
pushq %r14
pushq %rbx
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movq %rdi, %rdx
movq %rsi, %r8
xorl %r9d, %r9d
movq %r9, %r10
incq %r9
cmpq %rdi, %r9
jae 0x3f542
movq (%rsi,%r10,8), %r11
addq %rcx, %r11
movl $0x1, %ebx
movsd (%r11,%rbx,8), %xmm0
movq (%r8,%rbx,8), %r14
ucomisd (%r14,%r10,8), %xmm0
jne 0x3f557
jp 0x3f557
incq %rbx
cmpq %rbx, %rdx
jne 0x3f526
addq $0x8, %r8
addq $0x8, %rcx
decq %rdx
cmpq %rdi, %r9
jne 0x3f50f
jmp 0x3f559
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, (%rsp)
cmpl %edx, %esi
jg 0x3f60e
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
movapd 0x66c49(%rip), %xmm2    # 0xa61d0
xorpd %xmm0, %xmm2
movslq %ecx, %rax
movslq %esi, %r13
incl %r14d
movl (%rsp), %ecx
movq %rax, 0x8(%rsp)
subl %eax, %ecx
incl %ecx
movl %ecx, 0x4(%rsp)
movapd %xmm0, 0x20(%rsp)
movapd %xmm2, 0x10(%rsp)
cmpl (%rsp), %ebp
jg 0x3f606
movl 0x4(%rsp), %r12d
movq 0x8(%rsp), %rbx
xorl %eax, %eax
callq 0x3af20
movsd 0x65f4a(%rip), %xmm3    # 0xa5518
movapd 0x10(%rsp), %xmm2
movapd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rax
movsd %xmm1, (%rax,%rbx,8)
incq %rbx
decl %r12d
jne 0x3f5bf
incq %r13
cmpl %r13d, %r14d
jne 0x3f5b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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:
movl (%rdi), %eax
testl %eax, %eax
jle 0x3f6b8
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movapd 0x66b95(%rip), %xmm2    # 0xa61d0
xorpd %xmm0, %xmm2
movl 0x4(%rdi), %ecx
xorl %r14d, %r14d
movapd %xmm0, 0x10(%rsp)
movapd %xmm2, (%rsp)
testl %ecx, %ecx
jle 0x3f6a4
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3af20
movsd 0x65eb2(%rip), %xmm3    # 0xa5518
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), %rcx
cmpq %rcx, %r15
jl 0x3f657
movl (%rbx), %eax
incq %r14
movslq %eax, %rdx
cmpq %rdx, %r14
jl 0x3f650
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f76c
movq %rax, 0x10(%rsp)
movq %rbp, 0x8(%rsp)
movslq %edx, %r12
jle 0x3f70c
leaq (%r14,%r12,8), %rbx
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %rdi
callq 0x3a180
incq %rbp
cmpl %ebp, %r13d
jne 0x3f6fb
shlq $0x3, %r12
movq %r14, %rdi
movq %r12, %rsi
movl 0x4(%rsp), %ebx
movl %ebx, %edx
callq 0x3a0b4
movq %rax, %r14
cmpl %ebx, %r15d
jge 0x3f762
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 0x6a80f(%rip), %rsi     # 0xa9f5a
movl $0x1c, %edx
callq 0x3a0e1
movq %rax, (%rbp,%rbx,8)
incq %rbx
cmpl %ebx, %r13d
jne 0x3f741
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %rax
cmpl %ebp, %eax
sete %al
testl %r15d, %r15d
setle %cl
orb %al, %cl
jne 0x3f7a5
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 0x3a0b4
movq %rax, (%r14,%rbx,8)
incq %rbx
cmpq %rbx, %r15
jne 0x3f78b
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_O3/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 0x3f7fe
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x3f7f6
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 0x3f7de
incq %rdx
cmpq %rax, %rdx
jne 0x3f7cf
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f83b
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x3f833
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 0x3f81b
incq %rdx
cmpq %rax, %rdx
jne 0x3f80c
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f908
movl 0x4(%rdi), %ecx
leal 0x1(%rcx), %edx
movq %rcx, %rsi
decq %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %edx
shlq $0x4, %rdx
xorl %esi, %esi
movdqa 0x66bd2(%rip), %xmm1    # 0xa6440
movdqa 0x66bda(%rip), %xmm2    # 0xa6450
pxor %xmm2, %xmm0
movabsq $0x3ff0000000000000, %r8 # imm = 0x3FF0000000000000
pcmpeqd %xmm3, %xmm3
movdqa 0x66c00(%rip), %xmm4    # 0xa6490
testl %ecx, %ecx
jle 0x3f900
movq 0x8(%rdi), %r9
movq (%r9,%rsi,8), %r9
xorl %r10d, %r10d
movdqa %xmm1, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r11d
notl %r11d
testb $0x1, %r11b
je 0x3f8de
movq %r8, (%r9,%r10)
pxor %xmm3, %xmm6
pextrw $0x4, %xmm6, %r11d
testb $0x1, %r11b
je 0x3f8f3
movq %r8, 0x8(%r9,%r10)
paddq %xmm4, %xmm5
addq $0x10, %r10
cmpq %r10, %rdx
jne 0x3f8a3
incq %rsi
cmpq %rax, %rsi
jne 0x3f890
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f94a
movq %rdi, %rbx
movl 0x4(%rdi), %r12d
movq %r12, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r12d, %r12d
jle 0x3f942
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x4050
incq %r13
cmpq %r13, %r15
jne 0x3f92b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/matrix.c
// Function: matrix_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:
movq (%rdi), %rax
cmpq %rsi, %rax
jne 0x3f9e3
testl %eax, %eax
jle 0x3f9e2
movq %rax, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
testl %ecx, %ecx
jle 0x3f9da
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 0x3f9c0
incq %rsi
cmpq %rax, %rsi
jne 0x3f9ad
retq
leaq 0x6a7c9(%rip), %rdi     # 0xaa1b3
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 0x3fa76
movq %rcx, %r15
movq %rbx, %r12
shrq $0x20, %r12
leaq 0x6a559(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %r12d, %ecx
movl $0x3, %r9d
callq 0x3a231
testl %ebx, %ebx
jle 0x3fa71
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r12d, %r12d
jle 0x3fa69
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 0x3fa4f
incq %rdx
cmpq %rcx, %rdx
jne 0x3fa3b
movq %rax, %r14
jmp 0x3fa82
leaq 0x6a736(%rip), %rdi     # 0xaa1b3
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_O3/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:
movq (%rdi), %rax
cmpq %rsi, %rax
jne 0x3fae4
testl %eax, %eax
jle 0x3fae3
movq %rax, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
testl %ecx, %ecx
jle 0x3fadb
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 0x3fac1
incq %rsi
cmpq %rax, %rsi
jne 0x3faae
retq
leaq 0x6a6c8(%rip), %rdi     # 0xaa1b3
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 0x3fb77
movq %rcx, %r15
movq %rbx, %r12
shrq $0x20, %r12
leaq 0x6a458(%rip), %r8      # 0xa9f6c
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %r12d, %ecx
movl $0x3, %r9d
callq 0x3a231
testl %ebx, %ebx
jle 0x3fb72
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r12d, %r12d
jle 0x3fb6a
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 0x3fb50
incq %rdx
cmpq %rcx, %rdx
jne 0x3fb3c
movq %rax, %r14
jmp 0x3fb83
leaq 0x6a635(%rip), %rdi     # 0xaa1b3
callq 0x4090
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq