LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_naivebayes
void* load_model_naivebayes(FILE* infile, Datasetptr d)
{
 /*!Last Changed 11.08.2007*/
	int i, j;
 Model_naivebayesptr m;
 m = safemalloc(sizeof(Model_naivebayes), "load_model_naivebayes", 3);
	m->m = load_array_two(infile, d->classno, d->featurecount);
	m->priors = load_array(infile, d->classno);
	m->s = load_array(infile, d->classno);
	m->p = safemalloc(d->classno * sizeof(double **), "load_model_naivebayes", 7);
 for (i = 0; i < d->classno; i++)
	 {
		 m->p[i] = safemalloc(d->featurecount * sizeof(double *), "load_model_naivebayes", 10);
		 for (j = 0; j < d->featurecount; j++)
				 if (d->features[j].type == STRING)
						 m->p[i][j] = load_array(infile, d->features[j].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 0x62da7(%rip), %r15     # 0x99c99
pushq $0x20
popq %rdi
pushq $0x3
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %r12
movl 0x10(%rbx), %esi
movl 0x1bc(%rbx), %edx
movq %r14, %rdi
callq 0x3622c
movq %rax, (%r12)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3615a
movq %rax, 0x10(%r12)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3615a
movq %rax, 0x8(%r12)
movslq 0x10(%rbx), %rdi
shlq $0x3, %rdi
pushq $0x7
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, 0x18(%r12)
leaq 0x30f20(%rbx), %rax
movq %rax, (%rsp)
xorl %r15d, %r15d
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jge 0x36fcd
movslq 0x1bc(%rbx), %rdi
shlq $0x3, %rdi
leaq 0x62d20(%rip), %rsi     # 0x99c99
pushq $0xa
popq %rdx
callq 0x34f59
movq 0x18(%r12), %rcx
movq %rax, (%rcx,%r15,8)
movq (%rsp), %r13
xorl %ebp, %ebp
movslq 0x1bc(%rbx), %rax
cmpq %rax, %rbp
jge 0x36fc8
cmpl $0x1, -0x18(%r13)
jne 0x36fbc
movl (%r13), %esi
movq %r14, %rdi
callq 0x3615a
movq 0x18(%r12), %rcx
movq (%rcx,%r15,8), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
addq $0x340, %r13            # imm = 0x340
jmp 0x36f90
incq %r15
jmp 0x36f5e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x62cb8(%rip), %r12     # 0x99caf
pushq $0x20
popq %rdi
pushq $0x3
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %r15
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3615a
movq %rax, 0x10(%r15)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3615a
movq %rax, 0x18(%r15)
movslq 0x10(%rbx), %rdi
shlq $0x4, %rdi
pushq $0x5
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, (%r15)
pushq $0x8
popq %r12
xorl %r13d, %r13d
movslq 0x10(%rbx), %rdi
cmpq %rdi, %r13
jge 0x37074
movq (%r15), %rbp
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x360cc
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
addq $0x10, %r12
jmp 0x37043
shlq $0x4, %rdi
leaq 0x62c30(%rip), %rsi     # 0x99caf
pushq $0x8
popq %rdx
callq 0x34f59
movq %rax, 0x8(%r15)
pushq $0x8
popq %r12
xorl %r13d, %r13d
movslq 0x10(%rbx), %rax
cmpq %rax, %r13
jge 0x370c5
movq 0x8(%r15), %rbp
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
pushq $0x1
popq %rsi
callq 0x360cc
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
addq $0x10, %r12
jmp 0x37092
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_O2/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 0x62bd4(%rip), %r12     # 0x99cc3
pushq $0x30
popq %rdi
pushq $0x2
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %rbx
leaq 0x4(%rax), %rcx
leaq 0x617d3(%rip), %rsi     # 0x988de
xorl %r13d, %r13d
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%r15), %esi
movq %r14, %rdi
callq 0x3615a
movq %rax, 0x8(%rbx)
movslq 0x10(%r15), %rdi
shlq $0x4, %rdi
pushq $0x5
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x10(%rbx)
pushq $0x8
popq %r12
movslq 0x10(%r15), %rax
cmpq %rax, %r13
jge 0x37175
movq 0x10(%rbx), %rbp
movl (%rbx), %edx
decl %edx
movq %r14, %rdi
pushq $0x1
popq %rsi
callq 0x360cc
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
addq $0x10, %r12
jmp 0x37146
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x360cc
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
andq $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_O2/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 0x629a0(%rip), %rsi     # 0x99ce6
pushq $0x70
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %rbx
leaq 0x4(%rax), %r12
leaq 0x62996(%rip), %rsi     # 0x99cf5
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
cmpl $0x0, (%rbx)
js 0x373a2
cmpb $0x2a, (%r12)
jne 0x373d8
leaq 0x18(%rbx), %rdx
leaq 0x62822(%rip), %r15     # 0x99ba8
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4070
movq %rbx, %rdx
addq $0x10, %rdx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x373e9
movq %rbx, %rdx
addq $0x30, %rdx
leaq 0x627f8(%rip), %rsi     # 0x99ba8
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%r15), %edx
decl %edx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x360cc
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
jmp 0x373f0
movq %rbx, %rdx
addq $0x8, %rdx
leaq 0x627c2(%rip), %rsi     # 0x99ba8
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
andq $0x0, 0x48(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x628df(%rip), %rsi     # 0x99cfb
pushq $0x38
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x28(%rax), %r12
leaq 0x8(%rax), %r8
leaq 0x4(%rax), %r9
leaq 0x628c8(%rip), %rsi     # 0x99d05
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x361c3
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37331
movq %rax, %r13
movq %rax, 0x18(%r15)
pushq $0x1
popq %rbp
cmpl (%r12), %ebp
jge 0x3748d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37331
movq %rax, 0x48(%r13)
incl %ebp
movq %rax, %r13
jmp 0x37471
movq %r13, 0x20(%r15)
andq $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_O2/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, %rbx
movq %rdi, %r14
leaq 0x6284e(%rip), %rsi     # 0x99d0e
pushq $0x28
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x14(%rax), %rdx
leaq 0x10(%rax), %r12
leaq 0x6282c(%rip), %rsi     # 0x99d09
movq %r14, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x361c3
movq %rax, 0x18(%r15)
cmpl $0x0, 0x10(%r15)
jle 0x37536
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37404
movq %rax, %r13
movq %rax, (%r15)
pushq $0x1
popq %rbp
cmpl (%r12), %ebp
jge 0x37530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37404
movq %rax, 0x30(%r13)
incl %ebp
movq %rax, %r13
jmp 0x37514
movq %r13, 0x8(%r15)
jmp 0x3753d
xorps %xmm0, %xmm0
movups %xmm0, (%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_O2/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 0x627b9(%rip), %rsi     # 0x99d20
pushq $0x38
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x10(%rax), %r12
leaq 0x695d9(%rip), %rsi     # 0xa0b59
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x361c3
movq %rax, 0x30(%r15)
cmpl $0x0, 0x10(%r15)
jle 0x375d9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37404
movq %rax, %r13
movq %rax, (%r15)
pushq $0x1
popq %rbp
cmpl (%r12), %ebp
jge 0x375d3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37404
movq %rax, 0x30(%r13)
incl %ebp
movq %rax, %r13
jmp 0x375b7
movq %r13, 0x8(%r15)
jmp 0x375e0
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movslq 0x1bc(%rbx), %rdi
shlq $0x4, %rdi
leaq 0x6272e(%rip), %rsi     # 0x99d20
pushq $0x14
popq %rdx
callq 0x34f59
movq %rax, 0x28(%r15)
leaq 0x30f20(%rbx), %r12
pushq $0x8
popq %r13
xorl %ebp, %ebp
movq %rbx, (%rsp)
movslq 0x1bc(%rbx), %rax
cmpq %rax, %rbp
jge 0x3765e
cmpl $0x1, -0x18(%r12)
jne 0x3764e
movq %r14, %rbx
movq %r15, %r14
movq 0x28(%r15), %r15
movl (%r12), %edx
movq %rbx, %rdi
movl %edx, %esi
callq 0x360cc
movq %rax, -0x8(%r15,%r13)
movq %rdx, (%r15,%r13)
movq %r14, %r15
movq %rbx, %r14
movq (%rsp), %rbx
incq %rbp
addq $0x10, %r13
addq $0x340, %r12            # imm = 0x340
jmp 0x3760f
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_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_divs
void* load_model_divs(FILE* infile, Datasetptr d)
{
 int i, j, k;
 Model_divsptr m;
 m = safemalloc(sizeof(Model_divs), "load_model_divs", 4);
 fscanf(infile, "%d %d %d", &(m->datacount), &(m->M), &(m->epsilon));
 m->rulecounts = safemalloc(m->datacount * sizeof(int), "load_model_divs", 6);
 m->classno = safemalloc(m->datacount * sizeof(int), "load_model_divs", 7);
 m->hypotheses = safemalloc(m->datacount * sizeof(Condition**), "load_model_divs", 8);
 m->conditioncounts = safemalloc(m->datacount * sizeof(int*), "load_model_divs", 9);
 for (i = 0; i < m->datacount; i++)
  {
   fscanf(infile, "%d %d", &(m->rulecounts[i]), &(m->classno[i]));
   m->conditioncounts[i] = load_array_int(infile, m->rulecounts[i]);
   for (j = 0; j < m->rulecounts[i]; j++)
    {
     for (k = 0; k < m->conditioncounts[i][j]; k++)
       fscanf(infile, "%d%c%lf", &(m->hypotheses[i][j][k].featureindex), &(m->hypotheses[i][j][k].comparison), &(m->hypotheses[i][j][k].value));
    }   
  }
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x626ab(%rip), %r12     # 0x99d30
pushq $0x30
popq %rdi
pushq $0x4
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %r14
leaq 0x20(%rax), %rdx
leaq 0x24(%rax), %rcx
leaq 0x28(%rax), %r8
leaq 0x61232(%rip), %rsi     # 0x988db
movq %rbx, %rdi
movq %rdx, (%rsp)
xorl %eax, %eax
callq 0x4070
movslq 0x20(%r14), %rdi
shlq $0x2, %rdi
pushq $0x6
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x8(%r14)
movslq 0x20(%r14), %rdi
shlq $0x2, %rdi
pushq $0x7
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x10(%r14)
movslq 0x20(%r14), %rdi
shlq $0x3, %rdi
pushq $0x8
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, (%r14)
movslq 0x20(%r14), %rdi
shlq $0x3, %rdi
pushq $0x9
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x18(%r14)
xorl %r12d, %r12d
movq (%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %r12
jge 0x377ce
leaq (,%r12,4), %rcx
movq 0x8(%r14), %rdx
addq %rcx, %rdx
addq 0x10(%r14), %rcx
movq %rbx, %rdi
leaq 0x6119c(%rip), %rsi     # 0x988de
xorl %eax, %eax
callq 0x4070
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x361c3
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%r12,8)
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movslq (%rax,%r12,4), %rax
cmpq %rax, %r15
jge 0x377c6
pushq $0x8
popq %rbp
xorl %r13d, %r13d
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r13
jge 0x377c1
movq (%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r15,8), %rax
leaq (%rax,%rbp), %r8
leaq (%rax,%rbp), %rdx
addq $-0x8, %rdx
leaq (%rax,%rbp), %rcx
addq $-0x4, %rcx
movq %rbx, %rdi
leaq 0x6258f(%rip), %rsi     # 0x99d40
xorl %eax, %eax
callq 0x4070
incq %r13
addq $0x10, %rbp
jmp 0x37777
incq %r15
jmp 0x37764
incq %r12
jmp 0x37715
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_onefeature
void* load_model_onefeature(FILE* infile, Datasetptr d)
{
 /*!Last Changed 27.12.2005*/
	Model_onefeatureptr m;
	m = safemalloc(sizeof(Model_onefeature), "load_model_onefeature", 2);
	fscanf(infile, "%d%lf%lf%lf", &(m->bestfeature), &(m->bestsplit), &(m->leftmean), &(m->rightmean));
	return m;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6255a(%rip), %rsi     # 0x99d48
pushq $0x20
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r14
leaq 0x8(%rax), %rcx
leaq 0x10(%rax), %r8
leaq 0x18(%rax), %r9
leaq 0x6254f(%rip), %rsi     # 0x99d5e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_selectaverage
void* load_model_selectaverage(FILE* infile, Datasetptr d)
{
 /*!Last Changed 27.12.2005*/
	double* m;
	m = safemalloc(sizeof(double), "load_model_selectaverage", 2);
	fscanf(infile, "%lf", m);
	return m;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x62535(%rip), %rsi     # 0x99d6a
pushq $0x8
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r14
leaq 0x6235e(%rip), %rsi     # 0x99ba8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6250f(%rip), %rsi     # 0x99d83
pushq $0x18
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x6231f(%rip), %rsi     # 0x99ba8
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%rbx), %edx
decl %edx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x360cc
movq %rax, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x624cc(%rip), %rsi     # 0x99d98
pushq $0x48
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %rbx
leaq 0x40(%rax), %rdx
leaq 0x69274(%rip), %rsi     # 0xa0b59
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
leaq 0x8(%rbx), %rdx
cmpl $0x2, 0x1c0(%r15)
jne 0x37920
leaq 0x6245f(%rip), %rsi     # 0x99d63
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3615a
pushq $0x20
jmp 0x3796f
leaq 0x18(%rbx), %r8
movq %rbx, %r9
addq $0x10, %r9
leaq 0x6247d(%rip), %rsi     # 0x99daf
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x40(%rbx), %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3622c
movq %rax, 0x28(%rbx)
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x360cc
movq %rax, %rcx
movq %rdx, %rax
movq %rcx, 0x30(%rbx)
pushq $0x38
popq %rcx
movq %rax, (%rbx,%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x61e91(%rip), %rsi     # 0x99dde
pushq $0x18
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x68bf7(%rip), %rsi     # 0xa0b59
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
xorl %r14d, %r14d
movl (%r15), %esi
cmpl %esi, %ebp
jge 0x37fd8
pushq $0x30
popq %rdi
leaq 0x61e59(%rip), %rsi     # 0x99dde
pushq $0x6
popq %rdx
callq 0x34f59
movq %rax, %r13
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x363da
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%r13)
movups %xmm1, 0x10(%r13)
movups %xmm0, (%r13)
movq %r13, %rax
testq %r14, %r14
je 0x37fce
movq %r13, 0x10(%r14)
movq %r12, %rax
incl %ebp
movq %r13, %r14
movq %rax, %r12
jmp 0x37f74
andq $0x0, 0x10(%r13)
movq %r12, 0x8(%r15)
movq %rbx, %rdi
callq 0x3615a
movq %rax, 0x10(%r15)
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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, %r13
movq %rsi, %r12
movq %rdi, %r15
shrq $0x20, %rdi
movq %rdx, %rsi
shrq $0x20, %rsi
callq 0x34ccd
movl %eax, %r14d
leal (%r15,%r13), %ebp
movl %ebp, %edi
movl %eax, %esi
callq 0x380d3
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
testl %r15d, %r15d
movl $0x0, %esi
cmovgl %r15d, %esi
cmpq %rsi, %rcx
je 0x3808a
xorl %edi, %edi
cmpq %rdi, %r14
je 0x38085
movq (%r12,%rcx,8), %r8
movsd (%r8,%rdi,8), %xmm0
movq (%rdx,%rcx,8), %r8
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
jmp 0x38067
incq %rcx
jmp 0x38060
movslq %r15d, %rcx
movslq %ebp, %rsi
movq %rcx, %rdi
cmpq %rsi, %rdi
jge 0x380c4
movq %rdi, %r8
subq %rcx, %r8
xorl %r9d, %r9d
cmpq %r9, %r14
je 0x380bf
movq (%rbx,%r8,8), %r10
movsd (%r10,%r9,8), %xmm0
movq (%rdx,%rdi,8), %r10
movsd %xmm0, (%r10,%r9,8)
incq %r9
jmp 0x380a1
incq %rdi
jmp 0x38093
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: 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, %rsi
shrq $0x20, %rsi
callq 0x380d3
movq %rax, (%rbx)
xorl %ebp, %ebp
testl %r15d, %r15d
movl $0x0, %r13d
cmovgl %r15d, %r13d
movq %rdx, 0x8(%rbx)
movl %r15d, %r15d
xorpd %xmm2, %xmm2
cmpq %r13, %rbp
je 0x381dd
movq %rbp, %r12
cmpq %r15, %r12
je 0x381c4
movq (%r14,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbp, %rcx
testq %rcx, %rcx
jle 0x38180
movsd -0x8(%rax,%rcx,8), %xmm1
movq (%r14,%r12,8), %rsi
mulsd -0x8(%rsi,%rcx,8), %xmm1
decq %rcx
subsd %xmm1, %xmm0
jmp 0x38162
cmpq %r12, %rbp
jne 0x38197
ucomisd %xmm0, %xmm2
jae 0x381cc
ucomisd %xmm2, %xmm0
jb 0x381a6
sqrtsd %xmm0, %xmm0
jmp 0x381af
movq (%rdx,%rbp,8), %rax
divsd (%rax,%rbp,8), %xmm0
leaq (%rdx,%r12,8), %rax
jmp 0x381b7
callq 0x4300
xorpd %xmm2, %xmm2
movq 0x8(%rbx), %rdx
leaq (%rdx,%rbp,8), %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %r12
jmp 0x38150
incq %rbp
jmp 0x38144
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x381ce
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r13
movq %rdi, %rsi
shrq $0x20, %rsi
callq 0x380d3
movq %rax, (%rsp)
movq %rdx, %r15
movq %r13, %r12
sarq $0x1d, %r12
andq $-0x8, %r12
xorl %ebp, %ebp
testl %r13d, %r13d
movl $0x0, %r14d
cmovgl %r13d, %r14d
cmpq %rbp, %r14
je 0x3844c
movq (%r15,%rbp,8), %rdi
movq (%rbx,%rbp,8), %rsi
movq %r12, %rdx
callq 0x4310
incq %rbp
jmp 0x38432
movq (%rsp), %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: 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 %r12
pushq %rbx
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movl %ecx, %edi
subl %edx, %edi
incl %edi
movl %r9d, %esi
subl %r8d, %esi
incl %esi
callq 0x380d3
movslq %r14d, %rcx
movslq %ebp, %rsi
movslq %r12d, %rdi
movslq %r15d, %r8
movq %rdi, %r9
cmpq %r8, %r9
jg 0x39296
movq %r9, %r10
subq %rdi, %r10
xorl %r11d, %r11d
movq %rcx, %r14
cmpq %rsi, %r14
jg 0x39291
movq (%rbx,%r9,8), %r15
movsd (%r15,%r14,8), %xmm0
movq (%rdx,%r10,8), %r15
movsd %xmm0, (%r15,%r11)
incq %r14
addq $0x8, %r11
jmp 0x3926f
incq %r9
jmp 0x3925e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_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, %rbx
movq %rdi, %r15
movq %rdi, %r14
shrq $0x20, %r14
movl %r14d, %edi
movl %r15d, %esi
callq 0x380d3
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
testl %r15d, %r15d
movl $0x0, %esi
cmovgl %r15d, %esi
cmpq %rsi, %rcx
je 0x39308
xorl %edi, %edi
cmpq %rdi, %r14
je 0x39303
movq (%rbx,%rcx,8), %r8
movsd (%r8,%rdi,8), %xmm0
movq (%rdx,%rdi,8), %r8
movsd %xmm0, (%r8,%rcx,8)
incq %rdi
jmp 0x392e5
incq %rcx
jmp 0x392de
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %edi, %esi
callq 0x380d3
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
cmpq %rcx, %rbx
je 0x3933b
movq (%rdx,%rcx,8), %rdi
movq %rsi, (%rdi,%rcx,8)
incq %rcx
jmp 0x39329
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r13
shrq $0x20, %r13
cmpl %r12d, %r13d
jne 0x393d1
movq %rcx, %r15
shrq $0x20, %r12
movl %r14d, %edi
movl %r12d, %esi
callq 0x380d3
xorl %ecx, %ecx
testl %r13d, %r13d
cmovlel %ecx, %r13d
testl %r12d, %r12d
cmovlel %ecx, %r12d
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %r14, %rcx
je 0x393df
xorl %esi, %esi
cmpq %r12, %rsi
je 0x393cc
movq (%rdx,%rcx,8), %rdi
andq $0x0, (%rdi,%rsi,8)
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
cmpq %r8, %r13
je 0x393c7
movq (%rbx,%rcx,8), %r9
movsd (%r9,%r8,8), %xmm1
movq (%r15,%r8,8), %r9
mulsd (%r9,%rsi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%rsi,8)
incq %r8
jmp 0x393a0
incq %rsi
jmp 0x3938b
incq %rcx
jmp 0x39384
leaq 0x60bc0(%rip), %rdi     # 0x99f98
callq 0x4090
jmp 0x393e5
movq %rax, %r14
movq %rdx, %rbx
movq %r14, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
callq 0x380d3
movq %rax, %r15
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
movq %rdx, %r12
testl %r14d, %r14d
cmovlel %r13d, %r14d
cmpq %r14, %r13
je 0x3945f
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x3945a
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x35cae
movq (%r12,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x39436
incq %r13
jmp 0x3942f
movq %r15, %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: 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 0x3950b
movq %rdi, %rbx
leaq 0x60874(%rip), %rsi     # 0x99d09
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x4070
movl (%r14), %edi
movl (%r15), %esi
callq 0x380d3
movq %rax, 0x10(%rsp)
movq %rdx, %r15
leaq 0x606e2(%rip), %r12     # 0x99ba8
xorl %r13d, %r13d
movslq 0xc(%rsp), %rax
cmpq %rax, %r13
jge 0x39504
xorl %ebp, %ebp
xorl %r14d, %r14d
movslq 0x8(%rsp), %rax
cmpq %rax, %r14
jge 0x394ff
movq (%r15,%r13,8), %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4070
incq %r14
addq $0x8, %rbp
jmp 0x394d8
incq %r13
jmp 0x394c9
movq 0x10(%rsp), %rax
jmp 0x3951f
pushq $0x1
popq %rdi
movl %edi, %esi
callq 0x380d3
movq %rdx, %r15
movq (%rdx), %rcx
andq $0x0, (%rcx)
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_O2/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
pushq %rax
movq %rdi, %r12
callq 0x33f62
movl %eax, %ebx
movq %r12, %rdi
callq 0x340fb
movl %eax, %r14d
leaq 0x60917(%rip), %rsi     # 0x99e6f
pushq $0x10
popq %rdi
pushq $0x6
popq %rdx
callq 0x34f59
movq %rax, %r15
movl %ebx, %edi
movl %r14d, %esi
callq 0x380d3
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
leaq 0x62301(%rip), %rsi     # 0x9b87f
movq %r12, %rdi
callq 0x40f0
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
testl %ebx, %ebx
cmovlel %ecx, %ebx
movq %rbx, (%rsp)
movq %rax, %r12
shlq $0x3, %r14
leaq 0x60602(%rip), %r13     # 0x99ba8
xorl %ebp, %ebp
cmpq (%rsp), %rbp
je 0x395d8
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x395d3
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rdx
addq %rbx, %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbx
jmp 0x395b0
incq %rbp
jmp 0x395a8
movq %r12, %rdi
callq 0x42a0
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_O2/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 %rsi, %rbx
movq %rdi, %r15
shrq $0x20, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
testl %edi, %edi
movl $0x0, %r13d
cmovgl %edi, %r13d
leaq 0x6708b(%rip), %r14     # 0xa06e5
cmpq %r13, %r12
je 0x3968b
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x3967e
movq (%rbx,%r12,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4030
incq %rbp
jmp 0x39661
pushq $0xa
popq %rdi
callq 0x40d0
incq %r12
jmp 0x3965a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: 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 $0x7a138, %rsp          # imm = 0x7A138
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
leaq 0x621d7(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x39760
movq %rax, %r14
movq %r12, %r15
shrq $0x20, %r15
testl %ebp, %ebp
je 0x396ed
leaq 0x5c757(%rip), %rsi     # 0x95e34
movq %r14, %rdi
movl %r12d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x42e0
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r13
cmpq 0x8(%rsp), %rbp
je 0x39758
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x39748
movq %r13, %rdi
xorl %esi, %esi
leaq 0x5ef3e(%rip), %rdx     # 0x98665
callq 0x35305
movq (%rbx,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
incq %r12
jmp 0x39716
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x4150
incq %rbp
jmp 0x3970c
movq %r14, %rdi
callq 0x42a0
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: 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:
movslq %ecx, %rax
movslq %r8d, %rcx
movslq %esi, %rsi
movslq %edx, %rdx
cmpq %rdx, %rsi
jg 0x397a3
movq %rax, %r8
cmpq %rcx, %r8
jg 0x3979e
movq 0x8(%rdi), %r9
movq (%r9,%rsi,8), %r9
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x39786
incq %rsi
jmp 0x3977e
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x397dc
movl 0x4(%rdi), %esi
testl %esi, %esi
cmovlel %ecx, %esi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x397d7
movq 0x8(%rdi), %r9
movq (%r9,%rdx,8), %r9
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x397bf
incq %rdx
jmp 0x397af
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39831
xorl %edx, %edx
testl %edi, %edi
movl $0x0, %ecx
cmovgl %edi, %ecx
pushq $0x1
popq %r8
pushq $0x1
popq %rax
cmpq %rcx, %rdx
je 0x39833
leaq 0x1(%rdx), %r9
movq %r8, %r10
cmpl %edi, %r10d
jge 0x39829
movq (%rsi,%rdx,8), %r11
movsd (%r11,%r10,8), %xmm0
movq (%rsi,%r10,8), %r11
incq %r10
ucomisd (%r11,%rdx,8), %xmm0
jne 0x39831
jnp 0x39807
jmp 0x39831
incq %r8
movq %r9, %rdx
jmp 0x397fb
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %rbx
movapd 0x5c983(%rip), %xmm1    # 0x961d0
movapd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movslq %ecx, %r14
movslq %r8d, %r15
movslq %esi, %r12
movslq %edx, %r13
cmpq %r13, %r12
jg 0x398ae
movq %r14, %rbp
cmpq %r15, %rbp
jg 0x398a9
xorl %eax, %eax
callq 0x35c7f
cvtsi2sd %eax, %xmm0
divsd 0x5bc90(%rip), %xmm0    # 0x95518
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm0
addsd (%rsp), %xmm0
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x39870
incq %r12
jmp 0x39868
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: 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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movapd 0x5c8ff(%rip), %xmm1    # 0x961d0
movapd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x39931
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x3992c
xorl %eax, %eax
callq 0x35c7f
cvtsi2sd %eax, %xmm0
divsd 0x5bc0e(%rip), %xmm0    # 0x95518
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm0
addsd (%rsp), %xmm0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x398ee
incq %r14
jmp 0x398e3
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rax
shrq $0x20, %rax
movslq %ecx, %r15
cmpl %edx, %edi
je 0x399f4
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl %ebp, 0x4(%rsp)
movslq %ebp, %rbp
jle 0x39990
movslq 0x8(%rsp), %r12
movq %rbp, %r13
cmpq %r12, %r13
jge 0x39990
movq (%r14,%r13,8), %rdi
callq 0x34ff7
incq %r13
jmp 0x3997d
leaq (,%rbp,8), %rsi
movq %r14, %rdi
movl 0x4(%rsp), %r12d
movl %r12d, %edx
callq 0x34f30
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpl %r12d, %edi
jge 0x399e0
leaq (,%r15,8), %r13
movslq %edi, %r12
cmpq %rbp, %r12
jge 0x399e6
movq %r13, %rdi
leaq 0x604bb(%rip), %rsi     # 0x99e8a
pushq $0x1c
popq %rdx
callq 0x34f59
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0x399c0
movl 0x4(%rsp), %ebp
jmp 0x399ef
movl 0x4(%rsp), %ebp
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
cmpl %ebx, %eax
jne 0x39a13
shlq $0x20, %rbx
movl %ebp, %eax
orq %rbx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shlq $0x3, %r15
xorl %r12d, %r12d
testl %edi, %edi
movl $0x0, %r13d
cmovgl %edi, %r13d
cmpq %r12, %r13
je 0x399f8
movq (%r14,%r12,8), %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x34f30
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0x39a26
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x39a84
movl 0x4(%rdi), %esi
testl %esi, %esi
cmovlel %ecx, %esi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x39a7f
movq 0x8(%rdi), %r9
movq (%r9,%rdx,8), %r9
movsd (%r9,%r8,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r8,8)
incq %r8
jmp 0x39a5d
incq %rdx
jmp 0x39a4d
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x39ac7
movl 0x4(%rdi), %esi
testl %esi, %esi
cmovlel %ecx, %esi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x39ac2
movq 0x8(%rdi), %r9
movq (%r9,%rdx,8), %r9
movsd (%r9,%r8,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r8,8)
incq %r8
jmp 0x39aa0
incq %rdx
jmp 0x39a90
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
xorl %esi, %esi
cmpq %rax, %rsi
je 0x39b0b
movl 0x4(%rdi), %r8d
testl %r8d, %r8d
cmovlel %ecx, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x39b06
movq 0x8(%rdi), %r10
movq (%r10,%rsi,8), %r10
movq %rdx, (%r10,%r9,8)
incq %r9
jmp 0x39af0
incq %rsi
jmp 0x39add
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x39b43
movl 0x4(%rdi), %esi
testl %esi, %esi
cmovlel %ecx, %esi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x39b3e
movq 0x8(%rdi), %r9
movq (%r9,%rdx,8), %r9
andq $0x0, (%r9,%r8,8)
incq %r8
jmp 0x39b27
incq %rdx
jmp 0x39b17
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39bd1
movq %rax, %rcx
shrq $0x20, %rcx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rax, %rsi
je 0x39bdd
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x39bcc
movq (%rdx,%rsi,8), %r9
movsd (%r9,%r8,8), %xmm0
movq 0x8(%rdi), %r9
movq (%r9,%rsi,8), %r9
addsd (%r9,%r8,8), %xmm0
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x39ba4
incq %rsi
jmp 0x39b9c
leaq 0x6050b(%rip), %rdi     # 0x9a0e3
jmp 0x4090
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
cmpq %rdx, %rdi
jne 0x39c47
movq %rcx, %r15
movq %r14, %r12
shrq $0x20, %r12
movl %r14d, %edi
movl %r12d, %esi
callq 0x380d3
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %r14, %rcx
je 0x39c55
xorl %esi, %esi
cmpq %rsi, %r12
je 0x39c42
movq (%rbx,%rcx,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%r15,%rcx,8), %rdi
addsd (%rdi,%rsi,8), %xmm0
movq (%rdx,%rcx,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0x39c1d
incq %rcx
jmp 0x39c16
leaq 0x60495(%rip), %rdi     # 0x9a0e3
callq 0x4090
jmp 0x39c5b
movq %rax, %r14
movq %rdx, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/matrix.c
// Function: matrix_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 0x39cbd
movq %rax, %rcx
shrq $0x20, %rcx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rax, %rsi
je 0x39cc9
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x39cb8
movq (%rdx,%rsi,8), %r9
movq 0x8(%rdi), %r10
movq (%r10,%rsi,8), %r10
movsd (%r10,%r8,8), %xmm0
subsd (%r9,%r8,8), %xmm0
movsd %xmm0, (%r10,%r8,8)
incq %r8
jmp 0x39c90
incq %rsi
jmp 0x39c88
leaq 0x6041f(%rip), %rdi     # 0x9a0e3
jmp 0x4090
retq