LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_svmreg
void* train_svmreg(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	/*!Last Changed 03.05.2005*/
 Partition dummyp;
	Svm_modelptr model;
	Svm_problem prob;
	Svm_parameterptr param;
	dummyp = get_two_class_partition();
	prepare_svm_problem(&prob, EPSILON_SVR, *trdata, dummyp);
	free_partition(dummyp);
	param = (Svm_parameter*) parameters;
 model = svm_train(prob, *param, 0);
	return model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x78(%rbp), %rdi
movb $0x0, %al
callq 0x7a760
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xcaf10
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7aa80
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
xorl %eax, %eax
movq 0x50(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x70(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x60(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x50(%rax)
movups %xmm2, 0x40(%rax)
movups %xmm1, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %edi, %edi
callq 0xc7240
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_svmreg
Prediction test_svmreg(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 03.05.2005*/
	Svm_nodeptr node;
 Prediction predicted;
	Svm_modelptr m;
 double* dec_values;
 double y = give_regressionvalue(data);
	m = (Svm_modelptr) model;
	node = instance_to_svmnode(data);
 dec_values = safemalloc(sizeof(double), "test_svm", 7);
 svm_predict_values(m, node, dec_values);
 predicted.epsilonloss = epsilon_sensitive_loss(y, dec_values[0], get_parameter_f("svmepsilon"));
 safe_free(dec_values); 
	predicted.regvalue = svm_predict(m, node);
	safe_free(node);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43580
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42b00
movq %rax, -0x28(%rbp)
movl $0x8, %edi
leaq 0x40127(%rip), %rsi     # 0xe2c76
movl $0x7, %edx
callq 0x52d70
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xc85c0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq 0x3fc31(%rip), %rdi     # 0xe27bd
callq 0x79040
movsd -0x60(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x58(%rbp), %xmm0
callq 0x65ea0
movq -0x50(%rbp), %rdi
movsd %xmm0, 0x18(%rdi)
movq -0x38(%rbp), %rdi
callq 0x52e80
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc9ce0
movq -0x50(%rbp), %rdi
movsd %xmm0, (%rdi)
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: write_nodetypes_regression_rule
void write_nodetypes_regression_rule(Regressionruleset r, char* st)
{
	/*!Last Changed 06.03.2005*/
	Regressionruleptr tmprule;
	Regressionconditionptr tmpcondition;
 sprintf(st, "%s", "");
	tmprule = r.start;
	while (tmprule)
	 {
		 tmpcondition = tmprule->start;
			while (tmpcondition)
			 {				 
				 if (tmpcondition->featureindex == LINEAR)
  				 sprintf(st, "%sL", st);
					else
						 if (tmpcondition->featureindex == QUADRATIC)
						   sprintf(st, "%sQ", st);
							else
								 sprintf(st, "%sU", st);
				 tmpcondition = tmpcondition->next;
			 }
			sprintf(st, "%s;", st);
		 tmprule = tmprule->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x41e09(%rip), %rsi     # 0xe4a98
leaq 0x4b344(%rip), %rdx     # 0xedfda
movb $0x0, %al
callq 0x4170
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa2d55
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa2d2e
movq -0x18(%rbp), %rax
cmpl $-0x2, (%rax)
jne 0xa2ce7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x446dd(%rip), %rsi     # 0xe73bb
movb $0x0, %al
callq 0x4170
jmp 0xa2d20
movq -0x18(%rbp), %rax
cmpl $-0x3, (%rax)
jne 0xa2d08
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x446c0(%rip), %rsi     # 0xe73bf
movb $0x0, %al
callq 0x4170
jmp 0xa2d1e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x446ac(%rip), %rsi     # 0xe73c3
movb $0x0, %al
callq 0x4170
jmp 0xa2d20
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa2cbf
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x44698(%rip), %rsi     # 0xe73d5
movb $0x0, %al
callq 0x4170
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa2ca8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: regression_condition_count
int regression_condition_count(Regressionruleset r)
{
	/*!Last Changed 06.03.2005*/
	int result = 0;
	Regressionruleptr tmp;
	tmp = r.start;
	while (tmp)
	 {
		 result += tmp->conditioncount;
		 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 0xa2d98
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa2d76
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: generalization_error_of_regression_ruleset
double generalization_error_of_regression_ruleset(Regressionruleset r, Instanceptr data, MODEL_SELECTION_TYPE modelselectionmethod)
{
	/*!Last Changed 04.03.2005*/
	double error;
	int complexity, size;
	error = mse_of_ruleset(r, data, &size);
	complexity = complexity_of_regression_ruleset(r);
	switch (modelselectionmethod)
	 {
	  case MODEL_SELECTION_CV :return error;
				                        break;
			case MODEL_SELECTION_AIC:return aic_squared_error(error, complexity, size);
				                        break;
			case MODEL_SELECTION_BIC:return bic_squared_error(error, complexity, size);
				                        break;
   default                 :printf(m1230, modelselectionmethod);
                            break;
	 }
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
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)
leaq -0x28(%rbp), %rsi
callq 0xa3430
movq -0x38(%rbp), %rcx
movsd %xmm0, -0x20(%rbp)
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 0xa3540
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0xa2fd7
jmp 0xa2fc3
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0xa2fe3
jmp 0xa2fcd
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0xa2ffc
jmp 0xa3015
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa3030
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
movl -0x28(%rbp), %edi
callq 0x663e0
movsd %xmm0, -0x8(%rbp)
jmp 0xa3030
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
movl -0x28(%rbp), %edi
callq 0x66950
movsd %xmm0, -0x8(%rbp)
jmp 0xa3030
movl -0x14(%rbp), %esi
leaq 0x49255(%rip), %rdi     # 0xec274
movb $0x0, %al
callq 0x4030
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: remove_regression_rule_after
void remove_regression_rule_after(Regressionruleset* r, Regressionruleptr before, Regressionruleptr deleted)
{
	/*!Last Changed 04.03.2005*/
	r->rulecount--;
	if (r->rulecount == 0)
	 {
		 r->start = NULL;
			r->end = NULL;
	 }
	else
	 {
	  if (deleted->next == NULL)
	  	 r->end = before;
	  if (before == NULL)
	  	 r->start = deleted->next;
	  else
		   before->next = deleted->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0xa3080
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xa30c1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xa3097
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xa30af
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa30bf
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0xa30c1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: add_regression_rule_after
void add_regression_rule_after(Regressionruleset* r, Regressionruleptr before, Regressionruleptr inserted)
{
	/*!Last Changed 04.03.2005*/
	r->rulecount++;
	if (before == NULL)
	 {
		 inserted->next = r->start;
		 r->start = inserted;
	 }
	else
	 {
		 inserted->next = before->next;
		 before->next = inserted;
	 }
	if (inserted->next == NULL)
			r->end = inserted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xa3110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa312c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xa3143
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: free_regression_rule
void free_regression_rule(Regressionrule rule)
{
	/*!Last Changed 27.03.2005*/
	/*!Last Changed 02.03.2005*/
	Regressionconditionptr tmp, next;
	tmp = rule.start;
	while (tmp)
	 {
		 next = tmp->next;
			if (in_list(tmp->featureindex, 2, LINEAR, QUADRATIC))
			 {
				 deallocate(tmp->leftcenter);
				 deallocate(tmp->rightcenter);
			 }
			safe_free(tmp);
			tmp = next;
	 }
	if (rule.leaftype == LINEARLEAF)
		 matrix_free(rule.w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa31c9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%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 0xa31b6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x44510
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44510
movq -0x8(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa3168
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0xa31e3
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: generalization_error_of_regression_rule
double generalization_error_of_regression_rule(Regressionruleptr rule, Instanceptr data, MODEL_SELECTION_TYPE modelselectionmethod)
{
	/*!Last Changed 06.03.2005*/
	double error;
	int complexity, size;
	error = mse_of_rule(rule, data, &size);
	complexity = complexity_of_regression_rule(rule);
	switch (modelselectionmethod)
	 {
	  case MODEL_SELECTION_CV :return error;
				                        break;
			case MODEL_SELECTION_AIC:return aic_squared_error(error, complexity, size);
				                        break;
			case MODEL_SELECTION_BIC:return bic_squared_error(error, complexity, size);
				                        break;
   default                 :printf(m1230, modelselectionmethod);
                            break;
	 }
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xa32b0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3360
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0xa3245
jmp 0xa3231
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0xa3251
jmp 0xa323b
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0xa326a
jmp 0xa3283
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa329e
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
movl -0x30(%rbp), %edi
callq 0x663e0
movsd %xmm0, -0x8(%rbp)
jmp 0xa329e
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
movl -0x30(%rbp), %edi
callq 0x66950
movsd %xmm0, -0x8(%rbp)
jmp 0xa329e
movl -0x1c(%rbp), %esi
leaq 0x48fe7(%rip), %rdi     # 0xec274
movb $0x0, %al
callq 0x4030
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: mse_of_rule
double mse_of_rule(Regressionruleptr c, Instanceptr list, int* covered)
{
	/*!Last Changed 02.03.2005*/
	Instanceptr tmp;
	double result = 0;
	tmp = list;
	*covered = 0;
	while (tmp)
	 {
		 if (regression_rule_cover_instance(tmp, c))
			 {
				 (*covered)++;
					result += instance_regression_error(c->w, c->regressionvalue, tmp, c->leaftype);
			 }
		 tmp = tmp->next;
	 }
	return result / (*covered);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0xa333e
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xa4520
cmpl $0x0, %eax
je 0xa3330
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xa6b40
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa32de
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: complexity_of_regression_rule
int complexity_of_regression_rule(Regressionruleptr rule)
{
	/*!Last Changed 27.03.2005*/
	/*!Last Changed 02.03.2005*/
	int result = 0;
 Regressionconditionptr tmp;
	tmp = rule->start;
	while (tmp)
	 {
		 if (tmp->featureindex >= 0)
  		 result += 2;
			else
				 if (tmp->featureindex == LINEAR)
						 result += current_dataset->multifeaturecount;
					else
						 if (tmp->featureindex == QUADRATIC)
								 result += multifeaturecount_2d(current_dataset) + 1;
		 tmp = tmp->next;
	 }
	if (rule->leaftype == CONSTANTLEAF)
		 result += 1;
	else
		 result += current_dataset->multifeaturecount;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa33ee
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jl 0xa339a
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0xa33e0
movq -0x18(%rbp), %rax
cmpl $-0x2, (%rax)
jne 0xa33bb
leaq 0x62496(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xa33de
movq -0x18(%rbp), %rax
cmpl $-0x3, (%rax)
jne 0xa33dc
leaq 0x62475(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1b690
addl $0x1, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xa33de
jmp 0xa33e0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa337f
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xa3403
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa3419
leaq 0x62436(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: mse_of_ruleset
double mse_of_ruleset(Regressionruleset set, Instanceptr list, int* count)
{
	/*!Last Changed 02.03.2005*/
	int iscovered;
	Instanceptr tmp;
 Regressionruleptr rule;
	double result = 0;
	*count = 0;
	tmp = list;
	while (tmp)
	 {
		 rule = set.start;
			iscovered = 0;
			while (rule)
			 {
	  	 if (regression_rule_cover_instance(tmp, rule))
					 {
		  			result += instance_regression_error(rule->w, rule->regressionvalue, tmp, rule->leaftype);
							iscovered = 1;
							break;
					 }
					rule = rule->next;
			 }
			if (!iscovered)
				 result += instance_regression_error(set.w, set.regressionvalue, tmp, set.leaftype);
		 tmp = tmp->next;
			(*count)++;
	 }
	return result / (*count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa3526
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa34dd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa4520
cmpl $0x0, %eax
je 0xa34cf
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %ecx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xa6b40
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x14(%rbp)
jmp 0xa34dd
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa347f
cmpl $0x0, -0x14(%rbp)
jne 0xa350a
movq -0x38(%rbp), %rax
movsd 0x28(%rax), %xmm0
movq -0x20(%rbp), %rdx
movl 0x20(%rax), %ecx
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
callq 0xa6b40
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xa3462
movsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: complexity_of_regression_ruleset
int complexity_of_regression_ruleset(Regressionruleset set)
{
	/*!Last Changed 02.03.2005*/
	int result = 0;
	Regressionruleptr rule;
	rule = set.start;
	while (rule)
	 {
		 result += complexity_of_regression_rule(rule);
		 rule = rule->next;
	 }
	if (set.leaftype == CONSTANTLEAF)
		 result += 1;
	else
		 result += current_dataset->multifeaturecount;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa3582
movq -0x10(%rbp), %rdi
callq 0xa3360
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa355e
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xa3597
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa35ad
leaq 0x622a2(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
addl -0x4(%rbp), %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/regressionrule.c
// Function: can_be_divided_rule
int can_be_divided_rule(Instanceptr data, double sigma, matrix* w, double* regvalue, LEAF_TYPE leaftype)
{
	/*!Last Changed 03.04.2005 added size < 3*/
	/*!Last Changed 02.03.2005*/
	int size;
	matrix X, r;
	double error;
	size = data_size(data);
	if (size < 3)
		 return 0;
	if (leaftype == CONSTANTLEAF)
	 {
  	*regvalue = find_mean_of_regression_value(data);
			error = find_variance_of_regression_value(data, *regvalue);
	 }
	else
	 {
   create_regression_matrices(data, &X, &r);
		 *w = multivariate_regression(X, r);
			matrix_free(X);
			matrix_free(r);
			error = variance_of_linear_regression(*w, data, leaftype);
	 }
	if (error / size < sigma)
		 return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x449f0
movl %eax, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0xa3f1a
movl $0x0, -0x4(%rbp)
jmp 0xa3ff7
cmpl $0x0, -0x2c(%rbp)
jne 0xa3f4c
movq -0x10(%rbp), %rdi
callq 0x44600
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
callq 0x44690
movsd %xmm0, -0x58(%rbp)
jmp 0xa3fce
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xa6c20
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xa6590
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59ea0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x59ea0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xa6bb0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm1
cvtsi2sdl -0x30(%rbp), %xmm0
divsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa3ff0
movl $0x0, -0x4(%rbp)
jmp 0xa3ff7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: grow_regression_rule
Regressionruleptr grow_regression_rule(Instanceptr* growset, Regrule_parameterptr param)
{
	/*!Last Changed 02.03.2005*/
	Regressionruleptr result;
	Regressionconditionptr newcondition;
	matrix w;
	double regvalue;
	Instanceptr obey, notobey = NULL;
 result = empty_regression_rule();
	result->leaftype = param->leaftype;
	obey = (*growset);
 while (can_be_divided_rule(obey, param->sigma, &w, &regvalue, param->leaftype))
	 {
			newcondition = best_regression_condition(&obey, param);
			if (newcondition->featureindex == LEAF_NODE || newcondition->comparison == '=')
			 {
				 safe_free(newcondition);
				 break;
			 }
			else
			 {
				 add_regression_condition(result, newcondition);
					send_regression_exceptions(newcondition, &obey, &notobey);
			 }
		 if (param->leaftype == LINEARLEAF)
  		 matrix_free(w);
	 }
	result->covered = data_size(obey);
	if (notobey)
	 {
   merge_instancelist(&notobey, obey);
	  (*growset) = notobey;
	 }
	else
		 (*growset) = obey;
 if (param->leaftype == CONSTANTLEAF)
	  result->regressionvalue = regvalue;
	else
   result->w = w;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x48(%rbp)
callq 0xa4980
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xa3ee0
cmpl $0x0, %eax
je 0xa40c9
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xa56e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xa4085
movq -0x20(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x3d, %eax
jne 0xa4090
movq -0x20(%rbp), %rdi
callq 0x52e80
jmp 0xa40c9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa4880
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xa4660
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xa40c4
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ea0
jmp 0xa4039
movq -0x40(%rbp), %rdi
callq 0x449f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
cmpq $0x0, -0x48(%rbp)
je 0xa40fc
movq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x44f40
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa4107
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xa4120
movsd -0x38(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0xa4133
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: prune_regression_rule
void prune_regression_rule(Regressionruleptr rule, Instanceptr dataset, int modelselectionmethod)
{
	/*!Last Changed 04.03.2005*/
	double bestgen, gen;
	int improved = 1;
	Regressioncondition *best, *bestbefore, *tmpcondition, *tmpbefore;
	bestgen = generalization_error_of_regression_rule(rule, dataset, modelselectionmethod);
	while (improved)
	 {
		 improved = 0;
			tmpbefore = NULL;
   tmpcondition = rule->start;
			while (tmpcondition)
			 {
				 remove_regression_condition_after(rule, tmpbefore, tmpcondition);
	    gen = generalization_error_of_regression_rule(rule, dataset, modelselectionmethod);
					if (gen < bestgen)
					 {
						 bestgen = gen;
							bestbefore = tmpbefore;
							best = tmpcondition;
							improved = 1;
					 }
					add_regression_condition_after(rule, tmpbefore, tmpcondition);
				 tmpbefore = tmpcondition;
				 tmpcondition = tmpcondition->next;
			 }
			if (improved)
			 {
				 remove_regression_condition_after(rule, bestbefore, best);
					safe_free(best);
			 }
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xa31f0
movsd %xmm0, -0x20(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xa4245
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xa4220
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xa4580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xa31f0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa41f6
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xa45e0
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xa4194
cmpl $0x0, -0x2c(%rbp)
je 0xa4240
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xa4580
movq -0x38(%rbp), %rdi
callq 0x52e80
jmp 0xa416f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: grow_regression_revision_rule
Regressionruleptr grow_regression_revision_rule(Instanceptr* growset, Regressionruleptr rule, Regrule_parameterptr param)
{
	/*!Last Changed 05.03.2005*/
	Regressionruleptr result = create_copy_of_regression_rule(rule);
	Regressionconditionptr newcondition;
	matrix w;
	double regvalue;
	Instanceptr obey = NULL, notobey;
	notobey = (*growset);
 remove_regression_covered(&notobey, &obey, result);
 while (can_be_divided_rule(obey, param->sigma, &w, &regvalue, rule->leaftype))
	 {
			newcondition = best_regression_condition(&obey, param);
			if (newcondition->featureindex == LEAF_NODE || newcondition->comparison == '=')
			 {
				 safe_free(newcondition);
				 break;
			 }
			else
			 {
				 add_regression_condition(result, newcondition);
					send_regression_exceptions(newcondition, &obey, &notobey);
			 }
		 if (rule->leaftype == LINEARLEAF)
  		 matrix_free(w);
	 }
	result->covered = data_size(obey);
	if (notobey)
	 {
   merge_instancelist(&notobey, obey);
	  (*growset) = notobey;
	 }
	else
		 (*growset) = obey;
 if (rule->leaftype == CONSTANTLEAF)
	  result->regressionvalue = regvalue;
	else
   result->w = w;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa58f0
movq %rax, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa43a0
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xa3ee0
cmpl $0x0, %eax
je 0xa4327
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xa56e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xa42e2
movq -0x28(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x3d, %eax
jne 0xa42ed
movq -0x28(%rbp), %rdi
callq 0x52e80
jmp 0xa4327
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa4880
movq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xa4660
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0xa4322
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
jmp 0xa4295
movq -0x48(%rbp), %rdi
callq 0x449f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x40(%rax)
cmpq $0x0, -0x50(%rbp)
je 0xa435a
movq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x44f40
movq -0x50(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa4365
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xa437f
movsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0xa4392
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: remove_regression_covered
void remove_regression_covered(Instanceptr* list1, Instanceptr* list2, Regressionruleptr rule)
{
	/*!Last Changed 04.03.2005*/
	Instanceptr tmp, next, last, tmpbefore;
	last = *list2;
	if (last)
		 while (last->next)
				 last = last->next;
	tmpbefore = NULL;
	tmp = *list1;
	while (tmp)
	 {
		 next = tmp->next;
   if (regression_rule_cover_instance(tmp, rule))
			 {
				 if (last)
						 last->next = tmp;
					else
						 (*list2) = tmp;
					last = tmp;
			 }
			else
			 {
				 if (tmpbefore)
				   tmpbefore->next = tmp;
					else
						 (*list1) = tmp;
			  tmpbefore = tmp;
			 }
			tmp = next;
	 }
	if (last)
	  last->next = NULL;
	if (tmpbefore)
		 tmpbefore->next = NULL;
	else
		 (*list1) = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa43e3
jmp 0xa43c8
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa43e1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa43c8
jmp 0xa43e3
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa447a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa4520
cmpl $0x0, %eax
je 0xa4445
cmpq $0x0, -0x30(%rbp)
je 0xa4430
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa443b
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xa446d
cmpq $0x0, -0x38(%rbp)
je 0xa445a
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa4465
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xa43f6
cmpq $0x0, -0x30(%rbp)
je 0xa448d
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x38(%rbp)
je 0xa44a2
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0xa44ad
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: add_regression_rule
void add_regression_rule(Regressionruleset* set, Regressionruleptr rule)
{
	/*!Last Changed 04.03.2005*/
	if (set->rulecount == 0)
		 set->start = rule;
	else
		 set->end->next = rule;
	set->end = rule;
	rule->next = NULL;
	set->rulecount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0xa44e3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa44f3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: regression_rule_cover_instance
int regression_rule_cover_instance(Instanceptr instance, Regressionruleptr rule)
{
	/*!Last Changed 02.03.2005*/
	Regressionconditionptr tmp = rule->start;
	while (tmp)
	 {
		 if (!regression_condition_cover_instance(instance, tmp))
				 return NO;
		 tmp = tmp->next;
	 }
	return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa456c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa4780
cmpl $0x0, %eax
jne 0xa455e
movl $0x0, -0x4(%rbp)
jmp 0xa4573
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa453c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: remove_regression_condition_after
void remove_regression_condition_after(Regressionruleptr rule, Regressionconditionptr before, Regressionconditionptr deleted)
{
	/*!Last Changed 04.03.2005*/
	rule->conditioncount--;
	if (deleted->next == NULL)
		 rule->end = before;
	if (before == NULL)
		 rule->start = deleted->next;
	else
		 before->next = deleted->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xa45b4
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xa45cd
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xa45dd
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: add_regression_condition_after
void add_regression_condition_after(Regressionruleptr rule, Regressionconditionptr before, Regressionconditionptr inserted)
{
	/*!Last Changed 04.03.2005*/
	rule->conditioncount++;
	if (before == NULL)
	 {
		 inserted->next = rule->start;
		 rule->start = inserted;
	 }
	else
	 {
		 inserted->next = before->next;
		 before->next = inserted;
	 }
	if (inserted->next == NULL)
			rule->end = inserted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xa4622
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xa463e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xa4655
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: send_regression_exceptions
void send_regression_exceptions(Regressionconditionptr condition, Instanceptr* obey, Instanceptr* notobey)
{
	/*!Last Changed 02.03.2005*/
	Instanceptr tmp, next, last, tmpbefore;
	last = *notobey;
	if (last)
		 while (last->next)
				 last = last->next;
	tmpbefore = NULL;
	tmp = *obey;
	while (tmp)
	 {
		 next = tmp->next;
   if (!regression_condition_cover_instance(tmp, condition))
			 {
				 if (last)
						 last->next = tmp;
					else
						 (*notobey) = tmp;
					last = tmp;
			 }
			else
			 {
				 if (tmpbefore)
				   tmpbefore->next = tmp;
					else
						 (*obey) = tmp;
			  tmpbefore = tmp;
			 }
			tmp = next;
	 }
	if (last)
	  last->next = NULL;
	if (tmpbefore)
		 tmpbefore->next = NULL;
	else
		 (*obey) = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa46a3
jmp 0xa4688
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa46a1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa4688
jmp 0xa46a3
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa473a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xa4780
cmpl $0x0, %eax
jne 0xa4705
cmpq $0x0, -0x30(%rbp)
je 0xa46f0
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa46fb
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xa472d
cmpq $0x0, -0x38(%rbp)
je 0xa471a
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa4725
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xa46b6
cmpq $0x0, -0x30(%rbp)
je 0xa474d
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x38(%rbp)
je 0xa4762
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0xa476d
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: regression_condition_cover_instance
int regression_condition_cover_instance(Instanceptr instance, Regressionconditionptr condition)
{
	/*!Last Changed 27.03.2005*/
	/*!Last Changed 02.03.2005*/
	int fno;
 CHILD_TYPE nearest;
	double value;
	fno = condition->featureindex;
	if (fno >= 0)
	 {
		 value = real_feature(instance, fno);
			if (value < condition->value && condition->comparison == '>')
					return NO;
			if (value > condition->value && condition->comparison == '<')
					return NO;
	 }
	else
	 {
		 nearest = nearest_center_in_regression_tree(instance, condition->featureindex, condition->leftcenter, condition->rightcenter);
		 if (nearest == LEFTCHILD && condition->comparison == '>')
				 return NO;
		 if (nearest == RIGHTCHILD && condition->comparison == '<')
				 return NO;
  }
	return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xa4805
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa47dd
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x3e, %eax
jne 0xa47dd
movl $0x0, -0x4(%rbp)
jmp 0xa4868
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0xa4803
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x3c, %eax
jne 0xa4803
movl $0x0, -0x4(%rbp)
jmp 0xa4868
jmp 0xa4861
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0xa5ce0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0xa4843
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x3e, %eax
jne 0xa4843
movl $0x0, -0x4(%rbp)
jmp 0xa4868
cmpl $0x1, -0x20(%rbp)
jne 0xa485f
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x3c, %eax
jne 0xa485f
movl $0x0, -0x4(%rbp)
jmp 0xa4868
jmp 0xa4861
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: add_regression_condition
void add_regression_condition(Regressionruleptr rule, Regressionconditionptr condition)
{
	/*!Last Changed 02.03.2005*/
	rule->conditioncount++;
	if (rule->conditioncount == 1)
		 rule->start = condition;
	else
	  rule->end->next = condition;
	rule->end = condition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0xa48b1
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xa48c1
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: free_regression_ruleset
void free_regression_ruleset(Regressionruleset r)
{
 /*!Last Changed 31.08.2008 added freeing weights*/
	/*!Last Changed 02.03.2005*/
	Regressionruleptr tmp, next;
	tmp = r.start;
	while (tmp)
	 {
		 next = tmp->next;
			free_regression_rule(*tmp);
			safe_free(tmp);
			tmp = next;
	 }
 if (r.leaftype == LINEARLEAF)
   matrix_free(r.w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa493f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xa3150
movq -0x8(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa48e7
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0xa495a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
callq 0x59ea0
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: empty_regression_ruleset
Regressionruleset empty_regression_ruleset()
{
	/*!Last Changed 02.03.2005*/
	Regressionruleset r;
	r.rulecount = 0;
	r.start = NULL;
	r.end = NULL;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl $0x0, 0x30(%rdi)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: empty_regression_rule
Regressionruleptr empty_regression_rule()
{
	/*!Last Changed 02.03.2005*/
	Regressionruleptr newrule = safemalloc(sizeof(Regressionrule), "empty_regression_rule", 1);
	newrule->conditioncount = 0;
	newrule->start = NULL;
	newrule->end = NULL;
	newrule->next = NULL;
	return newrule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x48, %edi
leaq 0x47915(%rip), %rsi     # 0xec2a9
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regressionrule.c
// Function: empty_regression_condition
Regressionconditionptr empty_regression_condition()
{
	/*!Last Changed 27.03.2005*/
	/*!Last Changed 02.03.2005*/
	Regressionconditionptr result = safemalloc(sizeof(Regressioncondition), "empty_regression_condition", 1);
	result->leftcenter = NULL;
	result->rightcenter = NULL;
	result->featureindex = LEAF_NODE;
	result->next = NULL;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
leaq 0x478cb(%rip), %rsi     # 0xec2bf
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)