LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/metaclassification.c
// Function: free_model_of_meta_classification_algorithm
void free_model_of_meta_classification_algorithm(int meta_algorithm, int algorithm, void** model, Datasetptr current_dataset)
{
 int i, d;
 d = current_dataset->classno;
 switch (meta_algorithm)
  {
   case         ONE_VERSUS_ONE:current_dataset->classno = 2;
                               for (i = 0; i < d * (d - 1) / 2; i++)
                                 free_model_of_supervised_algorithm(algorithm, model[i], current_dataset);
                               current_dataset->classno = d;
                               break;
   case        ONE_VERSUS_REST:current_dataset->classno = 2;
                               for (i = 0; i < d; i++)
                                 free_model_of_supervised_algorithm(algorithm, model[i], current_dataset);
                               current_dataset->classno = d;
                               break;
   case BAGGING_CLASSIFICATION:for (i = 0; i < get_parameter_i("weaklearnercount"); i++)
                                 free_model_of_supervised_algorithm(algorithm, model[i], current_dataset);
                               break;
  }
 safe_free(model);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x64, %eax
je 0x60688
jmp 0x6066d
movl -0x24(%rbp), %eax
subl $0x65, %eax
je 0x606ef
jmp 0x60677
movl -0x24(%rbp), %eax
subl $0x66, %eax
je 0x60738
jmp 0x6077f
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0x606e0
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x5ac0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6069a
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x6077f
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6072c
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x5ac0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60701
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x6077f
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq 0x86669(%rip), %rdi     # 0xe6db5
callq 0x78f10
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x6077d
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x5ac0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6073f
jmp 0x6077f
movq -0x10(%rbp), %rdi
callq 0x52e80
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/metaregression.c
// Function: train_bagging_regression
void** train_bagging_regression(Instanceptr* trdata, Instanceptr* cvdata, int algorithm, void* parameters)
{
 int i, learner_count;
 Instanceptr traindata, validationdata;
 void** model;
 learner_count = get_parameter_i("weaklearnercount");
 model = safemalloc(sizeof(void*) * learner_count, "train_bagging_regression", 4);
 for (i = 0; i < learner_count; i++)
  {
   traindata = bootstrap_sample_without_stratification(*trdata);
   if (is_cvdata_needed(algorithm))
     validationdata = bootstrap_sample_without_stratification(*cvdata);
   else
     validationdata = NULL;
   model[i] = regression_algorithms[algorithm - ONEFEATURE].train_algorithm(&traindata, &validationdata, parameters);
  }
 return model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x862a7(%rip), %rdi     # 0xe6db5
callq 0x78f10
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x86325(%rip), %rsi     # 0xe6e4a
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x60bc0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x45270
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x7050
cmpl $0x0, %eax
je 0x60b71
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x45270
movq %rax, -0x38(%rbp)
jmp 0x60b79
movq $0x0, -0x38(%rbp)
movl -0x14(%rbp), %eax
subl $0x7d0, %eax            # imm = 0x7D0
movslq %eax, %rcx
leaq 0xa3c75(%rip), %rax     # 0x104800
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq *%rax
movq %rax, %rdx
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x60b3a
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/metaregression.c
// Function: test_bagging_regression
Prediction test_bagging_regression(Instanceptr data, void** model, int algorithm, void* parameters, double* posterior)
{
 int i, learner_count;
 double* outputs;
 Prediction result, prediction;
 learner_count = get_parameter_i("weaklearnercount");
 outputs = safemalloc(sizeof(double) * learner_count, "test_bagging_regression", 4);
 for (i = 0; i < learner_count; i++)
  {
   prediction = regression_algorithms[algorithm - ONEFEATURE].test_algorithm(data, model[i], parameters, NULL);
   outputs[i] = prediction.regvalue;
  }
 qsort(outputs, learner_count, sizeof(double), sort_function_double_ascending);
 result.regvalue = outputs[learner_count / 2];
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq 0x861b2(%rip), %rdi     # 0xe6db5
callq 0x78f10
movl %eax, -0x30(%rbp)
movslq -0x30(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x86249(%rip), %rsi     # 0xe6e63
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x60ca6
movl -0x14(%rbp), %eax
subl $0x7d0, %eax            # imm = 0x7D0
movslq %eax, %rcx
leaq 0xa3bb7(%rip), %rax     # 0x104800
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x20(%rbp), %rcx
leaq -0xa8(%rbp), %rdi
xorl %r8d, %r8d
callq *%rax
leaq -0x70(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x38, %edx
callq 0x42b0
movsd -0x70(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x60c2f
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rsi
movl $0x8, %edx
leaq -0xd7fa(%rip), %rcx     # 0x534c0
callq 0x41f0
movq -0xb8(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0x30(%rbp), %eax
movl $0x2, %esi
cltd
idivl %esi
movq -0xc0(%rbp), %rdx
movl %eax, %esi
movq -0xb0(%rbp), %rax
movslq %esi, %rsi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rcx)
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/metaregression.c
// Function: free_model_of_meta_regression_algorithm
void free_model_of_meta_regression_algorithm(int meta_algorithm, int algorithm, void** model, Datasetptr current_dataset)
{
 int i;
 switch (meta_algorithm)
  {
   case BAGGING_REGRESSION:for (i = 0; i < get_parameter_i("weaklearnercount"); i++)
                             free_model_of_supervised_algorithm(algorithm, model[i], current_dataset);
                           break;
  }
 safe_free(model);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
subl $0xc8, %eax
jne 0x60d79
jmp 0x60d32
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
leaq 0x8606f(%rip), %rdi     # 0xe6db5
callq 0x78f10
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0x60d77
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x5ac0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60d39
jmp 0x60d79
movq -0x10(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mixture.c
// Function: mixture_class_at_value
int mixture_class_at_value(Mixtureptr mix, double value)
{
	/*!Last Changed 26.01.2005*/
	int i, j, index;
	double maxprob = -1, prob;
	for (i = 0; i < mix->classcount; i++)
	 {
		 prob = 0;
			for (j = 0; j < mix->numberofmodels[i]; j++)
				 prob += mix->mixtureprob[i][j] * gaussian(value, mix->mixturemeans[i][j], mix->mixturedeviations[i][j]);
			if (prob > maxprob)
			 {
				 maxprob = prob;
					index = i;
			 }
	 }
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd 0x8193f(%rip), %xmm0    # 0xe2a48
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x611f9
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x611cd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
callq 0xc2650
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x61133
movsd -0x30(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x611e9
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x611eb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x61115
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mixture.c
// Function: mixture_value
double mixture_value(Mixtureptr mix, double value, int classno)
{
	/*!Last Changed 26.01.2005*/
	int i, j;
	double totalprob = 0, prob, realprob;
	for (i = 0; i < mix->classcount; i++)
	 {
		 prob = 0;
			for (j = 0; j < mix->numberofmodels[i]; j++)
				 prob += mix->mixtureprob[i][j] * gaussian(value, mix->mixturemeans[i][j], mix->mixturedeviations[i][j]);
			if (i == classno)
				 realprob = prob;
			totalprob += prob;
	 }
	return realprob / totalprob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6131a
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x612eb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
callq 0xc2650
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61251
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x612fd
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x61233
movsd -0x38(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mixture.c
// Function: free_mixture
void free_mixture(Mixtureptr mix)
{
	/*!Last Changed 26.01.2005*/
	safe_free(mix->numberofmodels);
	safe_free(mix->classpriors);
	free_2d((void**)mix->mixtureprob, mix->classcount);
	free_2d((void**)mix->mixturemeans, mix->classcount);
	free_2d((void**)mix->mixturedeviations, mix->classcount);
	safe_free(mix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x52e20
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x52e20
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x52e20
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mixture.c
// Function: generate_data_from_mixture_file
double** generate_data_from_mixture_file(char* modeldefinition, int datasize)
{
	/*!Last Changed 26.01.2005*/
	Mixtureptr mix;
	double** data;
	mix = read_mixture_from_file(modeldefinition);
 data = generate_data_from_mixture_model(mix, datasize);
	free_mixture(mix);
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x60d90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x613e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x61330
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mixture.c
// Function: generate_data_from_mixture_model
double** generate_data_from_mixture_model(Mixtureptr mix, int datasize)
{
	/*!Last Changed 26.01.2005*/
	int i, whichclass, whichmodel;
	double** data, prob;
 data = (double**) safemalloc_2d(sizeof(double*), sizeof(double), datasize, 2, "generate_data_from_mixture_model", 5); 
	for (i = 0; i < datasize; i++)
	 {
		 prob = produce_random_value(0, 1);
   whichclass = find_bin(mix->classpriors, mix->classcount, prob);
			data[i][1] = whichclass;
			prob = produce_random_value(0, 1);
   whichmodel = find_bin(mix->mixtureprob[whichclass], mix->numberofmodels[whichclass], prob);
			data[i][0] = produce_normal_value(mix->mixturemeans[whichclass][whichmodel], mix->mixturedeviations[whichclass][whichmodel]);
	 }
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edx
movl $0x8, %esi
movl $0x2, %ecx
leaq 0x85a8f(%rip), %r8      # 0xe6e92
movl $0x5, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x61504
xorps %xmm0, %xmm0
movsd 0x80be5(%rip), %xmm1    # 0xe2018
callq 0x545a0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
movsd -0x28(%rbp), %xmm0
callq 0x4fff0
movl %eax, -0x14(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd 0x80b9f(%rip), %xmm1    # 0xe2018
callq 0x545a0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movsd -0x28(%rbp), %xmm0
callq 0x4fff0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0xc4710
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6141c
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: copy_of_Mlpnetwork
Mlpnetwork copy_of_Mlpnetwork(Mlpnetwork source)
{
	/*!Last Changed 29.06.2005*/
 Mlpnetwork dest;
	int li;
	dest = allocate_mlpnnetwork(source.P);
	dest.P = source.P;
	for (li = 0; li < source.P.layernum + 1; li++)
		 matrix_identical(&(dest.weights[li]), source.weights[li]);
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0xb0(%rbp)
movq %rdi, -0xb8(%rbp)
leaq 0x10(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
addq $0x8, %rsi
movq %rsp, %rdi
movl $0x12, %ecx
rep  movsq (%rsi), %es:(%rdi)
leaq -0xa0(%rbp), %rdi
callq 0x61600
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x98, %edx
callq 0x42b0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x8, %rdi
addq $0x8, %rsi
movl $0x90, %edx
callq 0x42b0
movl $0x0, -0x4(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x4(%rbp), %eax
movl 0x5c(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x615e3
movq -0xa8(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq (%rcx), %rdi
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rdi
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x5c040
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6158e
movq -0xb8(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: mlp_network_train_general
Mlpnetwork mlp_network_train_general(matrix train, matrix cv, Mlpparametersptr mlpparams)
{
	/*!Last Changed 26.06.2005*/
	mlpparams->inputnum = train.row;
	mlpparams->trnum = train.row;
	mlpparams->cvnum = cv.row;
 if (current_dataset->classno == 0)
  	return mlpn_general(train, cv, mlpparams, REGRESSION);
	else
  	return mlpn_general(train, cv, mlpparams, CLASSIFICATION);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x28(%rbp)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
leaq 0xa4197(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x616d8
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r9
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x1, (%rsp)
callq 0x61710
jmp 0x616fe
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %r9
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x61710
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: testMlpnNetwork_cls
int testMlpnNetwork_cls(matrix Data, Mlpnetwork N, double* loglikelihood)
{
	/*!Last Changed 22.05.2005 fixed class results*/
	/*!Last Changed 09.02.2004 Oya*/
	int k, res, performance = 0;
	double prob;
	matrix testY;
	*loglikelihood = 0;
	for (k = 0; k < Data.row; k++)
	 {
		 testMlpnInput_cls(Data.values[k], &testY, N, &res, &prob);
			if (prob != 0)
				 *loglikelihood += log2(prob);
   performance += res;				 
			matrix_free(testY);
	 }
	return performance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x61d94
movq -0x48(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x64c10
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x61d5a
jp 0x61d5a
jmp 0x61d70
movsd -0x30(%rbp), %xmm0
callq 0x52ad0
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59ea0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61d08
movl -0x24(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: test_mlp_network
double test_mlp_network(Mlpnetwork neuralnetwork, matrix test)
{
	/*!Last Changed 26.06.2005*/
	double loglikelihood;
	int performance;
	if (current_dataset->classno == 0)
	  return testMlpnNetwork_reg(test, neuralnetwork) / test.row;
	else
		{
	  performance = testMlpnNetwork_cls(test, neuralnetwork, &loglikelihood);
			return 100.0 * ((test.row - performance + 0.0) / test.row);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xa3a7e(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x61e07
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x61e80
cvtsi2sdl -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x61e65
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x61cd0
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
subl -0x24(%rbp), %eax
cvtsi2sd %eax, %xmm1
xorps %xmm0, %xmm0
addsd %xmm0, %xmm1
cvtsi2sdl -0x18(%rbp), %xmm0
divsd %xmm0, %xmm1
movsd 0x80be4(%rip), %xmm0    # 0xe2a40
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: testMlpnNetwork_reg
double testMlpnNetwork_reg(matrix Data, Mlpnetwork N)
{
	/*!Last Changed 16.03.2004 Oya*/
	double sqrdError = 0;
	matrix output_error, testY;
	int k;
 output_error = matrix_alloc(1, N.P.classnum);
	for (k = 0; k < Data.row; k++)
	 {
   sqrdError =  sqrdError + testMlpnInput_reg(Data.values[k], &testY, N, &output_error);
   matrix_free(testY);
	 } 	
	matrix_free(output_error);
	return sqrdError;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl 0x8(%rax), %esi
movl $0x1, %edi
callq 0x57fc0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x61f3a
movq -0x58(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x64e70
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x61ecf
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x59ea0
movsd -0x18(%rbp), %xmm0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: number_of_weights_in_mlp_network
int number_of_weights_in_mlp_network(Mlpnetwork N)
{
	/*!Last Changed 18.06.2005*/
	int result = 0, i;
	for (i = 0; i <= N.P.layernum; i++)
		 result += N.weights[i].row * N.weights[i].col;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x5c(%rcx), %eax
jg 0x621ad
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl (%rax), %eax
movq (%rcx), %rcx
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
imull 0x4(%rcx), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6216a
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: calculate_hidden_values
void calculate_hidden_values(double *inputdata, matrix weight, matrixptr hidden)
{
	/*!Last Changed 09.02.2004 Oya*/
	int i, hi;
	double sum;	
	for (hi = 0; hi < weight.row; hi++)
  {
		 sum = weight.values[hi][0];
		 for (i = 1; i < weight.col; i++)
    {
				 sum = sum + weight.values[hi][i] * inputdata[i - 1];
		  }
		 hidden->values[0][hi] = sigmoid(sum);
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x62b7f
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x62b53
movsd -0x30(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x62b07
movsd -0x30(%rbp), %xmm0
callq 0x7aab0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x62adf
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: calculate_output_values_reg
void calculate_output_values_reg(double *inputdata, matrix weight, matrixptr output)
{	
	/*!Last Changed 16.03.2004 Oya*/
	int i, hi;
	double sum;	
	for (hi=0; hi<weight.row; hi++)
  {
		 sum = weight.values[hi][0];
		 for (i=1; i<weight.col; i++)
    {
		 		sum = sum + weight.values[hi][i] * inputdata[i-1];
		  }
		 output->values[0][hi] = sum;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x63356
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6332f
movsd -0x30(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x632e3
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x632bb
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: softmax_with_calculation_of_outputs
void softmax_with_calculation_of_outputs(double *inputdata, matrix weights, matrixptr Y)
{
	/*!Last Changed 09.02.2004 Oya*/
	int i, j;
	double sum;
	sum = 0;
	for (i = 0; i < Y->col; i++)
	 {
 		Y->values[0][i] = weights.values[i][0];     /*for bias term*/
 		for (j = 1; j < weights.col; j++)
  			Y->values[0][i] = Y->values[0][i] + weights.values[i][j] * inputdata[j - 1];
 		Y->values[0][i] = exp(Y->values[0][i]);
 		sum = sum + Y->values[0][i];
	 }
	for (i = 0; i < Y->col; i++)
 		Y->values[0][i] = Y->values[0][i] / sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x63485
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6342c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x633c2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x4060
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x63387
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x634d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6348c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: allocate_hiddens
matrixptr allocate_hiddens(Mlpparameters P)
{
	/*!Last Changed 09.02.2004 Oya*/
	matrixptr hiddens;
	int i;	 
	/*allocations*/
	if (P.layernum > 0)
	 {
	 	hiddens = (matrixptr) safemalloc (P.layernum * sizeof(matrix), "allocate_hiddens", 4);
	 	for (i = 0; i < P.layernum; i++)
	  		hiddens[i] = matrix_alloc(1, P.hidden[i]);
		 return hiddens;
	 }
	else
	 	return NULL;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x54(%rax)
jle 0x63a1a
movq -0x30(%rbp), %rax
movslq 0x54(%rax), %rdi
shlq $0x4, %rdi
leaq 0x83527(%rip), %rsi     # 0xe6ec4
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x54(%rcx), %eax
jge 0x63a10
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movslq -0x14(%rbp), %rcx
movl 0x48(%rax,%rcx,4), %esi
movl $0x1, %edi
callq 0x57fc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x639b2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x63a22
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: free_weights
void free_weights(matrixptr weights, int layer)
{
	/*!Last Changed 09.02.2004 Oya*/
	int i;	
	for (i = 0; i < (layer + 1); i++)
		 matrix_free(weights[i]);
	safe_free(weights);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x63b29
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x63af6
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: free_hiddens
void free_hiddens(matrixptr hiddens, int layer)
{
	/*!Last Changed 09.02.2004 Oya*/
	int i;	
	if (layer > 0)
	 {	
 		for (i = 0; i < layer; i++)
 			 matrix_free(hiddens[i]);
 		safe_free(hiddens);
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x63b93
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x63b8a
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x63b5c
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: calculate_error_values_cls
double calculate_error_values_cls(double outputclass, matrix output, matrixptr output_error)
{
	/*!Last Changed 09.02.2004 Oya*/
	int i;
	double sqrderror = 0;
	/*for error in classification*/
	for (i=0; i<output.col; i++)
	 {
 		output_error->values[0][i] = equal((int)outputclass,i) - output.values[0][i];
 		sqrderror = sqrderror + (-1 * equal((int)outputclass,i) * log(output.values[0][i]));
	 }
	sqrderror = sqrderror / output.col;
	return sqrderror;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x63c6c
cvttsd2si -0x18(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x52790
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
cvttsd2si -0x18(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x52790
imull $0xffffffff, %eax, %eax # imm = 0xFFFFFFFF
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x4120
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x63bc8
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: calculate_error_values_reg
double calculate_error_values_reg(double outputdata, matrix output, matrixptr output_error)
{	
	/*!Last Changed 16.03.2004 Oya*/
	int i;
	double sqrderror = 0;
	/*for error in regression*/
	for (i=0; i<output.col; i++)
  {
		 output_error->values[0][i] = outputdata - output.values[0][i];
		 sqrderror = sqrderror + output_error->values[0][i] * output_error->values[0][i];
	 }
	sqrderror = sqrderror / output.col;
	return sqrderror;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x63d2a
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x30(%rbp), %xmm1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x63cb4
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: calculate_error_values_autoencoder
double calculate_error_values_autoencoder(double* outputdata, matrix output, matrixptr output_error)
{
	int i;
	double sqrderror = 0;
	for (i = 0; i < output.col; i++)
  {
   output_error->values[0][i] = outputdata[i] - output.values[0][i];
   sqrderror = sqrderror + output_error->values[0][i] * output_error->values[0][i];
  }
	sqrderror = sqrderror / output.col;
	return sqrderror;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x63df1
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x30(%rbp), %xmm1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x63d73
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: update_weights
void update_weights(matrixptr weights, matrixptr dweights, matrixptr prevWeights, Mlpparameters P)
{
	/*!Last Changed 23.06.2005 added weight decay*/
	/*!Last Changed 09.02.2004 Oya*/
	int li, i, j;	
	for (li=0; li<(P.layernum+1); li++)
 		for (i=0; i<weights[li].row; i++)
  			for (j=0; j<weights[li].col; j++)
  					weights[li].values[i][j] = weights[li].values[i][j] + dweights[li].values[i][j] + P.alpha * prevWeights[li].values[i][j] + P.weightdecay * P.decayalpha * P.eta * weights[li].values[i][j]; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x54(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x643d1
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0x643c1
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jge 0x643b1
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x24(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x24(%rbp), %rdx
addsd (%rcx,%rdx,8), %xmm0
movsd 0x30(%rax), %xmm1
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x24(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdl 0x58(%rax), %xmm0
mulsd 0x60(%rax), %xmm0
mulsd 0x38(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x642ac
jmp 0x643b3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6428b
jmp 0x643c3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6426f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: testMlpnInput_autoencoder
double testMlpnInput_autoencoder(double *Test, matrix* testY, Mlpnetwork N, matrixptr output_error)
{
	double sqrderror;
	matrixptr testH;
	int li;
	*testY = matrix_alloc(1, N.P.classnum);
	testH = allocate_hiddens(N.P);
	/*calculate hidden layers*/
	for (li = 0; li < N.P.layernum; li++)
  {
   if (li == 0)
     calculate_hidden_values(Test, N.weights[0], &testH[0]);
   else
     calculate_hidden_values(testH[li-1].values[0], N.weights[li], &testH[li]);
  }
	/*calculate outputs*/
 calculate_output_values_reg(testH[N.P.layernum-1].values[0], N.weights[N.P.layernum], testY);
	/*calculate error*/
	sqrderror = calculate_error_values_autoencoder(Test, *testY, output_error);
	free_hiddens(testH, N.P.layernum);
	return sqrderror;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movl 0x8(%rax), %esi
movl $0x1, %edi
callq 0x57fc0
movq -0x50(%rbp), %rsi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsi
movq %rsp, %rdi
movl $0x12, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x63970
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x50(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x5c(%rcx), %eax
jge 0x6512c
cmpl $0x0, -0x2c(%rbp)
jne 0x650d4
movq -0x50(%rbp), %rax
movq -0x8(%rbp), %rdi
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x62ac0
jmp 0x6511c
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rdi
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x62ac0
jmp 0x6511e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x650a5
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movl 0x5c(%rcx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq (%rcx), %rax
movslq 0x5c(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x632a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x63d50
movq -0x50(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl 0x5c(%rax), %esi
callq 0x63b40
movsd -0x20(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: testMlpnNetwork2_cls
int testMlpnNetwork2_cls(matrix Data, Mlpnetwork N, double* loglikelihood, double *sqrdError)
{
	/*!Last Changed 22.05.2005 fixed class results*/
	/*!Last Changed 09.02.2004 Oya*/
	int k, res, performance = 0;
	double prob;	
	matrix testY;
	*sqrdError = 0;
	*loglikelihood = 0;
	for (k = 0; k < Data.row; k++)
	 {
		 *sqrdError += testMlpnInput_cls(Data.values[k], &testY, N, &res, &prob);
			if (prob != 0)
				 *loglikelihood += log2(prob);
   performance += res;				 
			matrix_free(testY);
	 }
	*sqrdError = *sqrdError / Data.row;
	return performance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6528f
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x64c10
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x65255
jp 0x65255
jmp 0x6526b
movsd -0x38(%rbp), %xmm0
callq 0x52ad0
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x28(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x59ea0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x651f7
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/mlp.c
// Function: testMlpnNetwork_autoencoder
double testMlpnNetwork_autoencoder(matrix Data, Mlpnetwork N)
{
	double sqrdError = 0;
	matrix output_error, testY;
	int k;
 output_error = matrix_alloc(1, N.P.classnum);
	for (k = 0; k < Data.row; k++)
  {
   sqrdError =  sqrdError + testMlpnInput_autoencoder(Data.values[k], &testY, N, &output_error);
   matrix_free(testY);
  }
	matrix_free(output_error);
	return sqrdError;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl 0x8(%rax), %esi
movl $0x1, %edi
callq 0x57fc0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6537a
movq -0x58(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x65030
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6530f
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x59ea0
movsd -0x18(%rbp), %xmm0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)