LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: separate_which_group
char separate_which_group(Instanceptr* data, Instanceptr left, Instanceptr right, int quadratic, LEAF_TYPE leaftype)
{
	/*!Last Changed 03.04.2005*/
	/*!Last Changed 26.03.2005*/
	int leftsize, rightsize;
	double lefterror, righterror;
	Instanceptr leftinstances, rightinstances;
 divide_instancelist_according_centers(data, &leftinstances, &rightinstances, left, right, quadratic);
	leftsize = data_size(leftinstances);
	rightsize = data_size(rightinstances);
	if (leftsize == 0 || rightsize == 0)
	 {
   *data = restore_instancelist(*data, leftinstances);
  	merge_instancelist(data, rightinstances);	
		 return '=';
	 }
	lefterror = constant_or_linear_model_mse(leftinstances, leftinstances, leaftype);
	righterror = constant_or_linear_model_mse(rightinstances, rightinstances, leaftype);
 *data = restore_instancelist(*data, leftinstances);
	merge_instancelist(data, rightinstances);	
	if ((lefterror / leftsize) < (righterror / rightsize))
		 return '<';
	else
		 return '>';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x45590
movq -0x48(%rbp), %rdi
callq 0x449f0
movl %eax, -0x2c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x449f0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xa4a9c
cmpl $0x0, -0x30(%rbp)
jne 0xa4ac9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x464e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x44f40
movb $0x3d, -0x1(%rbp)
jmp 0xa4b46
movq -0x48(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0xa7830
movsd %xmm0, -0x38(%rbp)
movq -0x50(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0xa7830
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x464e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x44f40
movsd -0x38(%rbp), %xmm1
cvtsi2sdl -0x2c(%rbp), %xmm0
divsd %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
cvtsi2sdl -0x30(%rbp), %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa4b42
movb $0x3c, -0x1(%rbp)
jmp 0xa4b46
movb $0x3e, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: best_single_regression_condition
void best_single_regression_condition(Regressionconditionptr condition, Instanceptr* data, NODE_TYPE nodetype, LEAF_TYPE leaftype)
{
	/*!Last Changed 03.04.2005*/
	/*!Last Changed 26.03.2005*/
	switch (nodetype)
	 {
	  case UNIVARIATE:if (leaftype == CONSTANTLEAF)
		                   condition->featureindex = best_regression_feature(*data, &(condition->value), &(condition->comparison));
	                  else
		                   condition->featureindex = best_regression_feature_linear_leaves(*data, &(condition->value), &(condition->comparison));
																			break;
			case LINEAR    :condition->featureindex = LINEAR;
				               find_linear_regression_condition(data, &(condition->leftcenter), &(condition->rightcenter), &(condition->comparison), leaftype);
				               break;
			case QUADRATIC :condition->featureindex = QUADRATIC;
				               find_quadratic_regression_condition(data, &(condition->leftcenter), &(condition->rightcenter), &(condition->comparison), leaftype);
				               break;
   default        :printf(m1231, nodetype);
                   break;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $-0x3, %eax
je 0xa4cd1
jmp 0xa4c37
movl -0x1c(%rbp), %eax
subl $-0x2, %eax
je 0xa4ca0
jmp 0xa4c41
movl -0x1c(%rbp), %eax
testl %eax, %eax
jne 0xa4d02
jmp 0xa4c4e
cmpl $0x0, -0x18(%rbp)
jne 0xa4c7a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
callq 0xa6720
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0xa4c9e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
callq 0xa6110
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0xa4d13
movq -0x8(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rdx
addq $0x18, %rdx
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movl -0x18(%rbp), %r8d
callq 0xa4b50
jmp 0xa4d13
movq -0x8(%rbp), %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rdx
addq $0x18, %rdx
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movl -0x18(%rbp), %r8d
callq 0xa4bb0
jmp 0xa4d13
movl -0x14(%rbp), %esi
leaq 0x475ce(%rip), %rdi     # 0xec2da
movb $0x0, %al
callq 0x4030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: find_uni_and_multi_regression_conditions
void find_uni_and_multi_regression_conditions(Regressionconditionptr condition, Instanceptr data, Instanceptr* leftlincenter, Instanceptr* rightlincenter, Instanceptr* leftquacenter, Instanceptr* rightquacenter, LEAF_TYPE leaftype)
{
	/*!Last Changed 27.03.2005*/
 if (leaftype == CONSTANTLEAF)
   condition->featureindex = best_regression_feature(data, &(condition->value), &(condition->comparison));
	else
		 condition->featureindex = best_regression_feature_linear_leaves(data, &(condition->value), &(condition->comparison));
 find_linear_regression_split(data, leftlincenter, rightlincenter);
 find_quadratic_regression_split(data, leftquacenter, rightquacenter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, 0x10(%rbp)
jne 0xa539c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
callq 0xa6720
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0xa53bd
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
callq 0xa6110
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa7b10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xa7b90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: set_best_model_in_regression_rule
void set_best_model_in_regression_rule(Regressionconditionptr condition, MODEL_TYPE bestmodel, Instanceptr leftl, Instanceptr rightl, Instanceptr leftq, Instanceptr rightq)
{
	/*!Last Changed 27.03.2005*/
	switch (bestmodel)
	 {
	  case MODEL_UNI:deallocate(leftl);
										        deallocate(rightl);
				              deallocate(leftq);
				              deallocate(rightq);
										        break;
	  case MODEL_LIN:condition->featureindex = LINEAR;
				              condition->leftcenter = leftl;
				              condition->rightcenter = rightl;
				              deallocate(leftq);
				              deallocate(rightq);
										        break;				      
			case MODEL_QUA:condition->featureindex = QUADRATIC;
				              condition->leftcenter = leftq;
				              condition->rightcenter = rightq;
				              deallocate(leftl);
				              deallocate(rightl);
										        break;				      
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0xa5432
jmp 0xa541b
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0xa5458
jmp 0xa5425
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0xa548e
jmp 0xa54c2
movq -0x18(%rbp), %rdi
callq 0x44510
movq -0x20(%rbp), %rdi
callq 0x44510
movq -0x28(%rbp), %rdi
callq 0x44510
movq -0x30(%rbp), %rdi
callq 0x44510
jmp 0xa54c2
movq -0x8(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rdi
callq 0x44510
movq -0x30(%rbp), %rdi
callq 0x44510
jmp 0xa54c2
movq -0x8(%rbp), %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x44510
movq -0x20(%rbp), %rdi
callq 0x44510
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: best_regression_condition
Regressionconditionptr best_regression_condition(Instanceptr* data, Regrule_parameterptr param)
{
	/*!Last Changed 26.03.2005*/
	/*!Last Changed 02.03.2005*/
	Regressionconditionptr result;
	result = empty_regression_condition();
	switch (param->modelselectionmethod)
	 {
	  case MODEL_SELECTION_CV :best_regression_condition_crossvalidation(result, data, param->leaftype, param->correctiontype);
				                        break;
			case MODEL_SELECTION_AIC:
			case MODEL_SELECTION_BIC:best_regression_condition_aic_or_bic(result, data, param->leaftype, param->modelselectionmethod);
				                        break;
			case MODEL_SELECTION_UNI:best_single_regression_condition(result, data, UNIVARIATE, param->leaftype);
				                        break;
			case MODEL_SELECTION_LIN:best_single_regression_condition(result, data, LINEAR, param->leaftype);
				                        break;
			case MODEL_SELECTION_QUA:best_single_regression_condition(result, data, QUADRATIC, param->leaftype);
				                        break;
   default                 :printf(m1230, param->modelselectionmethod);
                            break;
	 }
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xa49e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0xa57a5
movq -0x20(%rbp), %rax
leaq 0x46b3b(%rip), %rcx     # 0xec254
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
callq 0xa4d20
jmp 0xa57ba
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
callq 0xa54d0
jmp 0xa57ba
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
xorl %edx, %edx
callq 0xa4c10
jmp 0xa57ba
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0xa4c10
jmp 0xa57ba
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0xfffffffd, %edx       # imm = 0xFFFFFFFD
callq 0xa4c10
jmp 0xa57ba
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x46ac1(%rip), %rdi     # 0xec274
movb $0x0, %al
callq 0x4030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: create_copy_of_regression_condition
Regressionconditionptr create_copy_of_regression_condition(Regressionconditionptr condition)
{
	/*!Last Changed 27.03.2005*/
	/*!Last Changed 05.03.2005*/
	int oldfcount;
	Regressionconditionptr result = safemalloc(sizeof(Regressioncondition), "create_copy_of_regression_condition", 2);
	result->comparison = condition->comparison;
	result->featureindex = condition->featureindex;
	result->value = condition->value;
	if (in_list(result->featureindex, 2, LINEAR, QUADRATIC))
	 {
		 if (result->featureindex == QUADRATIC)
			 {
				 oldfcount = current_dataset->multifeaturecount;
     current_dataset->multifeaturecount = multifeaturecount_2d(current_dataset) + 1;
			 }
  	result->leftcenter = copy_of_instance(condition->leftcenter);
  	result->rightcenter = copy_of_instance(condition->rightcenter);
		 if (result->featureindex == QUADRATIC)
				 current_dataset->multifeaturecount = oldfcount;
	 }
	result->next = NULL;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
leaq 0x46b44(%rip), %rsi     # 0xec32c
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb 0x4(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x2, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xa58d5
movq -0x18(%rbp), %rax
cmpl $-0x3, (%rax)
jne 0xa5887
leaq 0x5ffe9(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x5ffd6(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1b690
movl %eax, %ecx
addl $0x1, %ecx
leaq 0x5ffc2(%rip), %rax     # 0x105840
movq (%rax), %rax
movl %ecx, 0x1c0(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x42ca0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x42ca0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpl $-0x3, (%rax)
jne 0xa58d3
movl -0xc(%rbp), %ecx
leaq 0x5ff76(%rip), %rax     # 0x105840
movq (%rax), %rax
movl %ecx, 0x1c0(%rax)
jmp 0xa58d5
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: create_copy_of_regression_rule
Regressionruleptr create_copy_of_regression_rule(Regressionruleptr rule)
{
	/*!Last Changed 05.03.2005*/
	Regressionruleptr result = safemalloc(sizeof(Regressionrule), "create_copy_of_rule", 1);
	Regressionconditionptr newcondition, tmp, last = NULL;
	result->regressionvalue = rule->regressionvalue;
	result->conditioncount = rule->conditioncount;
	result->next = NULL;
	result->start = NULL;
	result->leaftype = rule->leaftype;
	if (rule->leaftype == LINEARLEAF)
  	result->w = matrix_copy(rule->w);
	tmp = rule->start;
	while (tmp)
	 {
		 newcondition = create_copy_of_regression_condition(tmp);
			if (tmp == rule->start)
				 result->start = newcondition;
			else
				 last->next = newcondition;
			last = newcondition;
			tmp = tmp->next;
	 }
	result->end = last;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x48, %edi
leaq 0x46a48(%rip), %rsi     # 0xec350
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0xa59a4
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa5a02
movq -0x20(%rbp), %rdi
callq 0xa57d0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xa59e0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xa59ec
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa59b0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: nearest_center_in_regression_tree
CHILD_TYPE nearest_center_in_regression_tree(Instanceptr tmp, NODE_TYPE nodetype, Instanceptr leftcenter, Instanceptr rightcenter)
{
	/*!Last Changed 24.03.2005*/
	int oldfcount;
	Instanceptr tmp2d;
	double dist1, dist2;
	if (nodetype == QUADRATIC)
		{
			tmp2d = generate_2d_copy_of_instance(tmp);
   oldfcount = current_dataset->multifeaturecount;
	  current_dataset->multifeaturecount = multifeaturecount_2d(current_dataset) + 1;
			dist1 = distance_between_instances(tmp2d, leftcenter);
			dist2 = distance_between_instances(tmp2d, rightcenter);
   current_dataset->multifeaturecount = oldfcount;
			deallocate(tmp2d);
		}
	else
		{
		 dist1 = distance_between_instances(tmp, leftcenter);
		 dist2 = distance_between_instances(tmp, rightcenter);
		}
	if (dist1 < dist2)
		 return LEFTCHILD;
	else
		 return RIGHTCHILD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $-0x3, -0x14(%rbp)
jne 0xa5d87
movq -0x10(%rbp), %rdi
callq 0x42e60
movq %rax, -0x38(%rbp)
leaq 0x5fb2b(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x2c(%rbp)
leaq 0x5fb18(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1b690
movl %eax, %ecx
addl $0x1, %ecx
leaq 0x5fb04(%rip), %rax     # 0x105840
movq (%rax), %rax
movl %ecx, 0x1c0(%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x442e0
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x442e0
movsd %xmm0, -0x48(%rbp)
movl -0x2c(%rbp), %ecx
leaq 0x5facd(%rip), %rax     # 0x105840
movq (%rax), %rax
movl %ecx, 0x1c0(%rax)
movq -0x38(%rbp), %rdi
callq 0x44510
jmp 0xa5dab
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x442e0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x442e0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa5dc4
movl $0x0, -0x4(%rbp)
jmp 0xa5dcb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: regressiontree_node_types
void regressiontree_node_types(Regressionnodeptr node, char st[READLINELENGTH], int level)
{
	if (node->featureno != LEAF_NODE)
	 {
		 if (node->featureno >= 0)
				 sprintf(st,"%s%d-U-%d;", st, level, node->covered);
			else
				 if (node->featureno == LINEAR)
						 sprintf(st,"%s%d-L-%d;", st, level, node->covered);
					else
						 if (node->featureno == QUADRATIC) 
								 sprintf(st,"%s%d-Q-%d;", st, level, node->covered);
   regressiontree_node_types(node->left, st, level + 1);
   regressiontree_node_types(node->right, st, level + 1);
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
je 0xa5eb7
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jl 0xa5e2e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x78(%rax), %r8d
leaq 0x416ab(%rip), %rsi     # 0xe74d0
movb $0x0, %al
callq 0x4170
jmp 0xa5e8a
movq -0x8(%rbp), %rax
cmpl $-0x2, 0x68(%rax)
jne 0xa5e5b
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x78(%rax), %r8d
leaq 0x41689(%rip), %rsi     # 0xe74db
movb $0x0, %al
callq 0x4170
jmp 0xa5e88
movq -0x8(%rbp), %rax
cmpl $-0x3, 0x68(%rax)
jne 0xa5e86
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x78(%rax), %r8d
leaq 0x41667(%rip), %rsi     # 0xe74e6
movb $0x0, %al
callq 0x4170
jmp 0xa5e88
jmp 0xa5e8a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xa5de0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xa5de0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: regressiontree_leaf_count
int regressiontree_leaf_count(Regressionnodeptr node)
{
 int result = 0;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   result += regressiontree_leaf_count(node->left);
   result += regressiontree_leaf_count(node->right);
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xa5f46
movl $0x1, -0x4(%rbp)
jmp 0xa5f71
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa5f20
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa5f20
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: regressiontree_node_count
int regressiontree_node_count(Regressionnodeptr node)
{
 int result = 1;
 if (node->featureno == LEAF_NODE)
   return 0;
 else
  {
   result += regressiontree_node_count(node->left);
   result += regressiontree_node_count(node->right);
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xa5fa6
movl $0x0, -0x4(%rbp)
jmp 0xa5fd1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa5f80
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa5f80
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: complexity_of_regression_tree
int complexity_of_regression_tree(Regressionnodeptr node)
{
	/*!Last Changed 24.03.2005*/
 /*!Last Changed 02.03.2005*/
	int d;
	if (node->featureno == LEAF_NODE)
  	if (node->leaftype == CONSTANTLEAF)
	  	 return 1;
	  else
		   return current_dataset->multifeaturecount;
	else
	 {
		 if (node->featureno >= 0)
				 d = 2;
			else
				 if (node->featureno == LINEAR)
						 d = current_dataset->multifeaturecount;
					else
       if (node->featureno == QUADRATIC)
						   d = multifeaturecount_2d(current_dataset) + 1;
       else
         d = 2;
		 return d + complexity_of_regression_tree(node->left) + complexity_of_regression_tree(node->right);
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xa6024
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xa600c
movl $0x1, -0x4(%rbp)
jmp 0xa60b5
leaq 0x5f82d(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa60b5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jl 0xa6037
movl $0x2, -0x14(%rbp)
jmp 0xa6082
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x68(%rax)
jne 0xa6056
leaq 0x5f7f8(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xa6080
movq -0x10(%rbp), %rax
cmpl $-0x3, 0x68(%rax)
jne 0xa6077
leaq 0x5f7d9(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1b690
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa607e
movl $0x2, -0x14(%rbp)
jmp 0xa6080
jmp 0xa6082
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa5fe0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa5fe0
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: make_leaf_regression_node
void make_leaf_regression_node(Regressionnodeptr node, LEAF_TYPE leaftype)
{
	/*!Last Changed 25.08.2005 added leaftype*/
 /*!Last Changed 01.03.2005*/
 node->featureno = LEAF_NODE;
	node->leaftype = leaftype;
 node->left = NULL;
 node->right = NULL;
	node->string = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: create_regression_matrices_for_array_of_instances
void create_regression_matrices_for_array_of_instances(Instanceptr list, int start, int end, matrix* X, matrix* r)
{
	/*!Last Changed 01.03.2005*/
	int i, size = end - start + 1, j;
	*X = matrix_alloc(size, current_dataset->multifeaturecount);
	*r = matrix_alloc(size, 1);
	for (i = 0; i < size; i++)
	 {
		 (*X).values[i][0] = 1;
		 for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
			  (*X).values[i][j + 1] = real_feature(&(list[start + i]), j);
			(*r).values[i][0] = give_regressionvalue(&(list[start + i]));
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x28(%rbp), %edi
leaq 0x5f3e8(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %esi
callq 0x57fc0
movq %rax, %rcx
movq -0x60(%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)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x28(%rbp), %edi
movl $0x1, %esi
callq 0x57fc0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xa6585
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x3bb36(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
leaq 0x5f349(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa654b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl -0x24(%rbp), %eax
cltq
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl -0x2c(%rbp), %esi
callq 0x42c40
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa64ed
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl -0x24(%rbp), %eax
cltq
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x43580
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa64be
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: multivariate_regression
matrix multivariate_regression(matrix X, matrix r)
{
	/*!Last Changed 28.02.2005*/
	matrix XT, XTX, tmpmatrix, result;
	XT = matrix_transpose(X);
	XTX = matrix_multiply(XT, X);
	matrix_inverse(&XTX);
	tmpmatrix = matrix_multiply(XTX, XT);
	matrix_free(XTX);
	matrix_free(XT);
	result = matrix_multiply(tmpmatrix, r);
	matrix_free(tmpmatrix);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59ed0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movups -0x70(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x59fe0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movups -0x80(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5c470
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x59fe0
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movups -0x90(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x59ea0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59ea0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x59fe0
movq %rax, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movups -0xa0(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x59ea0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: variance_of_linear_regression_for_array_of_instances
double variance_of_linear_regression_for_array_of_instances(matrix w, Instanceptr list, int start, int end, LEAF_TYPE leaftype)
{
	/*!Last Changed 01.03.2005*/
	int i, size = end - start + 1;
	double variance = 0;
	for (i = 0; i < size; i++)
		 variance += instance_regression_error(w, 0, &(list[start + i]), leaftype);
	return variance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0xa670d
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %eax
addl -0x28(%rbp), %eax
cltq
imulq $0x30, %rax, %rax
addq %rax, %rdx
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0xa6b40
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa66ca
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: linear_fit_value
double linear_fit_value(matrix w, Instanceptr inst)
{
	/*!Last Changed 28.02.2005*/
	int i;
	double result = w.values[0][0];
	for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
			result += w.values[i + 1][0] * real_feature(inst, i);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x5ed6b(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa6b30
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa6acb
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: instance_regression_error
double instance_regression_error(matrix w, double regressionvalue, Instanceptr instance, LEAF_TYPE leaftype)
{
	/*!Last Changed 02.03.2005*/
	double mean, regvalue;
	if (leaftype == CONSTANTLEAF)
		 mean = regressionvalue;
	else
  	mean = linear_fit_value(w, instance);
	regvalue = give_regressionvalue(instance);
	return (regvalue - mean) * (regvalue - mean);
}

// 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)
movl %ecx, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xa6b6e
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xa6b84
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xa6aa0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x43580
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
subsd -0x30(%rbp), %xmm1
mulsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: variance_of_linear_regression
double variance_of_linear_regression(matrix w, Instanceptr list, LEAF_TYPE leaftype)
{
	/*!Last Changed 28.02.2005*/
	double variance = 0;
	Instanceptr tmp;
	tmp = list;
	while (tmp)
	 {
			variance += instance_regression_error(w, 0, tmp, leaftype);
		 tmp = tmp->next;
	 }
	return variance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa6c0d
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0xa6b40
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa6bd7
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: create_regression_matrices
void create_regression_matrices(Instanceptr list, matrix* X, matrix* r)
{
	/*!Last Changed 01.03.2005*/
	int i, size = data_size(list), j;
	Instanceptr tmp;
	*X = matrix_alloc(size, current_dataset->multifeaturecount);
	*r = matrix_alloc(size, 1);
 tmp = list;
	i = 0;
	while (tmp)
	 {
		 (*X).values[i][0] = 1;
		 for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
			  (*X).values[i][j + 1] = real_feature(tmp, j);
			(*r).values[i][0] = give_regressionvalue(tmp);
			i++;	 
		 tmp = tmp->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x449f0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x20(%rbp), %edi
leaq 0x5ebee(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %esi
callq 0x57fc0
movq %rax, %rcx
movq -0x60(%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)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x20(%rbp), %edi
movl $0x1, %esi
callq 0x57fc0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa6d74
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x3b335(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0x5eb48(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa6d3d
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x42c40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa6cee
movq -0x30(%rbp), %rdi
callq 0x43580
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa6cc0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: createnewregnode
Regressionnodeptr createnewregnode(Regressionnodeptr parentnode, int howmany, LEAF_TYPE leaftype)
{
	/*!Last Changed 25.08.2005 added leaftype*/
	/*!Last Changed 09.12.2004*/
	int j;
	Regressionnodeptr newnode;
	newnode = (Regressionnodeptr)safemalloc(howmany * sizeof(struct regressionnode), "createnewregnode", 3);
	newnode->featureno = LEAF_NODE;
	newnode->leaftype = leaftype;
	newnode->instances = NULL;
	newnode->cvinstances = NULL;
	for (j = 0; j < howmany; j++)
			newnode[j].parent = parentnode;
	return newnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rax
imulq $0x98, %rax, %rdi
leaq 0x455e0(%rip), %rsi     # 0xec384
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa6e13
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x98, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa6de6
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: next_regression_node
Regressionnodeptr next_regression_node(Regressionnodeptr currentnode, Instanceptr tmp)
{
	/*!Last Changed 24.03.2005*/
	/*!Last Changed 09.12.2004*/
	if (currentnode->featureno >= 0)
   if (tmp->values[currentnode->featureno].floatvalue <= currentnode->split)
     return currentnode->left;
   else
     return currentnode->right;
	else
			if (nearest_center_in_regression_tree(tmp, currentnode->featureno, currentnode->leftcenter, currentnode->rightcenter) == LEFTCHILD)
     return currentnode->left;
   else
     return currentnode->right;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jl 0xa6e78
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x68(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movsd 0x50(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xa6e6a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa6ebc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa6ebc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x68(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
callq 0xa5ce0
cmpl $0x0, %eax
jne 0xa6eb0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa6ebc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: test_regtree
double test_regtree(Regressionnodeptr root, Instanceptr testingdata)
{
	/*!Last Changed 28.02.2005*/
	/*!Last Changed 09.12.2004*/
 Instanceptr test = testingdata;
 Regressionnodeptr currentnode;
	double performance = 0;
 while (test)
  {
   currentnode = root;
   while (currentnode->featureno != LEAF_NODE)
     currentnode = next_regression_node(currentnode, test); 
			performance += instance_regression_error(currentnode->w, currentnode->regressionvalue, test, currentnode->leaftype);
   test = test->next;
  }
	return performance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa6f59
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
je 0xa6f1c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa6e20
movq %rax, -0x20(%rbp)
jmp 0xa6eff
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movsd 0x70(%rcx), %xmm0
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl 0x6c(%rcx), %ecx
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0xa6b40
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa6ef0
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: deallocate_regression_tree
void deallocate_regression_tree(Regressionnodeptr node)
{
	/*!Last Changed 23.03.2005 added deallocation of left and right centers*/
	/*!Last Changed 09.12.2004*/
 if (node->featureno == LEAF_NODE)
  {
   if (node->instances)
     deallocate(node->instances);
   if (node->cvinstances)
     deallocate(node->cvinstances);
   if (node->leaftype == LINEARLEAF)
     matrix_free(node->w);
  }
 else
  {
		 if (in_list(node->featureno, 2, LINEAR, QUADRATIC))
			 {
				 deallocate(node->leftcenter);
				 deallocate(node->rightcenter);
			 }
   else
     if (node->featureno == SOFTLIN)
       matrix_free(node->w);
   deallocate_regression_tree(node->left);
   safe_free(node->left);
   deallocate_regression_tree(node->right);
   safe_free(node->right);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xa6fd6
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xa6f9e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x44510
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xa6fb6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x44510
movq -0x8(%rbp), %rax
cmpl $0x1, 0x6c(%rax)
jne 0xa6fd1
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x59ea0
jmp 0xa7069
movq -0x8(%rbp), %rax
movl 0x68(%rax), %edi
movl $0x2, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xa701a
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x44510
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x44510
jmp 0xa7037
movq -0x8(%rbp), %rax
cmpl $-0x6, 0x68(%rax)
jne 0xa7035
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x59ea0
jmp 0xa7037
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa6f70
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa6f70
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: accumulate_instances_regression_leaf
void accumulate_instances_regression_leaf(Instanceptr* data, Instanceptr* cvdata, Regressionnodeptr leaf)
{
 /*!Last Changed 02.03.2005*/
	Instanceptr tmp;
	if ((*data) == NULL)
		 *data = leaf->instances;
	else
	 {
		 tmp = *data;
			while (tmp->next != NULL)
				 tmp = tmp->next;
			tmp->next = leaf->instances;
	 }
	leaf->instances = NULL;
	if ((*cvdata) == NULL)
		 *cvdata = leaf->cvinstances;
	else
	 {
		 tmp = *cvdata;
			while (tmp->next != NULL)
				 tmp = tmp->next;
			tmp->next = leaf->cvinstances;
	 }
	leaf->cvinstances = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa728b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa72bf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa72af
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa7296
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa72e6
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa731a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa730a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa72f1
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: accumulate_instances_regression_tree
void accumulate_instances_regression_tree(Instanceptr* data, Instanceptr* cvdata, Regressionnodeptr root)
{
 /*!Last Changed 02.03.2005*/
	if (root->featureno == LEAF_NODE)
		 accumulate_instances_regression_leaf(data, cvdata, root);
	else
	 {
   accumulate_instances_regression_tree(data, cvdata, root->left);
			accumulate_instances_regression_tree(data, cvdata, root->right);
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xa7361
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa7260
jmp 0xa738a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0xa7330
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0xa7330
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: setup_regressionnode_properties
void setup_regressionnode_properties(Regressionnodeptr node, LEAF_TYPE leaftype)
{
	matrix X, r, w;
	node->covered = data_size(node->instances);
	if (leaftype == CONSTANTLEAF)
	 {
   node->regressionvalue = find_mean_of_regression_value(node->instances);
   node->mseerror = find_variance_of_regression_value(node->instances, node->regressionvalue);
	 }
	else
	 {
   create_regression_matrices(node->instances, &X, &r);
   w = multivariate_regression(X, r);
   matrix_free(X);
   matrix_free(r);
   node->w = w;
   node->mseerror = variance_of_linear_regression(w, node->instances, leaftype);
	 } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x449f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0xa7655
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x44600
movq -0x8(%rbp), %rax
movsd %xmm0, 0x70(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movsd 0x70(%rax), %xmm0
callq 0x44690
movq -0x8(%rbp), %rax
movsd %xmm0, 0x60(%rax)
jmp 0xa76e6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xa6c20
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xa6590
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59ea0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movl -0xc(%rbp), %ecx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa6bb0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x60(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)