LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: copy_of_condition
Decisioncondition copy_of_condition(Decisioncondition condition)
{
	/* Last Changed 04.10.2004*/
	Decisioncondition result;
 result.conditiontype = condition.conditiontype;
	result.comparison = condition.comparison;
	result.featureindex = condition.featureindex;
 result.upperlimit = condition.upperlimit;
 result.lowerlimit = condition.lowerlimit;
	result.w0 = condition.w0;
	if (in_list(condition.featureindex, 2, LINEAR, QUADRATIC))
		 result.w = matrix_copy(condition.w);
	result.value = condition.value;
	result.datasize = condition.datasize;
	result.freeparam = condition.freeparam;
	if (condition.featureindex == DISCRETEMIX)
	  result.ksplit = copy_of_korderingsplit(condition.ksplit);
	result.next = NULL;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x40(%rax), %ecx
movl %ecx, 0x40(%rdi)
movb 0x4(%rax), %cl
movb %cl, 0x4(%rdi)
movl (%rax), %ecx
movl %ecx, (%rdi)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rdi)
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 0xad3e6
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rcx)
movl 0x38(%rax), %edx
movl %edx, 0x38(%rcx)
movl 0x3c(%rax), %edx
movl %edx, 0x3c(%rcx)
cmpl $-0x5, (%rax)
jne 0xad460
movq -0x38(%rbp), %rax
addq $0x50, %rax
leaq -0x30(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x47ec0
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq $0x0, 0x48(%rcx)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: create_copy_of_rule
Decisionruleptr create_copy_of_rule(Decisionruleptr rule)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
	/*!Last Changed 20.05.2003*/
 int i;
	Decisionruleptr result = safemalloc(sizeof(Decisionrule), "create_copy_of_rule", 1);
	Decisionconditionptr newcondition, tmp, last = NULL;
	result->classno = rule->classno;
	result->decisioncount = rule->decisioncount;
 result->covered = rule->covered;
 result->falsepositives = rule->falsepositives;
	result->next = NULL;
	result->start = NULL;
 result->counts = safecalloc(current_dataset->classno, sizeof(int), "create_copy_of_rule", 7);
 for (i = 0; i < current_dataset->classno; i++)
   result->counts[i] = rule->counts[i];
	tmp = rule->start;
	while (tmp)
	 {
		 newcondition = create_copy_of_condition(tmp);
			if (tmp == rule->start)
				 result->start = newcondition;
			else
				 last->next = newcondition;
			last = newcondition;
			tmp = tmp->next;
	 }
	result->end = last;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
leaq 0x3ed28(%rip), %rsi     # 0xec350
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
leaq 0x581ad(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x3ecaa(%rip), %rdx     # 0xec350
movl $0x7, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x58174(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xad6fd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xad6c2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xad75b
movq -0x28(%rbp), %rdi
callq 0xad480
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0xad739
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xad745
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xad709
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: extract_rule_from_leaf
Decisionruleptr extract_rule_from_leaf(Decisionnodeptr leaf)
{
 /*!Last Changed 18.03.2004 added covered and falsepositives*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 27.10.2003*/
 int i;
 Decisionruleptr newrule = empty_rule(leaf->classno);
 Decisionconditionptr newcondition;
 for (i = 0; i < leaf->conditioncount; i++)
  {
   newcondition = (Decisionconditionptr) safemalloc(sizeof(Decisioncondition), "add_rule_from_leave", 6);
   *newcondition = copy_of_condition(leaf->rule[i]);
   newcondition->next = NULL;
   add_condition(newrule, newcondition);
  }
 newrule->covered = leaf->covered;
 newrule->falsepositives = leaf->falsepositives;
 return newrule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edi
callq 0xad8b0
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x80(%rcx), %eax
jge 0xad87c
movl $0x70, %edi
leaq 0x3ed24(%rip), %rsi     # 0xec4e9
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movups 0x60(%rcx), %xmm0
movq %rsp, %rax
movups %xmm0, 0x60(%rax)
movups 0x50(%rcx), %xmm0
movups %xmm0, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 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)
leaq -0x90(%rbp), %rdi
callq 0xad350
movq -0x98(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x70, %edx
callq 0x42b0
movq -0x20(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xad950
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xad7a6
movq -0x8(%rbp), %rax
movl 0x84(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: empty_rule
Decisionruleptr empty_rule(int classno)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
	/*!Last Changed 13.05.2003*/
	Decisionruleptr newrule = safemalloc(sizeof(Decisionrule), "empty_rule", 1);
	newrule->decisioncount = 0;
	newrule->start = NULL;
	newrule->end = NULL;
	newrule->classno = classno;
	newrule->next = NULL;
 newrule->counts = safecalloc(current_dataset->classno, sizeof(int), "empty_rule", 8);
	return newrule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x38, %edi
leaq 0x3ec5b(%rip), %rsi     # 0xec522
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
leaq 0x57f2c(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x3ebfb(%rip), %rdx     # 0xec522
movl $0x8, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: add_condition
void add_condition(Decisionruleptr rule, Decisionconditionptr condition)
{
	/*!Last Changed 09.05.2003*/
	rule->decisioncount++;
	if (rule->decisioncount == 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 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0xad981
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xad991
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: create_copy_of_ruleset
Ruleset* create_copy_of_ruleset(Ruleset* r)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
	/*!Last Changed 20.05.2003*/
	Ruleset* result = safemalloc(sizeof(Ruleset), "create_copy_of_ruleset", 1);
	Decisionruleptr newrule, tmp, last = NULL;
	result->defaultclass = r->defaultclass;
	result->possibleconditioncount = r->possibleconditioncount;
	result->rulecount = r->rulecount;
	result->start = NULL;
 result->counts = safecalloc(current_dataset->classno, sizeof(int), "create_copy_of_ruleset", 7);
	tmp = r->start;
	while (tmp)
	 {
		 newrule = create_copy_of_rule(tmp);
			if (tmp == r->start)
				 result->start = newrule;
			else
			  last->next = newrule;
			last = newrule;
			tmp = tmp->next;
	 }
	result->end = last;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
leaq 0x3eb45(%rip), %rsi     # 0xec4fd
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
leaq 0x57e36(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x3eae0(%rip), %rdx     # 0xec4fd
movl $0x7, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xada8d
movq -0x20(%rbp), %rdi
callq 0xad610
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xada6b
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xada77
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xada3d
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: calculate_performance_for_prune
void calculate_performance_for_prune(Instanceptr pruneset, Decisionrule rule, int* p, int* n, int positive)
{
 /*!Last Changed 10.05.2003*/
 Instanceptr tmp;
 tmp = pruneset;
 *p = 0;
 *n = 0;
 while (tmp)
  {
   if (rule_cover_instance(tmp, rule))
    {
     if (give_classno(tmp) == positive)
       (*p)++;
     else
       (*n)++;
    }
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0xadb5b
movq -0x30(%rbp), %rcx
movq -0x28(%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)
callq 0xacfd0
cmpl $0x0, %eax
je 0xadb4d
movq -0x28(%rbp), %rdi
callq 0x43530
cmpl -0x1c(%rbp), %eax
jne 0xadb40
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xadb4b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xadb4d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xadaeb
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: check_rule_consistency
BOOLEAN check_rule_consistency(Decisionruleptr rule)
{
 int count = 0;
 Decisionconditionptr condition = rule->start;
 while (condition)
  {
   count++;
   condition = condition->next;
  }
 if (count == rule->decisioncount)
   return BOOLEAN_TRUE;
 else
   return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xadba9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xadb8b
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0xadbbe
movl $0x1, -0x4(%rbp)
jmp 0xadbc5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: check_ruleset_consistency
BOOLEAN check_ruleset_consistency(Ruleset set)
{
 int count = 0;
 Decisionruleptr rule = set.start;
 while (rule)
  {
   if (!check_rule_consistency(rule))
     return BOOLEAN_FALSE;
   count++;
   rule = rule->next;
  }
 if (count == set.rulecount)
   return BOOLEAN_TRUE;
 else
   return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xadc23
movq -0x10(%rbp), %rdi
callq 0xadb70
cmpl $0x0, %eax
jne 0xadc0c
movl $0x0, -0x4(%rbp)
jmp 0xadc3f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xadbee
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x10(%rcx), %eax
jne 0xadc38
movl $0x1, -0x4(%rbp)
jmp 0xadc3f
movl $0x0, -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: initialize_counts
void initialize_counts(Decisionruleptr start)
{
	/*!Last Changed 04.12.2003*/
	Decisionruleptr tmp = start;
	while (tmp)
	 {
		 tmp->falsepositives = 0;
			tmp->covered = 0;
		 tmp = tmp->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xadc8b
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xadc60
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: free_condition
void free_condition(Decisioncondition condition)
{
	/*!Last Changed 09.01.2004*/
	if (in_list(condition.featureindex, 2, LINEAR, QUADRATIC))
  	matrix_free(condition.w);
	if (condition.featureindex == DISCRETEMIX)
		 deallocate_korderingsplit(condition.ksplit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
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 0xadcce
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
cmpl $-0x5, (%rax)
jne 0xadd06
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x29fc0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: free_rule
void free_rule(Decisionrule rule)
{
	/*!Last Changed 10.05.2003*/
	Decisionconditionptr tmp, next;
	tmp = rule.start;
	while (tmp)
	 {
		 next = tmp->next;
			free_condition(*tmp);
			safe_free(tmp);
			tmp = next;
	 }
 safe_free(rule.counts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xadd93
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movups 0x60(%rcx), %xmm0
movq %rsp, %rax
movups %xmm0, 0x60(%rax)
movups 0x50(%rcx), %xmm0
movups %xmm0, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 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 0xadc90
movq -0x8(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xadd2b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: free_ruleset
void free_ruleset(Ruleset r)
{
	/*!Last Changed 21.05.2003*/
	Decisionruleptr tmp, next;
	tmp = r.start;
	while (tmp)
	 {
		 next = tmp->next;
			free_rule(*tmp);
			safe_free(tmp);
			tmp = next;
	 }
 safe_free(r.counts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xade17
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%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 0xadd10
movq -0x8(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaddc7
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e80
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: empty_ruleset
void empty_ruleset(Ruleset* r)
{
	/*!Last Changed 01.11.2003*/
	r->rulecount = 0;
	r->start = NULL;
	r->end = NULL;
 r->counts = safecalloc(current_dataset->classno, sizeof(int), "empty_ruleset", 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
leaq 0x579db(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x3e69c(%rip), %rdx     # 0xec514
movl $0x4, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: empty_condition
Decisionconditionptr empty_condition()
{
	/*!Last Changed 02.02.2004 added safemalloc*/
	/*!Last Changed 21.01.2004*/
	Decisionconditionptr result = safemalloc(sizeof(Decisioncondition), "empty_condition", 1);
	result->featureindex = -1;
	result->next = NULL;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x70, %edi
leaq 0x3e679(%rip), %rsi     # 0xec52d
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: merge_ruleset
void merge_ruleset(Ruleset* set1, Ruleset set2)
{
 if (set2.rulecount != 0)
  {
   if (set1->rulecount == 0)
     set1->start = set2.start;
   if (set1->rulecount != 0)
     set1->end->next = set2.start;
   set1->end = set2.end;
   set1->rulecount += set2.rulecount;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x10(%rax)
je 0xadf58
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xadf1e
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xadf3b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: ruleset_cover_instance
int ruleset_cover_instance(Instanceptr instance, Ruleset r)
{
	/*!Last Changed 03.11.2003*/
	Decisionruleptr tmp = r.start;
	while (tmp)
	 {
		 if (rule_cover_instance(instance, *tmp))
				 return YES;
		 tmp = tmp->next;
	 }
	return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xae298
movq -0x10(%rbp), %rdi
movq -0x18(%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 0xae28a
movl $0x1, -0x4(%rbp)
jmp 0xae29f
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xae247
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: rule_cover_instance2
int rule_cover_instance2(Instanceptr instance, Decisionrule rule)
{
	/*!Last Changed 19.09.2004*/
	Decisionconditionptr tmp = rule.start;
	while (tmp)
	 {
		 if (!condition_cover_instance2(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 0xae2f8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xadf60
cmpl $0x0, %eax
jne 0xae2ea
movl $0x0, -0x4(%rbp)
jmp 0xae2ff
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xae2c8
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: rule_cover_negative
int rule_cover_negative(Instanceptr instances, Decisionrule rule)
{
	/*!Last Changed 09.05.2003*/
	Instanceptr tmp;
	tmp = instances;
	while (tmp)
	 {
		 if (give_classno(tmp) != rule.classno)
		   if (rule_cover_instance(tmp, rule))
				   return YES;
		 tmp = tmp->next;
	 }
	return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xae390
movq -0x18(%rbp), %rdi
callq 0x43530
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0xae382
movq -0x20(%rbp), %rcx
movq -0x18(%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)
callq 0xacfd0
cmpl $0x0, %eax
je 0xae380
movl $0x1, -0x4(%rbp)
jmp 0xae397
jmp 0xae382
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xae32c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: false_positive_count
int false_positive_count(Ruleset r, Instanceptr instances)
{
	/*!Last Changed 03.11.2003*/
	int total = 0;
	Decisionruleptr tmprule;
	Instanceptr tmp;
	tmp = instances;
	while (tmp)
	 {
		 tmprule = r.start;
			while (tmprule)
			 {
				 if (rule_cover_instance(tmp, *tmprule))
					 {
		     if (give_classno(tmp) != tmprule->classno)
					  	 total++;
							break;
					 }
					tmprule = tmprule->next;
			 }
			tmp = tmp->next;
	 }
	return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xae4ae
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xae49d
movq -0x20(%rbp), %rdi
movq -0x18(%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 0xae48f
movq -0x20(%rbp), %rdi
callq 0x43530
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xae48d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xae49d
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xae439
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xae423
movl -0xc(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: return_error_and_free_condition
int return_error_and_free_condition(Decisionconditionptr condition, Instanceptr test, int positive)
{
	/*!Last Changed 03.12.2004*/
	int error;
	if (condition)
		 if (condition->featureindex != -1)
			 {
  			error = error_of_condition(condition, test, positive);
  			free_condition(*condition);
	  		safe_free(condition);
					return error;
			 }
			else
			 {
				 free_condition(*condition);
					safe_free(condition);
			  return 0;
			 }
	else
	  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xae5a4
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xae550
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xabf30
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movups 0x60(%rcx), %xmm0
movq %rsp, %rax
movups %xmm0, 0x60(%rax)
movups 0x50(%rcx), %xmm0
movups %xmm0, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 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 0xadc90
movq -0x10(%rbp), %rdi
callq 0x52e80
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xae5ab
movq -0x10(%rbp), %rcx
movups 0x60(%rcx), %xmm0
movq %rsp, %rax
movups %xmm0, 0x60(%rax)
movups 0x50(%rcx), %xmm0
movups %xmm0, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 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 0xadc90
movq -0x10(%rbp), %rdi
callq 0x52e80
movl $0x0, -0x4(%rbp)
jmp 0xae5ab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: add_condition_after
void add_condition_after(Decisionruleptr rule, Decisionconditionptr before, Decisionconditionptr inserted)
{
	/*!Last Changed 10.05.2003*/
	rule->decisioncount++;
	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 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xae602
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xae61e
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xae635
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: remove_condition
void remove_condition(Decisionruleptr rule, Decisionconditionptr deleted)
{
	/*!Last Changed 19.12.2003*/
 Decisionconditionptr before = NULL, tmp;
	tmp = rule->start;
	while (tmp)
	 { 
		 if (tmp == deleted)
				 break;
			before = tmp;
			tmp = tmp->next;
	 }
	if (tmp)
	  remove_condition_after(rule, before, deleted);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xae68d
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xae677
jmp 0xae68d
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xae664
cmpq $0x0, -0x20(%rbp)
je 0xae6a5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xae6b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: remove_condition_after
void remove_condition_after(Decisionruleptr rule, Decisionconditionptr before, Decisionconditionptr deleted)
{
	/*!Last Changed 10.05.2003*/
	rule->decisioncount--;
	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 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xae6e4
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xae6fd
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xae70d
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: test_rule
double test_rule(Decisionrule rule, Instanceptr instances)
{
	/*!Last Changed 10.05.2003*/
	int negative = 0, total = 0;
	Instanceptr tmp;
	tmp = instances;
	while (tmp)
	 {
			if (rule_cover_instance(tmp, rule))
			 {
			  total++;
		   if (give_classno(tmp) != rule.classno)
						 negative++;
			 }
			tmp = tmp->next;
	 }
	return negative/(total+0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xae7a7
movq -0x20(%rbp), %rcx
movq -0x18(%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)
callq 0xacfd0
cmpl $0x0, %eax
je 0xae799
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x43530
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0xae797
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xae799
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xae73a
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: add_rule_after
void add_rule_after(Ruleset* r, Decisionruleptr before, Decisionruleptr inserted)
{
	/*!Last Changed 18.05.2003*/
	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 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xae810
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xae82c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0xae843
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/rule.c
// Function: remove_rule_after
void remove_rule_after(Ruleset* r, Decisionruleptr before, Decisionruleptr deleted)
{
	/*!Last Changed 10.05.2003*/
	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 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xae890
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xae8d1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0xae8a7
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xae8bf
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xae8cf
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0xae8d1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: remove_rules_of_class
void remove_rules_of_class(Ruleset* set, int index)
{
 Decisionruleptr tmp, before = NULL, tmpnext;
 tmp = set->start;
 while (tmp)
  {
   tmpnext = tmp->next;
   if (tmp->classno == index)
    {
     if (before)
       before->next = tmp->next;
     else
       set->start = tmp->next;
     if (tmpnext == NULL)
       set->end = before;
     set->rulecount--;
     free_rule(*tmp);
     safe_free(tmp);
    }
   else
     before = tmp;
   tmp = tmpnext;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xae9b6
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xae9a1
cmpq $0x0, -0x20(%rbp)
je 0xae93d
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0xae94c
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
jne 0xae95f
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%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 0xadd10
movq -0x18(%rbp), %rdi
callq 0x52e80
jmp 0xae9a9
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xae902
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: remove_rule
void remove_rule(Ruleset* set, Decisionruleptr rule)
{
	/*!Last Changed 16.06.2003*/
 Decisionruleptr before = NULL, tmp;
	tmp = set->start;
	while (tmp)
	 { 
		 if (tmp == rule)
				 break;
			before = tmp;
			tmp = tmp->next;
	 }
	if (tmp)
	  remove_rule_after(set, before, rule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaea0c
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xae9f6
jmp 0xaea0c
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xae9e3
cmpq $0x0, -0x20(%rbp)
je 0xaea24
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xae850
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: add_rule
void add_rule(Ruleset* set, Decisionruleptr rule)
{
	/*!Last Changed 04.11.2003 Added rule->next = NULL*/
	/*!Last Changed 13.05.2003*/
	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, 0x10(%rax)
jne 0xaea53
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xaea63
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: update_counts
void update_counts(Decisionruleptr rule, Instanceptr list1, int initialize)
{
	/*!Last Changed 02.11.2003*/
 int classno;
	Instanceptr tmp;
	if (initialize)
	 {
		 rule->covered = 0;
			rule->falsepositives = 0;
	 }
	tmp = list1;
	while (tmp)
	 {
		 if (rule_cover_instance(tmp, *rule))
    {
     classno = give_classno(tmp);
				 if (classno != rule->classno)
						 rule->falsepositives++;
					else
						 rule->covered++;
    }
		 tmp = tmp->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xaeabf
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaeb44
movq -0x20(%rbp), %rdi
movq -0x8(%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 0xaeb36
movq -0x20(%rbp), %rdi
callq 0x43530
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0xaeb27
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xaeb34
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0xaeb36
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xaeac7
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: print_counts
void print_counts(char* st,Instanceptr list)
{
	int* counts, i;
	counts = find_class_counts(list);
	printf("----------\n");
	printf("%s\n",st);
	printf("----------\n");
 for (i = 0; i < current_dataset->classno; i++)
		 printf(m1309, i, counts[i]);
	printf("----------\n");
	safe_free(counts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x183a0
movq %rax, -0x18(%rbp)
leaq 0x341e7(%rip), %rdi     # 0xe2f1b
movb $0x0, %al
callq 0x4030
movq -0x8(%rbp), %rsi
leaq 0x3df88(%rip), %rdi     # 0xeccce
movb $0x0, %al
callq 0x4030
leaq 0x341c7(%rip), %rdi     # 0xe2f1b
movb $0x0, %al
callq 0x4030
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x56ad4(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xaed9b
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x3d7b4(%rip), %rdi     # 0xec53d
movb $0x0, %al
callq 0x4030
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xaed62
leaq 0x34179(%rip), %rdi     # 0xe2f1b
movb $0x0, %al
callq 0x4030
movq -0x18(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rule.c
// Function: get_next_class_rule
Decisionruleptr get_next_class_rule(Decisionruleptr previousclassrule)
{
	/*!Last Changed 05.05.2004*/
	int previousclass;
	Decisionruleptr tmp = previousclassrule;
	previousclass = tmp->classno;
	tmp = tmp->next;
	while (tmp && tmp->classno == previousclass)
			tmp = tmp->next;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xaeef0
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xaeef9
jmp 0xaef07
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xaeed5
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_start_block
void code_start_block(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 14.06.2006*/
 indentation++;
 if (in_list(language, 4, C_LANGUAGE, CPP_LANGUAGE, JAVA_LANGUAGE, PASCAL_LANGUAGE))
   code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "{\n");
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "begin\n");
                         break;
   case MATLAB_LANGUAGE :
   case FORTRAN_LANGUAGE:break;
 };
 indentation++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x333243(%rip), %eax    # 0x3e21b8
addl $0x1, %eax
movl %eax, 0x33323a(%rip)    # 0x3e21b8
movl -0xc(%rbp), %edi
movl $0x4, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x3, %r8d
movl $0x2, %r9d
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xaefae
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
jb 0xaefdc
jmp 0xaefbb
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xaeff0
jmp 0xaefc5
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0xaefdc
jmp 0xaefcf
movl -0x10(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xaf004
jmp 0xaf006
movq -0x8(%rbp), %rdi
leaq 0x3e92f(%rip), %rsi     # 0xed916
movb $0x0, %al
callq 0x4280
jmp 0xaf006
movq -0x8(%rbp), %rdi
leaq 0x3d785(%rip), %rsi     # 0xec780
movb $0x0, %al
callq 0x4280
jmp 0xaf006
jmp 0xaf006
movl 0x3331ac(%rip), %eax    # 0x3e21b8
addl $0x1, %eax
movl %eax, 0x3331a3(%rip)    # 0x3e21b8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: test_code_file_name_with_extension
char* test_code_file_name_with_extension(char* testcodefilename, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 02.06.2006*/
 char* fname = safemalloc((strlen(testcodefilename) + 6) * sizeof(char), "test_code_file_name_with_extension", 1);
 switch (language)
  {
   case C_LANGUAGE      :sprintf(fname, "%s.c", testcodefilename);
                         break;
   case CPP_LANGUAGE    :sprintf(fname, "%s.cpp", testcodefilename);
                         break;
   case PASCAL_LANGUAGE :sprintf(fname, "%s.pas", testcodefilename);
                         break;
   case JAVA_LANGUAGE   :sprintf(fname, "%s.java", testcodefilename);
                         break;
   case MATLAB_LANGUAGE :sprintf(fname, "%s.m", testcodefilename);
                         break;
   case FORTRAN_LANGUAGE:sprintf(fname, "%s.f", testcodefilename);
                         break;
  } 
 return fname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movq %rax, %rdi
addq $0x6, %rdi
leaq 0x3d681(%rip), %rsi     # 0xec787
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xaf1c7
movq -0x20(%rbp), %rax
leaq 0x3d41c(%rip), %rcx     # 0xec54c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d662(%rip), %rsi     # 0xec7aa
movb $0x0, %al
callq 0x4170
jmp 0xaf1c7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d64f(%rip), %rsi     # 0xec7af
movb $0x0, %al
callq 0x4170
jmp 0xaf1c7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d63e(%rip), %rsi     # 0xec7b6
movb $0x0, %al
callq 0x4170
jmp 0xaf1c7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d62d(%rip), %rsi     # 0xec7bd
movb $0x0, %al
callq 0x4170
jmp 0xaf1c7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d61d(%rip), %rsi     # 0xec7c5
movb $0x0, %al
callq 0x4170
jmp 0xaf1c7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d60a(%rip), %rsi     # 0xec7ca
movb $0x0, %al
callq 0x4170
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)