LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_mlpgeneric
void* load_model_mlpgeneric(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
	int i;
 Mlpnetworkptr m;
	m = safemalloc(sizeof(Mlpnetwork), "load_model_mlpgeneric", 3);
	fscanf(infile, "%d %d %d", &(m->P.dimnum), &(m->P.classnum), &(m->P.layernum));
	for (i = 0; i < m->P.layernum; i++)
		 fscanf(infile, "%d", &(m->P.hidden[i]));
	m->weights = safemalloc((m->P.layernum + 1) * sizeof(matrix), "load_model_mlpgeneric", 7);
	for (i = 0; i < m->P.layernum; i++)
			if (i == 0)
	 			m->weights[i] = load_matrix(infile, m->P.hidden[i], m->P.dimnum + 1);
			else
			 	m->weights[i] = load_matrix(infile, m->P.hidden[i], m->P.hidden[i-1] + 1);
	if (m->P.layernum == 0)
			m->weights[m->P.layernum] = load_matrix(infile, m->P.classnum, m->P.dimnum + 1);
	else
			m->weights[m->P.layernum] = load_matrix(infile, m->P.classnum, m->P.hidden[m->P.layernum - 1] + 1);	
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x6bdac(%rip), %rsi     # 0xa6cd0
movl $0x98, %edi
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x8(%rax), %rcx
leaq 0xc(%rax), %r15
leaq 0x5c(%rax), %r12
leaq 0x6a99a(%rip), %rsi     # 0xa58e3
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %r8
xorl %eax, %eax
callq 0x4070
movl 0x5c(%rbx), %eax
testl %eax, %eax
movq %r15, (%rsp)
jle 0x3af96
leaq 0x50(%rbx), %r13
leaq 0x72bee(%rip), %rbp     # 0xadb5d
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
incq %r15
movslq (%r12), %rax
addq $0x4, %r13
cmpq %rax, %r15
jl 0x3af72
movq (%rsp), %r15
movq %r14, 0x8(%rsp)
movslq %eax, %rdi
shlq $0x4, %rdi
addq $0x10, %rdi
leaq 0x6bd23(%rip), %rsi     # 0xa6cd0
movl $0x7, %edx
callq 0x390f5
movq %rax, (%rbx)
movl 0x5c(%rbx), %eax
testl %eax, %eax
jle 0x3b022
leaq 0x50(%rbx), %rbp
xorl %r13d, %r13d
movq %rbp, 0x10(%rsp)
xorl %r15d, %r15d
movq 0x8(%rsp), %r12
movq (%rbx), %rax
leaq (%rax,%r13), %r14
leaq -0x4(%rbp), %rcx
testq %r13, %r13
cmoveq (%rsp), %rcx
movq %rbp, %rdx
cmoveq 0x10(%rsp), %rdx
cmoveq %rax, %r14
movl (%rdx), %esi
movl (%rcx), %edx
incl %edx
movq %r12, %rdi
callq 0x3a488
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
incq %r15
movslq 0x5c(%rbx), %rax
addq $0x10, %r13
addq $0x4, %rbp
cmpq %rax, %r15
jl 0x3afd5
movq (%rsp), %r15
movq (%rbx), %rcx
cltq
movq %rax, %r14
shlq $0x4, %r14
addq %rcx, %r14
subl $0x1, %eax
cltq
leaq 0x50(%rbx,%rax,4), %rax
cmovbq %r15, %rax
cmovbq %rcx, %r14
movl 0x8(%rbx), %esi
movl (%rax), %edx
incl %edx
movq 0x8(%rsp), %rdi
callq 0x3a488
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
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_O1/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_multildt
void* load_model_multildt(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
 Decisionnodeptr tmp;
 tmp = safemalloc(sizeof(Decisionnode), "load_model_c45", 2);
 tmp->left = NULL;
 tmp->parent = NULL;
 tmp->right = NULL;
 tmp->string = NULL;
	tmp->rule = NULL;
	tmp->instances = NULL;
	tmp->conditiontype = MULTIVARIATE_CONDITION;
 fscanf(infile, "%d", &(tmp->featureno));
	if (tmp->featureno == LEAF_NODE)
	 {
		 fscanf(infile, "%d", &(tmp->classno));
			tmp->counts = load_array_int(infile, d->classno);
	 }
	else
	 {
  	fscanf(infile, "%lf", &(tmp->w0));
			tmp->w = load_matrix(infile, 1, d->multifeaturecount - 1);
		 tmp->counts = NULL;
 		tmp->left = load_model_multildt(infile, d);
   tmp->left->parent = tmp;
			tmp->right = load_model_multildt(infile, d);
   tmp->right->parent = tmp;
	 }
 return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x6bc20(%rip), %rsi     # 0xa6c9f
movl $0x160, %edi            # imm = 0x160
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
xorl %eax, %eax
movq %rax, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %rax, 0x20(%rbx)
movl $0x1, 0x98(%rbx)
leaq 0x30(%rbx), %rdx
leaq 0x72aa3(%rip), %rsi     # 0xadb5d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, 0x30(%rbx)
je 0x3b132
movq %rbx, %rdx
addq $0x48, %rdx
leaq 0x6bb38(%rip), %rsi     # 0xa6c10
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3a488
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
movq $0x0, 0xa0(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b06d
movq %rax, (%rbx)
movq %rbx, 0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b06d
movq %rax, 0x8(%rbx)
movq %rbx, 0x18(%rax)
jmp 0x3b15d
movq %rbx, %rdx
addq $0x34, %rdx
leaq 0x72a1d(%rip), %rsi     # 0xadb5d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x10(%r15), %esi
movq %r14, %rdi
callq 0x3a580
movq %rax, 0xa0(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_nodeboundedtree
void* load_model_nodeboundedtree(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
 Decisionnodeptr tmp;
 tmp = safemalloc(sizeof(Decisionnode), "load_model_nodeboundedtree", 2);
 tmp->left = NULL;
 tmp->parent = NULL;
 tmp->right = NULL;
 tmp->string = NULL;
	tmp->rule = NULL;
	tmp->instances = NULL;
	tmp->conditiontype = HYBRID_CONDITION;
 fscanf(infile, "%d", &(tmp->featureno));
	switch (tmp->featureno)
	 {
	  case LEAF_NODE:fscanf(infile, "%d", &(tmp->classno));
				              tmp->counts = load_array_int(infile, d->classno);
																		break;
			case LINEAR   :fscanf(infile, "%lf", &(tmp->w0));
               			tmp->w = load_matrix(infile, 1, d->multifeaturecount - 1);
		                tmp->counts = NULL;
                  break;
			case QUADRATIC:fscanf(infile, "%lf", &(tmp->w0));
				              tmp->w = load_matrix(infile, 1, multifeaturecount_2d(d));
		                tmp->counts = NULL;
                  break;
			default       :fscanf(infile, "%lf", &(tmp->split));
		                tmp->counts = NULL;
																		break;
	 }
	if (tmp->featureno != LEAF_NODE)
	 {
 		tmp->left = load_model_nodeboundedtree(infile, d);
			tmp->right = load_model_nodeboundedtree(infile, d);
	 }
 return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6bb6b(%rip), %rsi     # 0xa6ce6
movl $0x160, %edi            # imm = 0x160
movl $0x2, %edx
callq 0x390f5
movq %rax, %r15
xorl %eax, %eax
movq %rax, 0x58(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
movl $0x2, 0x98(%r15)
leaq 0x30(%r15), %rdx
leaq 0x729a4(%rip), %rsi     # 0xadb5d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x30(%r15), %eax
movq %r15, %rdx
cmpl $-0x3, %eax
je 0x3b22c
cmpl $-0x2, %eax
je 0x3b202
cmpl $-0x1, %eax
jne 0x3b265
addq $0x34, %rdx
leaq 0x72975(%rip), %rsi     # 0xadb5d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a580
movq %rax, %r12
jmp 0x3b27d
addq $0x48, %rdx
leaq 0x6ba03(%rip), %rsi     # 0xa6c10
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
jmp 0x3b256
addq $0x48, %rdx
leaq 0x6b9d9(%rip), %rsi     # 0xa6c10
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq %rbx, %rdi
callq 0x13726
movq %r14, %rdi
movl $0x1, %esi
movl %eax, %edx
callq 0x3a488
movq %rax, 0x38(%r15)
movq %rdx, 0x40(%r15)
jmp 0x3b27d
addq $0x28, %rdx
leaq 0x6b9a0(%rip), %rsi     # 0xa6c10
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq %r12, 0xa0(%r15)
cmpl $-0x1, 0x30(%r15)
je 0x3b2a8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b166
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b166
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_nearestmean
void* load_model_nearestmean(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
 Instanceptr m;
 int i;
 Instanceptr tmp, tmpbefore = NULL;
 for (i = 0; i < d->classno; i++)
  {
   tmp = safemalloc(sizeof(Instance), "load_model_gaussian", 7);
   *tmp = load_instance_discrete(infile, d);
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     m = tmp;
   tmpbefore = tmp;
  }
 tmp->next = NULL;
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
movl $0x30, %edi
leaq 0x6b98c(%rip), %rsi     # 0xa6c68
movl $0x7, %edx
callq 0x390f5
movq %rax, %r13
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3a86b
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 %rbp, %rbp
je 0x3b326
movq %r13, 0x10(%rbp)
movq %r12, %rax
incl %r15d
movq %r13, %rbp
movq %rax, %r12
cmpl 0x10(%rbx), %r15d
jl 0x3b2d0
movq $0x0, 0x10(%r13)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6b99d(%rip), %r12     # 0xa6d01
movl $0x20, %edi
movq %r12, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r15
movl 0x10(%rbx), %esi
movl 0x1bc(%rbx), %edx
movq %r14, %rdi
callq 0x3a5ec
movq %rax, (%r15)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a514
movq %rax, 0x10(%r15)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a514
movq %rax, 0x8(%r15)
movslq 0x10(%rbx), %rdi
shlq $0x3, %rdi
movq %r12, %rsi
movl $0x7, %edx
callq 0x390f5
movq %rax, 0x18(%r15)
cmpl $0x0, 0x10(%rbx)
jle 0x3b450
leaq 0x30f20(%rbx), %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
movslq 0x1bc(%rbx), %rdi
shlq $0x3, %rdi
leaq 0x6b914(%rip), %rsi     # 0xa6d01
movl $0xa, %edx
callq 0x390f5
movq 0x18(%r15), %rcx
movq %rax, (%rcx,%rbp,8)
cmpl $0x0, 0x1bc(%rbx)
jle 0x3b444
movq (%rsp), %r13
xorl %r12d, %r12d
cmpl $0x1, -0x18(%r13)
jne 0x3b42e
movl (%r13), %esi
movq %r14, %rdi
callq 0x3a514
movq 0x18(%r15), %rcx
movq (%rcx,%rbp,8), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movslq 0x1bc(%rbx), %rax
addq $0x340, %r13            # imm = 0x340
cmpq %rax, %r12
jl 0x3b40f
incq %rbp
movslq 0x10(%rbx), %rax
cmpq %rax, %rbp
jl 0x3b3db
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_O1/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 0x6b89d(%rip), %r12     # 0xa6d17
movl $0x20, %edi
movq %r12, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r15
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a514
movq %rax, 0x10(%r15)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a514
movq %rax, 0x18(%r15)
movslq 0x10(%rbx), %rdi
shlq $0x4, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, (%r15)
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x3b504
movl $0x8, %r12d
xorl %r13d, %r13d
movq (%r15), %rbp
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3a488
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
movslq 0x10(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x3b4d5
movslq %eax, %rdi
shlq $0x4, %rdi
leaq 0x6b805(%rip), %rsi     # 0xa6d17
movl $0x8, %edx
callq 0x390f5
movq %rax, 0x8(%r15)
cmpl $0x0, 0x10(%rbx)
jle 0x3b562
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rbp
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3a488
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
movslq 0x10(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x3b52f
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_O1/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 0x6b79f(%rip), %r12     # 0xa6d2b
movl $0x30, %edi
movq %r12, %rsi
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x4(%rax), %rcx
leaq 0x6a33a(%rip), %rsi     # 0xa58e6
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%r15), %esi
movq %r14, %rdi
callq 0x3a514
movq %rax, 0x8(%rbx)
movslq 0x10(%r15), %rdi
shlq $0x4, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, 0x10(%rbx)
cmpl $0x0, 0x10(%r15)
jle 0x3b621
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rbp
movl (%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3a488
movq %rax, -0x8(%rbp,%r12)
movq %rdx, (%rbp,%r12)
incq %r13
movslq 0x10(%r15), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x3b5f2
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3a488
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_O1/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 0x6b536(%rip), %rsi     # 0xa6d4e
movl $0x70, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x4(%rax), %r12
leaq 0x6b528(%rip), %rsi     # 0xa6d5d
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
cmpl $0x0, (%rbx)
js 0x3b878
cmpb $0x2a, (%r12)
jne 0x3b8b0
leaq 0x18(%rbx), %rdx
leaq 0x6b3b4(%rip), %r15     # 0xa6c10
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4070
movq %rbx, %rdx
addq $0x10, %rdx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x3b8c1
movq %rbx, %rdx
addq $0x30, %rdx
leaq 0x6b38a(%rip), %rsi     # 0xa6c10
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3a488
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
jmp 0x3b8c8
movq %rbx, %rdx
addq $0x8, %rdx
leaq 0x6b352(%rip), %rsi     # 0xa6c10
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_O1/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 0x6b46c(%rip), %rsi     # 0xa6d63
movl $0x38, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x28(%rax), %r12
leaq 0x8(%rax), %r8
leaq 0x4(%rax), %r9
leaq 0x6b451(%rip), %rsi     # 0xa6d6d
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a580
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b803
movq %rax, %r13
movq %rax, 0x18(%r15)
cmpl $0x2, 0x28(%r15)
jl 0x3b975
movl $0x1, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b803
movq %rax, 0x48(%r13)
incl %ebp
movq %rax, %r13
cmpl (%r12), %ebp
jl 0x3b959
jmp 0x3b978
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_O1/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 0x6b3c8(%rip), %rsi     # 0xa6d76
movl $0x28, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x14(%rax), %rdx
leaq 0x10(%rax), %r12
leaq 0x6b3a2(%rip), %rsi     # 0xa6d71
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x3a580
movq %rax, 0x18(%rbx)
cmpl $0x0, 0x10(%rbx)
jle 0x3ba2a
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b8df
movq %rax, %r13
movq %rax, (%rbx)
cmpl $0x2, 0x10(%rbx)
jl 0x3ba32
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b8df
movq %rax, 0x30(%r13)
incl %ebp
movq %rax, %r13
cmpl (%r12), %ebp
jl 0x3ba0e
jmp 0x3ba35
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x3ba39
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_O1/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 0x6b325(%rip), %rsi     # 0xa6d88
movl $0x38, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x10(%rax), %r12
leaq 0x720dd(%rip), %rsi     # 0xadb5d
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a580
movq %rax, 0x30(%r15)
cmpl $0x0, 0x10(%r15)
jle 0x3badc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b8df
movq %rax, %r13
movq %rax, (%r15)
cmpl $0x2, 0x10(%r15)
jl 0x3bae5
movl $0x1, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b8df
movq %rax, 0x30(%r13)
incl %ebp
movq %rax, %r13
cmpl (%r12), %ebp
jl 0x3bac0
jmp 0x3bae8
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0x3baec
movq %r13, %rax
movq %rax, 0x8(%r15)
movslq 0x1bc(%rbx), %rdi
shlq $0x4, %rdi
leaq 0x6b28a(%rip), %rsi     # 0xa6d88
movl $0x14, %edx
callq 0x390f5
movq %rax, 0x28(%r15)
cmpl $0x0, 0x1bc(%rbx)
jle 0x3bb75
leaq 0x30f20(%rbx), %r12
movl $0x8, %r13d
xorl %ebp, %ebp
movq %rbx, (%rsp)
cmpl $0x1, -0x18(%r12)
jne 0x3bb5b
movq %r14, %rbx
movq %r15, %r14
movq 0x28(%r15), %r15
movl (%r12), %edx
movq %rbx, %rdi
movl %edx, %esi
callq 0x3a488
movq %rax, -0x8(%r15,%r13)
movq %rdx, (%r15,%r13)
movq %r14, %r15
movq %rbx, %r14
movq (%rsp), %rbx
incq %rbp
movslq 0x1bc(%rbx), %rax
addq $0x10, %r13
addq $0x340, %r12            # imm = 0x340
cmpq %rax, %rbp
jl 0x3bb28
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_O1/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 0x6affe(%rip), %rsi     # 0xa6deb
movl $0x18, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x6ae0a(%rip), %rsi     # 0xa6c10
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3a488
movq %rax, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6afb5(%rip), %rsi     # 0xa6e00
movl $0x48, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x40(%rax), %rdx
leaq 0x71cf5(%rip), %rsi     # 0xadb5d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
leaq 0x8(%rbx), %rdx
cmpl $0x2, 0x1c0(%r15)
jne 0x3bea6
leaq 0x6af44(%rip), %rsi     # 0xa6dcb
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3a514
movl $0x20, %ecx
jmp 0x3bef8
leaq 0x18(%rbx), %r8
movq %rbx, %r9
addq $0x10, %r9
leaq 0x6af5f(%rip), %rsi     # 0xa6e17
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4070
movl 0x40(%rbx), %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3a5ec
movq %rax, 0x28(%rbx)
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x3a488
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_O1/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 0x6a91c(%rip), %rsi     # 0xa6e46
movl $0x18, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
leaq 0x7161a(%rip), %rsi     # 0xadb5d
xorl %r12d, %r12d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
xorl %r13d, %r13d
movl $0x30, %edi
leaq 0x6a8e4(%rip), %rsi     # 0xa6e46
movl $0x6, %edx
callq 0x390f5
movq %rax, %rbp
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x3a7c7
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 0x3c5ab
movq %rbp, 0x10(%r12)
movq %r15, %rax
incl %r13d
movl (%r14), %esi
movq %rax, %r15
movq %rbp, %r12
cmpl %esi, %r13d
jl 0x3c556
movq $0x0, 0x10(%rbp)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x3a514
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_O1/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 0x38de9
movl %eax, %r14d
leal (%r12,%r15), %ebp
leaq 0x6a89b(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %eax, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %rdx
movl %r14d, %eax
testl %r15d, %r15d
jle 0x3c68d
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %esi, %esi
testl %r14d, %r14d
jle 0x3c685
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 0x3c671
incq %rsi
cmpq %rcx, %rsi
jne 0x3c660
testl %r12d, %r12d
jle 0x3c6cd
movslq %r15d, %rcx
movslq %ebp, %rsi
movq %rcx, %rdi
testl %r14d, %r14d
jle 0x3c6c5
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 0x3c6b1
incq %rdi
cmpq %rsi, %rdi
jl 0x3c69b
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_O1/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 0x6a78b(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %r15d, %edx
movl $0x3, %r9d
callq 0x39245
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x1, %eax
testl %r15d, %r15d
jle 0x3c83c
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movl $0x1, %r8d
xorl %ebp, %ebp
xorpd %xmm2, %xmm2
movq %r14, (%rsp)
leaq (,%rbp,8), %r12
movq %rbp, %r13
movq (%r14,%rbp,8), %rax
movsd (%rax,%r13,8), %xmm0
testq %rbp, %rbp
je 0x3c7c0
movq (%r14,%r13,8), %rcx
movq %r8, %rdx
leal -0x2(%rdx), %esi
movsd (%rax,%rsi,8), %xmm1
mulsd (%rcx,%rsi,8), %xmm1
subsd %xmm1, %xmm0
decq %rdx
cmpq $0x1, %rdx
jg 0x3c7a6
cmpq %r13, %rbp
jne 0x3c7d7
ucomisd %xmm0, %xmm2
jae 0x3c83a
ucomisd %xmm2, %xmm0
jb 0x3c7ea
sqrtsd %xmm0, %xmm0
jmp 0x3c809
movq 0x8(%rbx), %rax
movq (%rax,%rbp,8), %rcx
divsd (%rcx,%rbp,8), %xmm0
leaq (%rax,%r13,8), %rax
jmp 0x3c810
movq %r15, %r14
movq %rbx, %r15
movq %r8, %rbx
callq 0x4300
movq %rbx, %r8
movq %r15, %rbx
movq %r14, %r15
movq (%rsp), %r14
xorpd %xmm2, %xmm2
movq 0x8(%rbx), %rax
addq %r12, %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %r13
cmpq %r15, %r13
jne 0x3c790
incq %rbp
incq %r8
cmpq %r15, %rbp
jne 0x3c785
movl $0x1, %eax
jmp 0x3c83c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_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 0x6a471(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl $0x3, %r9d
callq 0x39245
movq %rax, %r15
testl %ebx, %ebx
jle 0x3caa8
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 0x3ca90
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_O1/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 0x693a2(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %edx, 0x4(%rsp)
movl %r14d, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %rdx
cmpl %r12d, %r15d
jl 0x3db93
movslq %ebp, %rax
movslq %r12d, %rcx
incl %r15d
shlq $0x3, %rax
movq %rcx, %rsi
cmpl %ebp, %ebx
jl 0x3db8b
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 0x3db77
incq %rsi
cmpl %esi, %r15d
jne 0x3db5e
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_O1/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 0x692f9(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %r14d, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %rdx
testl %ebx, %ebx
jle 0x3dc27
movl %ebx, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %r14d, %r14d
jle 0x3dc1f
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 0x3dc08
incq %rcx
cmpq %rax, %rcx
jne 0x3dbfd
shlq $0x20, %rbx
orq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6928b(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %rdx
movl %ebx, %ecx
testl %ebx, %ebx
jle 0x3dc7f
xorl %eax, %eax
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
movq (%rdx,%rax,8), %rdi
movq %rsi, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x3dc6f
movq %rcx, %rax
shlq $0x20, %rax
orq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3dd54
movq %rcx, %r15
movq %r13, %r12
shrq $0x20, %r12
leaq 0x6920c(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebx, %edx
movl %r12d, %ecx
movl $0x3, %r9d
callq 0x39245
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
andq %r13, %rdx
movl %ebx, %ecx
orq %rdx, %rcx
testl %ebx, %ebx
jle 0x3dd4c
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %r12d, %r12d
jle 0x3dd44
movq (%rax,%rdx,8), %rsi
xorl %edi, %edi
movq $0x0, (%rsi,%rdi,8)
testl %ebp, %ebp
jle 0x3dd3c
movq (%r14,%rdx,8), %r8
movsd (%rsi,%rdi,8), %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 0x3dd1b
incq %rdi
cmpq %r12, %rdi
jne 0x3dd03
incq %rdx
cmpq %rbx, %rdx
jne 0x3dcf8
movq %rcx, %rbx
movq %rax, %r14
jmp 0x3dd60
leaq 0x6926d(%rip), %rdi     # 0xa6fc8
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_O1/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 0x69132(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %r14
movl %ebp, %r15d
testl %ebp, %ebp
jle 0x3ddf3
movl %ebx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x3ddeb
xorl %ebp, %ebp
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x39f62
movq (%r14,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r12
jne 0x3ddc9
incq %r13
cmpq %r15, %r13
jne 0x3ddc3
shlq $0x20, %rbx
orq %rbx, %r15
movq %r15, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: 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 0x3ded9
movq %rdi, %rbx
leaq 0x68f41(%rip), %rsi     # 0xa6d71
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 0x69077(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %r13d, %edx
movl %r14d, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %r15
shlq $0x20, %r14
orq %r13, %r14
cmpl $0x0, (%r12)
jle 0x3df16
movq %r14, 0x10(%rsp)
leaq 0x68d7f(%rip), %r12     # 0xa6c10
xorl %r13d, %r13d
cmpl $0x0, 0x8(%rsp)
jle 0x3dec5
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 0x3dea0
incq %r13
movslq 0xc(%rsp), %rax
cmpq %rax, %r13
jl 0x3de94
movq 0x10(%rsp), %r14
jmp 0x3df16
leaq 0x68fec(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rax, %r15
movq (%rax), %rax
movq $0x0, (%rax)
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r14, %rax
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_O1/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, %r15
callq 0x37e22
movl %eax, %ebp
movq %r15, %rdi
callq 0x37ff4
movl %eax, %ebx
leaq 0x68f4b(%rip), %rsi     # 0xa6e9f
movl $0x10, %edi
movl $0x6, %edx
callq 0x390f5
movq %rax, %r14
leaq 0x68f5f(%rip), %r8      # 0xa6ecc
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x39245
movq %rbx, 0x8(%rsp)
shlq $0x20, %rbx
movl %ebp, %edx
movq %rdx, 0x10(%rsp)
leaq (%rdx,%rbx), %rcx
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
leaq 0x6a8e7(%rip), %rsi     # 0xa888f
movq %r15, %rdi
callq 0x40f0
movq %rax, %r15
testl %ebp, %ebp
jle 0x3dffd
movl 0x8(%rsp), %ebp
shlq $0x3, %rbp
leaq 0x68c4a(%rip), %r12     # 0xa6c10
xorl %ebx, %ebx
cmpl $0x0, 0x8(%rsp)
jle 0x3dff3
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
cmpq %r13, %rbp
jne 0x3dfd2
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x3dfc8
movq %r15, %rdi
callq 0x42a0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: matrix_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 0x3e0af
movq %rsi, %rbx
movq %r14, %r12
shrq $0x20, %r12
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x6f66e(%rip), %r15     # 0xad6e9
testl %r12d, %r12d
jle 0x3e09d
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 0x3e082
movl $0xa, %edi
callq 0x40d0
incq %r13
cmpq %r14, %r13
jne 0x3e07b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/matrix.c
// Function: 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 0x6a7c3(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x3e1a1
movq %rax, %r15
movq %rbx, 0x18(%rsp)
movq %r13, %rbx
shrq $0x20, %rbx
testl %ebp, %ebp
je 0x3e115
leaq 0x64d26(%rip), %rsi     # 0xa2e2c
movq %r15, %rdi
movl %r13d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x42e0
testl %r13d, %r13d
jle 0x3e199
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq %r13, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
testl %ebx, %ebx
leaq 0x67556(%rip), %r12     # 0xa568d
movq %r15, %rbx
movq 0x18(%rsp), %r15
leaq 0x20(%rsp), %rbp
jle 0x3e177
xorl %r13d, %r13d
movq %rbp, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x39529
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 0x3e149
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 0x3e12e
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_O1/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 0x3e1f8
movslq %ecx, %r10
movslq %esi, %rax
incl %edx
leaq (,%r10,8), %rsi
movl %r8d, %r9d
subl %r10d, %r9d
incl %r9d
cmpl %r8d, %ecx
jg 0x3e1f1
movq 0x8(%rdi), %r10
movq (%r10,%rax,8), %r10
addq %rsi, %r10
xorl %r11d, %r11d
movsd %xmm0, (%r10,%r11,8)
incq %r11
cmpl %r11d, %r9d
jne 0x3e1e3
incq %rax
cmpl %eax, %edx
jne 0x3e1d0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e22b
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x3e223
movq 0x8(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %r8d, %r8d
movsd %xmm0, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x3e215
incq %rdx
cmpq %rax, %rdx
jne 0x3e206
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rcx
shrq $0x20, %rcx
cmpl %ecx, %edi
jne 0x3e2a1
movl $0x1, %eax
testl %edi, %edi
jle 0x3e2a3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rdx
sarq $0x20, %rdx
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movq %rsi, %r9
xorl %r10d, %r10d
movq %r10, %r11
incq %r10
cmpq %rdx, %r10
jge 0x3e28f
movq (%rsi,%r11,8), %rbx
addq %r8, %rbx
movl $0x1, %r14d
movsd (%rbx,%r14,8), %xmm0
movq (%r9,%r14,8), %r15
ucomisd (%r15,%r11,8), %xmm0
jne 0x3e2a4
jp 0x3e2a4
incq %r14
cmpq %r14, %rcx
jne 0x3e273
addq $0x8, %r9
addq $0x8, %r8
decq %rcx
cmpq %rdi, %r10
jne 0x3e25b
jmp 0x3e2a6
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e35d
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
movapd 0x64efa(%rip), %xmm2    # 0xa31d0
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 0x3e355
movl 0x4(%rsp), %r12d
movq 0x8(%rsp), %rbx
xorl %eax, %eax
callq 0x39f18
movsd 0x641fb(%rip), %xmm3    # 0xa2518
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 0x3e30e
incq %r13
cmpl %r13d, %r14d
jne 0x3e2ff
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq