LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: can_be_divided_regression
int can_be_divided_regression(Regressionnodeptr node, Regtree_parameterptr param)
{
	/*!Last Changed 01.03.2005*/
 setup_regressionnode_properties(node, param->leaftype);
 if (param->prunetype == VALIDATIONPRUNING || (param->prunetype == MODELSELECTIONPRUNING && param->modelselectionmethod == MODEL_SELECTION_CV))
  {
  	if (param->leaftype == CONSTANTLEAF)
     node->errorforprune = find_variance_of_regression_value(node->cvinstances, node->regressionvalue);
   else
     node->errorforprune = variance_of_linear_regression(node->w, node->cvinstances, param->leaftype);
  }
	if (node->mseerror / node->covered <= param->sigma)
	 {
		 make_leaf_regression_node(node, param->leaftype);
		 return 0;
	 }
	if (param->prunetype == PREPRUNING)
	 {
			if ((node->covered + 0.0) / current_dataset->traincount < param->pruningthreshold)
			 {
	  	 make_leaf_regression_node(node, param->leaftype);
     return 0;
			 }
	 }
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xa75f0
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0xa772d
movq -0x18(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0xa7781
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xa7781
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xa7757
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movsd 0x70(%rax), %xmm0
callq 0x44690
movq -0x10(%rbp), %rax
movsd %xmm0, 0x58(%rax)
jmp 0xa777f
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdx
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0xa6bb0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x58(%rax)
jmp 0xa7781
movq -0x10(%rbp), %rax
movsd 0x60(%rax), %xmm1
movq -0x10(%rbp), %rax
cvtsi2sdl 0x78(%rax), %xmm0
divsd %xmm0, %xmm1
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xa77be
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xa60c0
movl $0x0, -0x4(%rbp)
jmp 0xa781e
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xa7817
movq -0x10(%rbp), %rax
cvtsi2sdl 0x78(%rax), %xmm1
xorps %xmm0, %xmm0
addsd %xmm0, %xmm1
leaq 0x5e061(%rip), %rax     # 0x105840
movq (%rax), %rax
cvtsi2sdl 0x1407124(%rax), %xmm0
divsd %xmm0, %xmm1
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa7815
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xa60c0
movl $0x0, -0x4(%rbp)
jmp 0xa781e
jmp 0xa7817
movl $0x1, -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: constant_or_linear_model_mse
double constant_or_linear_model_mse(Instanceptr train, Instanceptr test, LEAF_TYPE leaftype)
{
	/*!Last Changed 26.03.2005*/
	double regvalue, error;
	matrix X, r, w;
	if (leaftype == CONSTANTLEAF)
	 {
  	regvalue = find_mean_of_regression_value(train);
			error = find_variance_of_regression_value(test, regvalue);
	 }
	else
	 {
   create_regression_matrices(train, &X, &r);
		 w = multivariate_regression(X, r);
			matrix_free(X);
			matrix_free(r);
			error = variance_of_linear_regression(w, test, leaftype);
			matrix_free(w);
	}
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xa786c
movq -0x8(%rbp), %rdi
callq 0x44600
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x44690
movsd %xmm0, -0x28(%rbp)
jmp 0xa78ea
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xa6c20
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xa6590
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x59ea0
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xa6bb0
movsd %xmm0, -0x28(%rbp)
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x59ea0
movsd -0x28(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: find_linear_regression_split
int find_linear_regression_split(Instanceptr data, Instanceptr* left, Instanceptr* right)
{
	/*!Last Changed 24.03.2005*/
	int size = data_size(data);
	Instanceptr list;
	if (size < 2)
		 return 0;
	list = k_means_clustering(data, 2);
	*left = list;
	*right = list->next;
	list->next = NULL;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x449f0
movl %eax, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0xa7b3f
movl $0x0, -0x4(%rbp)
jmp 0xa7b7e
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11ad0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: find_quadratic_regression_split
int find_quadratic_regression_split(Instanceptr data, Instanceptr* left, Instanceptr* right)
{
	/*!Last Changed 23.03.2005*/
	Instanceptr newlist, list;
	int size = data_size(data), oldfcount;
	if (size < 2)
		 return 0;
 newlist = generate_2d_copy_of_instance_list(data);
 oldfcount = current_dataset->multifeaturecount;
	current_dataset->multifeaturecount = multifeaturecount_2d(current_dataset) + 1;
	list = k_means_clustering(newlist, 2);
	*left = list;
	*right = list->next;
	list->next = NULL;
	deallocate(newlist);
 current_dataset->multifeaturecount = oldfcount;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x449f0
movl %eax, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
jge 0xa7bc2
movl $0x0, -0x4(%rbp)
jmp 0xa7c61
movq -0x10(%rbp), %rdi
callq 0x44590
movq %rax, -0x28(%rbp)
leaq 0x5dc6a(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x38(%rbp)
leaq 0x5dc57(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1b690
movl %eax, %ecx
addl $0x1, %ecx
leaq 0x5dc43(%rip), %rax     # 0x105840
movq (%rax), %rax
movl %ecx, 0x1c0(%rax)
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x11ad0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rdi
callq 0x44510
movl -0x38(%rbp), %ecx
leaq 0x5dbef(%rip), %rax     # 0x105840
movq (%rax), %rax
movl %ecx, 0x1c0(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: find_uni_and_multi_regression_splits
void find_uni_and_multi_regression_splits(Regressionnodeptr node, Instanceptr* leftlincenter, Instanceptr* rightlincenter, Instanceptr* leftquacenter, Instanceptr* rightquacenter)
{
	/*!Last Changed 24.03.2005*/
	char dummy3;
 if (node->leaftype == CONSTANTLEAF)
   node->featureno = best_regression_feature(node->instances, &(node->split), &dummy3);
	else
		 node->featureno = best_regression_feature_linear_leaves(node->instances, &(node->split), &dummy3);
 find_linear_regression_split(node->instances, leftlincenter, rightlincenter);
 find_quadratic_regression_split(node->instances, leftquacenter, rightquacenter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xa83ea
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
leaq -0x29(%rbp), %rdx
callq 0xa6720
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
jmp 0xa840c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
leaq -0x29(%rbp), %rdx
callq 0xa6110
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa7b10
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xa7b90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: set_best_model_in_regression_tree
void set_best_model_in_regression_tree(Regressionnodeptr node, int bestmodel, Instanceptr leftl, Instanceptr rightl, Instanceptr leftq, Instanceptr rightq)
{
	/*!Last Changed 24.03.2005*/
	switch (bestmodel)
	 {
	  case MODEL_UNI:deallocate(leftl);
										        deallocate(rightl);
				              deallocate(leftq);
				              deallocate(rightq);
        										break;
	  case MODEL_LIN:node->featureno = LINEAR;
				              node->leftcenter = leftl;
				              node->rightcenter = rightl;
				              deallocate(leftq);
				              deallocate(rightq);
										        break;				      
			case MODEL_QUA:node->featureno = QUADRATIC;
				              node->leftcenter = leftq;
				              node->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 0xa8482
jmp 0xa846b
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0xa84a8
jmp 0xa8475
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0xa84e5
jmp 0xa8520
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 0xa8520
movq -0x8(%rbp), %rax
movl $0xfffffffe, 0x68(%rax) # imm = 0xFFFFFFFE
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rdi
callq 0x44510
movq -0x30(%rbp), %rdi
callq 0x44510
jmp 0xa8520
movq -0x8(%rbp), %rax
movl $0xfffffffd, 0x68(%rax) # imm = 0xFFFFFFFD
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x18(%rbp), %rdi
callq 0x44510
movq -0x20(%rbp), %rdi
callq 0x44510
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: best_single_regression_tree_split
int best_single_regression_tree_split(Regressionnodeptr node, int nodetype)
{
	/*!Last Changed 23.03.2005*/
	char dummy;
	int found;
	switch (nodetype)
	 {
	  case UNIVARIATE:if (node->leaftype == CONSTANTLEAF)
                     return best_regression_feature(node->instances, &(node->split), &dummy);
	                  else
		                   return best_regression_feature_linear_leaves(node->instances, &(node->split), &dummy);
				               break;
		 case LINEAR    :found = find_linear_regression_split(node->instances, &(node->leftcenter), &(node->rightcenter));
				               break;
		 case QUADRATIC :found = find_quadratic_regression_split(node->instances, &(node->leftcenter), &(node->rightcenter));
				               break;
   default        :printf(m1231, nodetype);
                   found = 0;
                   break;
	 }
	if (found)
		 return nodetype;
	else
		 return LEAF_NODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $-0x3, %eax
je 0xa87f8
jmp 0xa8770
movl -0x20(%rbp), %eax
subl $-0x2, %eax
je 0xa87d0
jmp 0xa877a
movl -0x20(%rbp), %eax
testl %eax, %eax
jne 0xa8820
jmp 0xa8787
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xa87b2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
leaq -0x15(%rbp), %rdx
callq 0xa6720
movl %eax, -0x4(%rbp)
jmp 0xa884d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
leaq -0x15(%rbp), %rdx
callq 0xa6110
movl %eax, -0x4(%rbp)
jmp 0xa884d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
movq -0x10(%rbp), %rdx
addq $0x88, %rdx
callq 0xa7b10
movl %eax, -0x1c(%rbp)
jmp 0xa8838
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
movq -0x10(%rbp), %rdx
addq $0x88, %rdx
callq 0xa7b90
movl %eax, -0x1c(%rbp)
jmp 0xa8838
movl -0x14(%rbp), %esi
leaq 0x43ab0(%rip), %rdi     # 0xec2da
movb $0x0, %al
callq 0x4030
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xa8846
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa884d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: best_hybrid_regression_tree_split
int best_hybrid_regression_tree_split(Regressionnodeptr node, Regtree_parameterptr param)
{
	/*!Last Changed 27.03.2005*/
	switch (param->modelselectionmethod)
	 {
	  case MODEL_SELECTION_CV :return best_hybrid_regression_tree_split_crossvalidation(node, param);
				                        break;
			case MODEL_SELECTION_AIC:
			case MODEL_SELECTION_BIC:return best_hybrid_regression_tree_split_aic_or_bic(node, param);
				                        break;
			case MODEL_SELECTION_UNI:return best_single_regression_tree_split(node, UNIVARIATE);
				                        break;
			case MODEL_SELECTION_LIN:return best_single_regression_tree_split(node, LINEAR);
				                        break;
			case MODEL_SELECTION_QUA:return best_single_regression_tree_split(node, QUADRATIC);
				                        break;
   default                 :printf(m1230, param->modelselectionmethod);
                            break;
	 }
	return LEAF_NODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0xa88ef
movq -0x20(%rbp), %rax
leaq 0x43ad8(%rip), %rcx     # 0xec364
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa7c70
movl %eax, -0x4(%rbp)
jmp 0xa890b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa8530
movl %eax, -0x4(%rbp)
jmp 0xa890b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xa8750
movl %eax, -0x4(%rbp)
jmp 0xa890b
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xa8750
movl %eax, -0x4(%rbp)
jmp 0xa890b
movq -0x10(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xa8750
movl %eax, -0x4(%rbp)
jmp 0xa890b
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x43977(%rip), %rdi     # 0xec274
movb $0x0, %al
callq 0x4030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: create_regtree
int create_regtree(Regressionnodeptr node, Regtree_parameterptr param)
{
	/*!Last Changed 09.12.2004 rewritten*/
 /*!Last Changed 11.04.2004*/
	if (!(can_be_divided_regression(node, param)))
   return 1;
	node->featureno = best_hybrid_regression_tree_split(node, param);
 if (!(make_regression_children(node, param->leaftype)))
   return 1;
 create_regtree(node->left, param);
 create_regtree(node->right, param);
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa76f0
cmpl $0x0, %eax
jne 0xa894b
movl $0x1, -0x4(%rbp)
jmp 0xa89a6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa8860
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xa7070
cmpl $0x0, %eax
jne 0xa897e
movl $0x1, -0x4(%rbp)
jmp 0xa89a6
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xa8920
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xa8920
movl $0x1, -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: inorder_traversal_regression_tree
void inorder_traversal_regression_tree(Regressionnodeptr node, int* index)
{
 if (node)
  { 
   inorder_traversal_regression_tree(node->left, index);
   node->x = *index;
   (*index)++;
   inorder_traversal_regression_tree(node->right, index);   
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa8a03
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xa89b0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xa89b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: level_of_regression_tree
void level_of_regression_tree(Regressionnodeptr node)
{
 if (node)
  {
   if (node->parent)
     node->y = node->parent->y + 1;
   else
     node->y = 0;
   level_of_regression_tree(node->left);
   level_of_regression_tree(node->right);   
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa8a72
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xa8a4b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x94(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x94(%rax)
jmp 0xa8a59
movq -0x8(%rbp), %rax
movl $0x0, 0x94(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa8a10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa8a10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: soft_regtree_dimension_reduction
void soft_regtree_dimension_reduction(Regressionnodeptr node, char st[READLINELENGTH], int level)
{
 int i, count;
	if (node->featureno != LEAF_NODE)
	 {
   count = 0;
   for (i = 0; i < current_dataset->multifeaturecount; i++)
     if (node->w.values[i][0] != 0)
       count++;
   sprintf(st,"%s%d-%d;", st, level, count);
   soft_regtree_dimension_reduction(node->left, st, level + 1);
   soft_regtree_dimension_reduction(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 0xa8b45
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x5cd87(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1c0(%rcx), %eax
jge 0xa8afb
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa8ae5
jp 0xa8ae5
jmp 0xa8aee
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa8af0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa8aaf
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq 0x3e9e0(%rip), %rsi     # 0xe74f1
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xa8a80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xa8a80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: depth_of_regression_tree
int depth_of_regression_tree(Regressionnodeptr node)
{
 /*!Last Changed 12.07.2006*/
 int leftdepth, rightdepth;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   leftdepth = depth_of_regression_tree(node->left);
   rightdepth = depth_of_regression_tree(node->right);
   if (leftdepth >= rightdepth)
     return leftdepth + 1;
   else
     return rightdepth + 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xa8b6f
movl $0x1, -0x4(%rbp)
jmp 0xa8baa
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa8b50
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa8b50
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0xa8ba1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa8baa
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: estimate_sigma_square_with_heuristic
double estimate_sigma_square_with_heuristic(Instanceptr data)
{
	/*!Last Changed 02.03.2005*/
	double* values, difference = +INT_MAX, d;
	Instanceptr tmp;
	int size = data_size(data), i;
	values = safemalloc(size * sizeof(double), "estimate_sigma_square_with_heuristic", 4);
	tmp = data;
	i = 0;
	while (tmp)
	 {
		 values[i] = give_regressionvalue(tmp);
			tmp = tmp->next;
		 i++;
	 }
	qsort(values, size, sizeof(double), sort_function_double_ascending);
	for (i = 0; i < size - 1; i++)
	 {
		 d = values[i + 1] - values[i];
		 if ((!dequal(d, 0)) && d < difference)
				 difference = d;
	 }
	safe_free(values);
	return difference * difference;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd 0x393fc(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x449f0
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x43793(%rip), %rsi     # 0xec3c7
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa8c85
movq -0x28(%rbp), %rdi
callq 0x43580
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xa8c51
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
movl $0x8, %edx
leaq -0x557d9(%rip), %rcx    # 0x534c0
callq 0x41f0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa8d0f
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x526b0
cmpl $0x0, %eax
jne 0xa8d02
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa8d02
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xa8d04
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xa8ca5
movq -0x10(%rbp), %rdi
callq 0x52e80
movsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressiontree.c
// Function: estimate_sigma_square_with_knn
double estimate_sigma_square_with_knn(Instanceptr data, int nearcount)
{
	/*!Last Changed 01.03.2005*/
	Instanceptr tmp, *nearestneighbors;
	int N = 0, i;
	double result = 0, yvalue, realvalue, h;
	tmp = data;
	while (tmp)
	 {
		 nearestneighbors = find_nearest_neighbors(data, tmp, nearcount);
			yvalue = 0;
			for (i = 0; i < nearcount; i++)
  			yvalue += give_regressionvalue(nearestneighbors[i]);
			yvalue /= nearcount;
			safe_free(nearestneighbors);
   realvalue = give_regressionvalue(tmp);
			result += (double) ((realvalue - yvalue) * (realvalue - yvalue));
			N++;
			tmp = tmp->next;
	 }
	h = pow(N, 0.8) / nearcount;
 return result / (N - h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa8e1c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x467e0
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa8db2
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x43580
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa8d84
cvtsi2sdl -0xc(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rdi
callq 0x43580
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
subsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa8d56
cvtsi2sdl -0x24(%rbp), %xmm0
movsd 0x3ba67(%rip), %xmm1    # 0xe4890
callq 0x4290
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
subsd -0x48(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rise.c
// Function: nearest_example_not_covered
Instanceptr nearest_example_not_covered(Model_riseptr m, Decisionruleptr rule, Instanceptr instances)
{
 Instanceptr tmp, nearest = NULL;
 double distance, mindistance = +INT_MAX;
 tmp = instances;
 while (tmp)
  {
   if (give_classno(tmp) == rule->classno && !rule_cover_instance(tmp, *rule))
    {
     distance = distance_to_rule(m, tmp, rule);
     if (distance < mindistance)
      {
       mindistance = distance;
       nearest = tmp;
      }
    }
   tmp = tmp->next;
  }
 return nearest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movsd 0x3775c(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaa95b
movq -0x20(%rbp), %rdi
callq 0x43530
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xaa94a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xacfd0
cmpl $0x0, %eax
jne 0xaa94a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xaa970
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xaa948
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xaa94a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xaa8c1
movq -0x28(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rise.c
// Function: accuracy_of_ruleset
int accuracy_of_ruleset(Decisionruleptr* nearestrule, Instanceptr instances)
{
 int accuracy = 0, i = 0;
 Decisionruleptr rule;
 Instanceptr tmp;
 tmp = instances;
 while (tmp)
  {
   rule = nearestrule[i];
   if (rule)
    {
     if (give_classno(tmp) == rule->classno)
       accuracy++;
    }
   i++;
   tmp = tmp->next;
  }
 return accuracy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xab587
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xab570
movq -0x28(%rbp), %rdi
callq 0x43530
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xab56e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xab570
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xab536
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: complexity_of_rule
int complexity_of_rule(Decisionruleptr rule)
{
 /*!Last Changed 19.02.2005*/
	int result = 0;
	Decisionconditionptr condition;
	condition = rule->start;
	while (condition)
	 {
		 result += condition->freeparam + 1;
		 condition = condition->next;
	 }
	return result; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xabaf0
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
addl $0x1, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xabacb
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: complexity_of_ruleset
int complexity_of_ruleset(Ruleset set, int positive)
{
 /*!Last Changed 19.02.2005*/
	int result = 0;
	Decisionruleptr rule;
	rule = set.start;
	while (rule)
	 {
		 if (rule->classno == positive)
				 result += complexity_of_rule(rule);
		 rule = rule->next;
	 }
	return result; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xabb4c
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xabb3e
movq -0x10(%rbp), %rdi
callq 0xabab0
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xabb1d
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: ruleset_complexity
int ruleset_complexity(Ruleset set)
{
 /*!Last Changed 20.02.2005*/
	int result = 0;
	Decisionruleptr rule;
	rule = set.start;
	while (rule)
	 {
			result += complexity_of_rule(rule);
		 rule = rule->next;
	 }
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movl $0x0, -0x4(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xabb9e
movq -0x10(%rbp), %rdi
callq 0xabab0
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xabb7a
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: description_length_of_rule
double description_length_of_rule(Decisionrule r, int possibleconditioncount)
{
 /*!Last Changed 02.12.2003*/
 double result = 0;
 if (r.decisioncount != 0)
   result += log2(r.decisioncount);
 if (log2(r.decisioncount) > 1)
   result += log2(log2(r.decisioncount));
 result += S(possibleconditioncount, r.decisioncount, (r.decisioncount + 0.0) / possibleconditioncount);
 return result / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x4(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
cmpl $0x0, 0x28(%rax)
je 0xabcb9
movq -0x18(%rbp), %rax
cvtsi2sdl 0x28(%rax), %xmm0
callq 0x52ad0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
cvtsi2sdl 0x28(%rax), %xmm0
callq 0x52ad0
movsd 0x36349(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jbe 0xabcf2
movq -0x18(%rbp), %rax
cvtsi2sdl 0x28(%rax), %xmm0
callq 0x52ad0
callq 0x52ad0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %edi
movl 0x28(%rax), %esi
cvtsi2sdl 0x28(%rax), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0xabbb0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x36f73(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: description_length_of_ruleset
double description_length_of_ruleset(Ruleset r, int positive)
{
 /*!Last Changed 02.12.2003 added description_length_of_rule*/
 /*!Last Changed 18.05.2003*/
 double result = 0;
 Decisionruleptr tmp;
 tmp = r.start;
 while (tmp)
  {
   if (tmp->classno == positive || positive == -1)
     result += description_length_of_rule(*tmp, r.possibleconditioncount);
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %edi, -0x4(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xabdc3
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0xabd7a
cmpl $-0x1, -0x4(%rbp)
jne 0xabdb5
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x20(%rax), %edi
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xabc80
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xabd62
movsd -0x10(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: description_length_of_exceptions
double description_length_of_exceptions(int C, int U, int fp, int fn, double proportion)
{
 /*!Last Changed 24.11.2003 added S*/
 /*!Last Changed 04.11.2003 added extra checks for zero division*/
 /*!Last Changed 12.06.2003 added proportion*/
 /*!Last Changed 19.05.2003*/
 double result = 0; 
 int e = fp + fn;
 result = result + log2(C + U + 1);
 if (C >= U)
  {
   if (C != 0)
     result += S(C, fp, (proportion * (e + 0.0)) / C);
   if (U != 0)
     result += S(U, fn, (fn + 0.0) / U);
  }
 else
  {
   proportion = 1 - proportion;
   if (C != 0)
     result += S(C, fp, (fp + 0.0) / C);
   if (U != 0)
     result += S(U, fn, (proportion * (e + 0.0)) / U);
  }
 return result / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x52ad0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0xabe9a
cmpl $0x0, -0x4(%rbp)
je 0xabe68
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0xabbb0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xabe98
movl -0x8(%rbp), %edi
movl -0x10(%rbp), %esi
cvtsi2sdl -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0xabbb0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xabf17
movsd 0x36176(%rip), %xmm0    # 0xe2018
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xabedc
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
cvtsi2sdl -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0xabbb0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xabf15
movl -0x8(%rbp), %edi
movl -0x10(%rbp), %esi
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0xabbb0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xabf17
movsd -0x20(%rbp), %xmm0
movsd 0x36d7c(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: error_of_condition
int error_of_condition(Decisionconditionptr c, Instanceptr list, int positive)
{
	/*!Last Changed 21.01.2004*/
	int error = 0;
	Instanceptr tmp;
	tmp = list;
	while (tmp)
	 {
		 if (condition_cover_instance(tmp, c))
			 {
				 if (give_classno(tmp) != positive)
						 error++;
			 }
			else
				 if (give_classno(tmp) == positive)
						 error++;
		 tmp = tmp->next;
	 }
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xabfab
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xabfc0
cmpl $0x0, %eax
je 0xabf84
movq -0x20(%rbp), %rdi
callq 0x43530
cmpl -0x14(%rbp), %eax
je 0xabf82
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xabf9d
movq -0x20(%rbp), %rdi
callq 0x43530
cmpl -0x14(%rbp), %eax
jne 0xabf9b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xabf9d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xabf52
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: count_examples_for_condition
void count_examples_for_condition(Decisionconditionptr c, int* p, int* n, int posclass, Instanceptr list)
{
	/*!Last Changed 02.12.2003*/
	Instanceptr tmp;
	*p = 0;
	*n = 0;
	tmp = list;
	while (tmp)
	 {
		 if (condition_cover_instance(tmp, c))
    {
				 if (give_classno(tmp) == posclass)
						 (*p)++;
					else
						 (*n)++;
    }
		 tmp = tmp->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xac456
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xabfc0
cmpl $0x0, %eax
je 0xac448
movq -0x30(%rbp), %rdi
callq 0x43530
cmpl -0x1c(%rbp), %eax
jne 0xac43b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xac446
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xac448
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xac407
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: condition_count
int condition_count(Ruleset r)
{
	/*!Last Changed 10.11.2003*/
	int result = 0;
	Decisionruleptr tmp;
	tmp = r.start;
	while (tmp)
	 {
		 result += tmp->decisioncount;
		 tmp = tmp->next;
	 }
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movl $0x0, -0x4(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xac498
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xac476
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: write_rule
void write_rule(Decisionruleptr rule)
{
	/*!Last Changed 30.10.2003*/
	Decisionconditionptr condition;
	condition = rule->start;
	while (condition)
	 {
		 write_condition(condition);
		 condition = condition->next;
	 }
	fprintf(output, " THEN CLASS = %s.(%d/%d)\n",current_dataset->features[current_dataset->classdefno].strings[rule->classno], rule->covered, rule->falsepositives);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xace36
movq -0x10(%rbp), %rdi
callq 0xac4a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xace18
leaq 0x33523b(%rip), %rax    # 0x3e2078
movq (%rax), %rdi
leaq 0x589f9(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
leaq 0x589e9(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movslq 0x1407128(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %r8d
leaq 0x3f60c(%rip), %rsi     # 0xec499
movb $0x0, %al
callq 0x4280
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: write_ruleset
void write_ruleset(Ruleset r)
{
	/*!Last Changed 30.10.2003*/
	Decisionruleptr rule;
	rule = r.start;
	while (rule)
	 {
		 write_rule(rule);
		 rule = rule->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xaced1
movq -0x8(%rbp), %rdi
callq 0xace00
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xaceb3
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: error_of_ruleset
int error_of_ruleset(Ruleset set,Instanceptr traindata)
{
	/*!Last Changed 14.01.2004*/
 /*!Last Changed 04.11.2003*/
 int instanceclassno, covered, error;
 Instanceptr test = traindata;
	Decisionruleptr tmp;
	error = 0;
 while (test)
  {
   instanceclassno = give_classno(test);
			covered = 0;
			tmp = set.start;
			while (tmp)
			 {
				 if (rule_cover_instance(test, *tmp))
					 {
       if (instanceclassno != tmp->classno)
								 error++;
							covered = 1;
							break;
					 }
				 tmp = tmp->next;
			 }
			if (!covered)
				 if (instanceclassno != set.defaultclass)
						 error++;
   test=test->next;
  }
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xacfc1
movq -0x20(%rbp), %rdi
callq 0x43530
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xacf93
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xacfd0
cmpl $0x0, %eax
je 0xacf85
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
je 0xacf7c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x10(%rbp)
jmp 0xacf93
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xacf2e
cmpl $0x0, -0x10(%rbp)
jne 0xacfb0
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
je 0xacfae
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xacfb0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xacf03
movl -0x14(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: rule_cover_instance
int rule_cover_instance(Instanceptr instance, Decisionrule rule)
{
	/*!Last Changed 10.05.2003*/
	Decisionconditionptr tmp = rule.start;
	while (tmp)
	 {
		 if (!condition_cover_instance(instance, tmp))
				 return NO;
		 tmp = tmp->next;
	 }
	return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xad018
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xabfc0
cmpl $0x0, %eax
jne 0xad00a
movl $0x0, -0x4(%rbp)
jmp 0xad01f
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xacfe8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: exception_handling
void exception_handling(Ruleset r, Instanceptr instances, int positive, int* C, int* U, int* fp, int* fn)
{
	/*!Last Changed 19.05.2003 More than two classes are considered again*/
 /*!Last Changed 18.05.2003*/
	Instanceptr tmp = instances;
	Decisionruleptr rule;
	int covered, instanceclassno;
 while (tmp)
	 {
	  instanceclassno = give_classno(tmp);
		 rule = r.start;
			covered = 0;
			while (rule)
			 {
				 if ((rule->classno == positive || positive == -1) && rule_cover_instance(tmp, *rule))
					 {
						 covered = 1;
							(*C)++;
				   if (instanceclassno != rule->classno)
								 (*fp)++;
						 break;
					 }
				 rule = rule->next;
			 }
			if (!covered)
			 {
				 (*U)++;
				 if (instanceclassno == positive || (positive == -1 && instanceclassno != r.defaultclass))
						 (*fn)++;
			 }
		 tmp = tmp -> next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xad15c
movq -0x38(%rbp), %rdi
callq 0x43530
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, -0x48(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xad113
movq -0x40(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xad0a5
cmpl $-0x1, -0xc(%rbp)
jne 0xad102
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xacfd0
cmpl $0x0, %eax
je 0xad102
movl $0x1, -0x44(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x48(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl (%rcx), %eax
je 0xad100
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xad113
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xad08d
cmpl $0x0, -0x44(%rbp)
jne 0xad14b
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x48(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0xad13e
cmpl $-0x1, -0xc(%rbp)
jne 0xad149
movq -0x50(%rbp), %rcx
movl -0x48(%rbp), %eax
cmpl 0x14(%rcx), %eax
je 0xad149
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xad14b
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xad062
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)