LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariaterule.c
// Function: growrule_multivariate
Decisionruleptr growrule_multivariate(Instanceptr* growset, int positive, Ripper_parameterptr param)
{
 /*!Last Changed 21.01.2004*/
 /*!Last Changed 29.12.2003*/
 /*!Last Changed 02.12.2003*/
 /*!Last Changed 10.05.2003*/
 Decisionruleptr result;
 Decisionconditionptr newcondition = NULL;
 Instanceptr obey, notobey = NULL;
 int n, pnew, nnew;
 result = empty_rule(positive);
 obey = (*growset);
 if (rule_cover_negative(obey, *result))
   n = 1;
 else
   n = 0;
 while (n > 0)
  {
   newcondition = find_best_multivariate_condition(&obey, positive, MULTIVARIATE_LINEAR, param);
   if (newcondition && newcondition->featureindex != -1)
    {
     count_examples_for_condition(newcondition, &pnew, &nnew, positive, obey);
     if (result->decisioncount == 0 || nnew != n)
       n = nnew;
     else
      {
       free_condition(*newcondition);
       safe_free(newcondition);
       break;
      }
     send_exceptions(newcondition, &obey, &notobey);
     add_condition(result, newcondition);
    }
   else
    {
     if (newcondition && newcondition->featureindex == -1)
      {
       free_condition(*newcondition);
       safe_free(newcondition);
      }
     break;
    }
  }
 if (notobey)
  {
   merge_instancelist(&notobey, obey);
   (*growset) = notobey;
  }
 else
   (*growset) = obey;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x78(%rsp), %rax
andq $0x0, (%rax)
movl %esi, %edi
callq 0x719a4
movq %rax, %r15
movq %rbx, 0x90(%rsp)
movq (%rbx), %rdi
leaq 0x88(%rsp), %r12
movq %rdi, (%r12)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x71f54
xorl %r13d, %r13d
testl %eax, %eax
setne %r13b
testl %r13d, %r13d
jle 0x45338
movq %r12, %rdi
movl %ebp, %esi
pushq $-0x2
popq %rdx
movq 0x98(%rsp), %rcx
callq 0x45899
testq %rax, %rax
je 0x45338
movq %rax, %r14
cmpl $-0x1, (%rax)
je 0x4531f
movq 0x88(%rsp), %r8
movq %r14, %rdi
leaq 0xa4(%rsp), %rsi
leaq 0x84(%rsp), %rdx
movl %ebp, %ecx
callq 0x70ba5
cmpl $0x0, 0x28(%r15)
movl 0x84(%rsp), %ebx
je 0x452ff
cmpl %r13d, %ebx
je 0x4531f
movq %r14, %rdi
movq %r12, %rsi
leaq 0x78(%rsp), %rdx
callq 0x8ffc1
movq %r15, %rdi
movq %r14, %rsi
callq 0x719fe
movl %ebx, %r13d
jmp 0x4529f
pushq $0xe
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x71b91
movq %r14, %rdi
callq 0x34ff7
cmpq $0x0, 0x78(%rsp)
je 0x45355
movq 0x88(%rsp), %rsi
leaq 0x78(%rsp), %r12
movq %r12, %rdi
callq 0x2c6e4
movq (%r12), %rax
movq 0x90(%rsp), %rcx
movq %rax, (%rcx)
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariaterule.c
// Function: grow_revision_rule_multivariate
Decisionruleptr grow_revision_rule_multivariate(Instanceptr* growset, Decisionruleptr rule, int positive, Ripper_parameterptr param)
{
 /* Last Changed 21.01.2004*/
 /* Last Changed 14.01.2004*/
 /* Last Changed 20.05.2003*/
 Decisionruleptr newrule = create_copy_of_rule(rule);
 Decisionconditionptr newcondition;
 Instanceptr obey, notobey = NULL;
 int n, pnew, nnew;
 obey = (*growset);
 if (rule_cover_negative(obey, *newrule))
   n = 1;
 else
   n = 0;
 while (n > 0)
  {
   newcondition = find_best_multivariate_condition(&obey, positive, MULTIVARIATE_LINEAR, param);
   if (newcondition && newcondition->featureindex != -1)
    {
     count_examples_for_condition(newcondition, &pnew, &nnew, positive, obey);
     if (notobey == NULL || nnew != n)
       n = nnew;
     else
      {
       free_condition(*newcondition);
       safe_free(newcondition);       
       break;
      }
     send_exceptions(newcondition, &obey, &notobey);
     add_condition(newrule, newcondition);
    }
   else
    {
     if (newcondition && newcondition->featureindex == -1)
      {
       free_condition(*newcondition);
       safe_free(newcondition);
      }
     break;
    }
  }
 if (notobey)
  {
   merge_instancelist(&notobey, obey);
   (*growset) = notobey;
  }
 return newrule;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x98(%rsp)
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x717f9
leaq 0x78(%rsp), %rcx
andq $0x0, (%rcx)
movq %rax, %r14
movq %rbx, 0x90(%rsp)
movq (%rbx), %rdi
leaq 0x88(%rsp), %r13
movq %rdi, (%r13)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x71f54
xorl %r15d, %r15d
testl %eax, %eax
setne %r15b
testl %r15d, %r15d
jle 0x45492
movq %r13, %rdi
movl %ebp, %esi
pushq $-0x2
popq %rdx
movq 0x98(%rsp), %rcx
callq 0x45899
testq %rax, %rax
je 0x45492
movq %rax, %r12
cmpl $-0x1, (%rax)
je 0x45479
movq 0x88(%rsp), %r8
movq %r12, %rdi
leaq 0xa4(%rsp), %rsi
leaq 0x84(%rsp), %rdx
movl %ebp, %ecx
callq 0x70ba5
cmpq $0x0, 0x78(%rsp)
movl 0x84(%rsp), %ebx
je 0x45456
cmpl %r15d, %ebx
je 0x45479
movq %r12, %rdi
movq %r13, %rsi
leaq 0x78(%rsp), %rdx
callq 0x8ffc1
movq %r14, %rdi
movq %r12, %rsi
callq 0x719fe
movl %ebx, %r15d
jmp 0x453f5
pushq $0xe
popq %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x71b91
movq %r12, %rdi
callq 0x34ff7
cmpq $0x0, 0x78(%rsp)
je 0x454bd
movq 0x88(%rsp), %rsi
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0x2c6e4
movq (%rbx), %rax
movq 0x90(%rsp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariaterule.c
// Function: simplify_ruleset_multivariate
void simplify_ruleset_multivariate(Ruleset* r, int positive, Instanceptr cvdata)
{
 /*!Last Changed 14.01.2004*/
 Decisionruleptr firstrule, deleted, tmprule, deletedbefore;
 int minerror = error_of_ruleset(*r, cvdata), error;
 firstrule = r->start;
 while (firstrule && firstrule->classno != positive)
   firstrule = firstrule->next;
 if (!firstrule)
   return;
 deleted = r->end;
 while (deleted && deleted->next != firstrule)
  {
   tmprule = r->start;
   if (tmprule != deleted)
    {
     while (tmprule->next != deleted)
       tmprule = tmprule->next;
     deletedbefore = tmprule;
    }
   else
     deletedbefore = NULL;
   remove_rule_after(r, deletedbefore, deleted);
   error = error_of_ruleset(*r, cvdata);
   if (error > minerror)
     add_rule_after(r, deletedbefore, deleted);
   else
    {
     free_rule(*deleted);
     safe_free(deleted);
     minerror = error;
    }
   deleted = deletedbefore;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %r15d
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rsp)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rdx, 0x40(%rsp)
movq %rdx, %rdi
callq 0x71374
movl %eax, %ebp
movq %rbx, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x455dd
cmpl %r15d, (%r14)
je 0x45528
addq $0x30, %r14
jmp 0x45511
movq 0x8(%rbx), %r12
movq %r12, %r15
testq %r12, %r12
je 0x455dd
cmpq %r14, 0x30(%r15)
je 0x455dd
movq (%rbx), %rax
cmpq %r15, %rax
je 0x45558
movq %rax, %r12
movq 0x30(%rax), %rax
cmpq %r15, %rax
jne 0x4554a
jmp 0x4555b
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x721ae
movq 0x20(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x71374
cmpl %ebp, %eax
jle 0x455a0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7217f
jmp 0x4552c
movl %eax, %r13d
movq 0x30(%r15), %rax
movq %rax, 0x30(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x71be8
movq %r15, %rdi
callq 0x34ff7
movl %r13d, %ebp
jmp 0x4552c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariaterule.c
// Function: count_multivariate_condition_over_threshold
int count_multivariate_condition_over_threshold(Instanceptr list, Decisionconditionptr condition)
{
 /*!Last Changed 09.01.2004*/
 int result = 0;
 Instanceptr tmp = list;
 while (tmp)
  {
   if (multiply_with_matrix(tmp, condition->w) > condition->w0)
     result++;
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0x4561f
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x2b0c0
xorl %eax, %eax
ucomisd 0x30(%rbx), %xmm0
seta %al
addl %eax, %ebp
movq 0x10(%r14), %r14
jmp 0x455f8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariaterule.c
// Function: find_best_multivariate_condition_svm
Decisionconditionptr find_best_multivariate_condition_svm(Instanceptr* growset, int positive)
{
 /*!Last Changed 18.02.2008*/
 Decisionconditionptr result;
 int i;
 Partition p;
 Svm_split split;
 result = empty_condition();
 result->conditiontype = MULTIVARIATE_CONDITION;
 result->featureindex = LINEAR;
 result->freeparam = current_dataset->multifeaturecount - 1;
 result->comparison = '>';
 result->w = matrix_alloc(1, current_dataset->multifeaturecount - 1);
 p = get_two_class_partition_for_one_vs_all(current_dataset, positive);
	split = find_best_svm_split_for_partition(*growset, p);
	result->w0 = split.rho;
	for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
 		result->w.values[0][i] = split.weights[i];
	free_svm_split(split);
 free_partition(p);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x71cd1
movq %rax, %rbx
movl $0x1, 0x40(%rax)
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
leaq 0x88213(%rip), %r13     # 0xcd870
movq (%r13), %rax
movl 0x1c0(%rax), %esi
decl %esi
movl %esi, 0x3c(%rbx)
movb $0x3e, 0x4(%rbx)
pushq $0x1
popq %rdi
callq 0x380d3
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movq (%r13), %rsi
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movl %ebp, %edx
callq 0x4db20
movq (%r14), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0x88e4e
movsd 0x70(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
movq (%r13), %rax
movslq 0x1c0(%rax), %rax
decq %rax
movq 0x78(%r14), %rcx
cmpq %rax, %r12
jge 0x456f4
movsd (%rcx,%r12,8), %xmm0
movq 0x28(%rbx), %rdx
movq (%rdx), %rdx
movsd %xmm0, (%rdx,%r12,8)
incq %r12
jmp 0x456d7
pushq $0x11
popq %rcx
leaq 0xa0(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x828bc
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x88(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x4dd42
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariaterule.c
// Function: find_best_multivariate_condition_lp
Decisionconditionptr find_best_multivariate_condition_lp(Instanceptr* growset, int positive)
{
 /*!Last Changed 17.11.2005 added result->freeparam*/
 /*!Last Changed 26.06.2005*/
 /*!Last Changed 28.05.2004*/
 Mlpparameters mlpparams;
 Mlpnetwork neuralnetwork;
 matrix train;
 Decisionconditionptr result;
 int i;
 result = empty_condition();
 result->conditiontype = MULTIVARIATE_CONDITION;
 result->featureindex = LINEAR;
 result->freeparam = current_dataset->multifeaturecount - 1;
 mlpparams = prepare_Mlpparameters(*growset, *growset, 0, 0.0, 0, NULL, 0, 0.0, 0.0, 0, CLASSIFICATION);
 train = instancelist_to_matrix(*growset, 2, positive, MULTIVARIATE_LINEAR);
 neuralnetwork = mlpn_general(train, train, &mlpparams, CLASSIFICATION);
 result->comparison = '>';
 result->w0 = neuralnetwork.weights->values[1][0] - neuralnetwork.weights->values[0][0];
 result->w = matrix_alloc(1, current_dataset->multifeaturecount - 1);
 for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
   result->w.values[0][i] = neuralnetwork.weights->values[0][i + 1] - neuralnetwork.weights->values[1][i + 1];
 free_mlpnnetwork(&neuralnetwork);
 matrix_free(train);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x71cd1
movq %rax, %rbx
movl $0x1, 0x40(%rax)
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
leaq 0x880fc(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x1c0(%rax), %eax
decl %eax
movl %eax, 0x3c(%rbx)
movq (%r14), %rdx
subq $0x8, %rsp
leaq 0x8(%rsp), %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rdx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x0
pushq $0x0
callq 0x3df0e
addq $0x20, %rsp
movq (%r14), %rdi
pushq $0x2
popq %rsi
pushq $-0x2
popq %rcx
movl %ebp, %edx
callq 0x2c130
movq %rax, %r14
movq %rdx, %r15
subq $0x8, %rsp
leaq 0x98(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
movq %rax, %rcx
movq %rdx, %r8
leaq 0x8(%rsp), %r9
pushq $0x0
callq 0x3d96a
addq $0x10, %rsp
movb $0x3e, 0x4(%rbx)
movq (%r13), %r13
movq 0x8(%r13), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
subsd (%rcx), %xmm0
movsd %xmm0, 0x30(%rbx)
leaq 0x8805a(%rip), %rbp     # 0xcd870
movq (%rbp), %rax
movl 0x1c0(%rax), %esi
decl %esi
pushq $0x1
popq %rdi
callq 0x380d3
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movq (%rbp), %rax
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %r12
jge 0x4586c
movq 0x8(%r13), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
movsd 0x8(%rsi,%r12,8), %xmm0
subsd 0x8(%rcx,%r12,8), %xmm0
movq (%rdx), %rcx
movsd %xmm0, (%rcx,%r12,8)
incq %r12
jmp 0x45840
leaq 0x90(%rsp), %rdi
callq 0x3eeb2
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariaterule.c
// Function: multivariate_rule_learner
Ruleset multivariate_rule_learner(Instanceptr* instances, Instanceptr cvdata, Ripper_parameterptr param)
{
 /*!Last Changed 09.01.2004*/
 Ruleset result;
 int classno, *counts, *classes, posclass, classcount, i, maxcount;
 Instanceptr removed, totalremoved = NULL;
 empty_ruleset(&result);
 classno = all_in_one_class(*instances, &maxcount);
 if (!(classno % 10))
   return result;
 counts = find_class_counts(*instances);
 classes = find_max_occured(counts, current_dataset->classno, &classcount);
 safe_free(counts);
 result.defaultclass = classes[0];
 for (i = classcount - 1; i > 0; i--)
  {
   posclass = classes[i];
   removed = learn_multivariate_rules_for_positive_class(instances, &result, posclass, cvdata, param);
   merge_instancelist(&totalremoved, removed);
  }
 safe_free(classes);
 merge_instancelist(instances, totalremoved);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
callq 0x71c9d
movq (%r14), %rdi
leaq 0x14(%rsp), %rsi
callq 0x10916
pushq $0xa
popq %rcx
cltd
idivl %ecx
testl %edx, %edx
je 0x45d42
movq (%r14), %rdi
callq 0x108c8
movq %rax, %rbp
leaq 0x87b9c(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %esi
leaq 0x4(%rsp), %rdx
movq %rbp, %rdi
callq 0x3372d
movq %rax, %r13
movq %rbp, %rdi
callq 0x34ff7
movl (%r13), %eax
movl %eax, 0x14(%rbx)
leaq 0x4(%rsp), %rax
movl (%rax), %ebp
cmpl $0x2, %ebp
jl 0x45d2d
movl -0x4(%r13,%rbp,4), %edx
decq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
movq %r15, %r8
callq 0x45a9a
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2c6e4
jmp 0x45d00
movq %r13, %rdi
callq 0x34ff7
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2c6e4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: decisiontree_multivariate_linear_node_count
int decisiontree_multivariate_linear_node_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 if (node->featureno == LEAF_NODE)
   return 0;
 else
   if (node->featureno == LINEAR)
     return 1 + decisiontree_multivariate_linear_node_count(node->left) + decisiontree_multivariate_linear_node_count(node->right);
   else
     return decisiontree_multivariate_linear_node_count(node->left) + decisiontree_multivariate_linear_node_count(node->right);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %r14d, %r14d
movl 0x30(%rbx), %eax
cmpl $-0x2, %eax
jne 0x45d7c
movq (%rbx), %rdi
callq 0x45d54
movq 0x8(%rbx), %rbx
addl %eax, %r14d
incl %r14d
jmp 0x45d60
cmpl $-0x1, %eax
je 0x45d98
movq (%rbx), %rdi
callq 0x45d54
movq 0x8(%rbx), %rbx
addl %ebp, %r14d
addl %eax, %r14d
movl %r14d, %ebp
jmp 0x45d5d
addl %ebp, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: decisiontree_multivariate_quadratic_node_count
int decisiontree_multivariate_quadratic_node_count(Decisionnodeptr node)
{
 /*!Last Changed 29.01.2005*/
 if (node->featureno == LEAF_NODE)
   return 0;
 else
   if (node->featureno == QUADRATIC)
     return 1 + decisiontree_multivariate_quadratic_node_count(node->left) + decisiontree_multivariate_quadratic_node_count(node->right);
   else
     return decisiontree_multivariate_quadratic_node_count(node->left) + decisiontree_multivariate_quadratic_node_count(node->right);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %r14d, %r14d
movl 0x30(%rbx), %eax
cmpl $-0x3, %eax
jne 0x45dcb
movq (%rbx), %rdi
callq 0x45da3
movq 0x8(%rbx), %rbx
addl %eax, %r14d
incl %r14d
jmp 0x45daf
cmpl $-0x1, %eax
je 0x45de7
movq (%rbx), %rdi
callq 0x45da3
movq 0x8(%rbx), %rbx
addl %ebp, %r14d
addl %eax, %r14d
movl %r14d, %ebp
jmp 0x45dac
addl %ebp, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: test_multivariate
int test_multivariate(Instanceptr testingdata, matrix w, double w0, int leftclass, int rightclass)
{
 /*!Last Changed 23.09.2004*/
 int i, error = 0;
 double value;
 Instanceptr test = testingdata;
 while (test)
  {
   value = multiply_with_matrix(test, w);
   i = give_classno(test);
   if (value <= w0)
    {
     if (i != leftclass)
       error++;
    }
   else
    {
     if (i != rightclass)
       error++;
    }
   test = test->next;
  }
 return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %r12d, %r12d
testq %r13, %r13
je 0x45ea1
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2b0c0
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
callq 0x2b47e
movsd 0x8(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
movl %ebp, %ecx
cmovbl %ebx, %ecx
xorl %edx, %edx
cmpl %ecx, %eax
setne %dl
addl %edx, %r12d
movq 0x10(%r13), %r13
jmp 0x45e5f
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: find_counts_for_multivariate_split
void find_counts_for_multivariate_split(Instanceptr instances, matrix w, double w0, int* leftcounts, int* rightcounts)
{
 /*!Last Changed 22.09.2004*/
 int j;
 double value;
 Instanceptr tmp = instances;
 for (j = 0; j < MAXCLASSES; j++)
  {
   leftcounts[j] = 0;
   rightcounts[j] = 0;
  }
 while (tmp)
  {
   value = multiply_with_matrix(tmp, w);
   j = give_classno(tmp);
   if (value <= w0)
     leftcounts[j]++;
   else
     rightcounts[j]++;
   tmp = tmp->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %eax, %eax
cmpq $0x32, %rax
je 0x46c26
andl $0x0, (%r14,%rax,4)
andl $0x0, (%rbx,%rax,4)
incq %rax
jmp 0x46bdb
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2b0c0
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
callq 0x2b47e
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
cltq
movq %r14, %rcx
cmovbq %rbx, %rcx
incl (%rcx,%rax,4)
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x46bef
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: find_split_for_partition_multivariate
int find_split_for_partition_multivariate(Instanceptr* instances, Partition p, matrix* w, double*  w0, MULTIVARIATE_TYPE multivariate_type, int* newdim, double variance_explained)
{
 /*!Last Changed 21.09.2004*/
 int result;
 Instanceptr positives = NULL, negatives = NULL;
 divide_instancelist_according_partition(instances, &positives, &negatives, p);
 result = best_multivariate_split_lda_with_pca(positives, negatives, w, w0, multivariate_type, newdim, variance_explained);
 *instances = positives;
 merge_instancelist(instances, negatives);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
andq $0x0, (%r13)
leaq 0x28(%rsp), %r14
andq $0x0, (%r14)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rsi
movq %r14, %rdx
callq 0x2c8d9
movq (%r13), %rdi
movq (%r14), %rsi
movq %r12, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movq 0x18(%rsp), %r9
movsd 0x20(%rsp), %xmm0
callq 0x460cb
movl %eax, %ebp
movq (%r13), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2c6e4
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: find_gain_for_partition_multivariate
double find_gain_for_partition_multivariate(Instanceptr* instances, Partition p, matrix* w, double* w0, MULTIVARIATE_TYPE multivariate_type, int* newdim, double variance_explained)
{
 /*!Last Changed 21.09.2004*/
 if (p.count == 0 || instances == NULL || all_same_side(p))
  {
   *w = identity(1);
   return ISELL;
  }
 if (!find_split_for_partition_multivariate(instances, p, w, w0, multivariate_type, newdim, variance_explained))
   return ISELL;
 return information_gain_for_multivariate_split(*instances, *w, *w0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x46d56
cmpl $0x0, 0x70(%rsp)
je 0x46d56
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
leaq 0x60(%rsp), %r13
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm1
movups %xmm1, (%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x4dbfb
movsd 0x20(%rsp), %xmm0
testl %eax, %eax
je 0x46d7c
pushq $0x1
popq %rdi
callq 0x3930e
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movsd 0x4ef8b(%rip), %xmm0    # 0x95cf8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm1
movups %xmm1, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r12, %r8
callq 0x46c65
testl %eax, %eax
je 0x46d65
movq (%r15), %rdi
movsd (%r14), %xmm0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x46c39
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: log_likelihood_for_multi_ldt_splits
double log_likelihood_for_multi_ldt_splits(Instanceptr data, matrix w, double w0)
{
 int counts[2][MAXCLASSES];
 double result = 0;
 find_counts_for_multivariate_split(data, w, w0, counts[0], counts[1]);
 result += log_likelihood_for_classification(counts[0]);
 result += log_likelihood_for_classification(counts[1]);
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
leaq 0xd8(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rcx
movq %rbx, %r8
callq 0x46bb8
movq %r14, %rdi
callq 0x1b961
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1b961
addsd 0x8(%rsp), %xmm0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/multivariatetree.c
// Function: create_multildtchildren
int create_multildtchildren(Decisionnodeptr node, Multildt_parameterptr param)
{
 /*!Last Changed 21.09.2004*/
 node->conditiontype = MULTIVARIATE_CONDITION;
 if (!(can_be_divided(node, &(param->c45param))))
   return 1;
 node->lineard = find_best_multi_ldt_split(&(node->instances),&(node->w),&(node->w0), MULTIVARIATE_LINEAR, param->variance_explained);
 if (!(node->lineard))
  {
   matrix_free(node->w);
   make_leaf_node(node);
   return 1;
  }
 node->featureno = LINEAR; 
 if (!(make_multivariate_children(node)))
   return 1;
 create_multildtchildren(node->left, param);
 create_multildtchildren(node->right, param);
 return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $-0x2
popq %rbp
movl $0x1, 0x98(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1abee
testl %eax, %eax
je 0x4721c
leaq 0x20(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x48(%rbx), %rdx
movsd 0x20(%r14), %xmm0
movl %ebp, %ecx
callq 0x46e18
movl %eax, 0x90(%rbx)
testl %eax, %eax
je 0x47207
movl $0xfffffffe, 0x30(%rbx) # imm = 0xFFFFFFFE
movq %rbx, %rdi
callq 0x4692e
testl %eax, %eax
je 0x4721c
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4719a
movq 0x8(%rbx), %rbx
jmp 0x471a7
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x3929f
movq %rbx, %rdi
callq 0x1a6ac
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: table_list
int* table_list(struct node mynode, int pos)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 int i, *result;
	result = (int *) safemalloc(mynode.parents * sizeof(int), "table_list", 2);
 for (i = mynode.parents - 1; i > -1; i--)
  {
   result[i] = pos % (mynode.parent_counts[i]);
   pos = pos / (mynode.parent_counts[i]);
  }
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x40(%rsp), %r14d
movslq %r14d, %rdi
shlq $0x2, %rdi
leaq 0x533c4(%rip), %rsi     # 0x9a65c
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %rcx
movq 0x38(%rsp), %rsi
testl %r14d, %r14d
jle 0x472c9
movl %ebx, %eax
cltd
idivl -0x4(%rsi,%r14,4)
movl %edx, -0x4(%rcx,%r14,4)
movl %ebx, %eax
cltd
idivl -0x4(%rsi,%r14,4)
decq %r14
movl %eax, %ebx
jmp 0x472a8
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: table_pos
int table_pos(struct node mynode, int *list)
{
 int i, table_index = 0;
 for (i = 0; i < mynode.parents; i++)
   if (i != 0)
     table_index = list[i] + table_index * mynode.parent_counts[i];
   else
     table_index = list[0];
 return table_index;
}

// Assembly:
movl 0x28(%rsp), %ecx
movq 0x20(%rsp), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
xorl %eax, %eax
cmpq %rsi, %rcx
je 0x47300
testq %rsi, %rsi
je 0x472f9
imull (%rdx,%rsi,4), %eax
addl (%rdi,%rsi,4), %eax
jmp 0x472fb
movl (%rdi), %eax
incq %rsi
jmp 0x472e6
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: find_parents
int* find_parents(bayesiangraphptr mygraph, int node)
{
 /*!Last changed 15.01.2001*/
 int i = 0, where, *result = NULL;
 where = mygraph->nodes[node].pointer;
 while (where != -1)
  {
   i++;
   result = alloc(result, i * sizeof(int), i);
   result[i - 1] = mygraph->dest[where];
   where = mygraph->arcs[where].pointer;
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq %esi, %rcx
imulq $0x48, %rcx, %rcx
leaq (%rax,%rcx), %r15
addq $0x30, %r15
pushq $0x4
popq %r14
pushq $0x1
popq %rbp
xorl %eax, %eax
movslq (%r15), %r15
cmpq $-0x1, %r15
je 0x4735a
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x34f30
movq 0x28(%rbx), %rcx
movl (%rcx,%r15,4), %ecx
shlq $0x2, %r15
movl %ecx, -0x4(%rax,%r14)
addq 0x18(%rbx), %r15
addq $0x4, %r14
incl %ebp
jmp 0x47327
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: parent_index
int parent_index(bayesiangraphptr mygraph, int node, int pindex)
{
 int i = 0, where;
 where = mygraph->nodes[node].pointer;
 while (i < pindex)
  {
   i++;
   where = mygraph->arcs[where].pointer;
  }
 return mygraph->dest[where];
}

// Assembly:
movq 0x8(%rdi), %rax
movslq %esi, %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
addq $0x30, %rax
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
movslq (%rax), %rax
subl $0x1, %ecx
jb 0x47390
shlq $0x2, %rax
addq 0x18(%rdi), %rax
jmp 0x4737e
movq 0x28(%rdi), %rcx
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: add_one_node
nodeptr add_one_node(bayesiangraphptr mygraph, char *st)
{
/*!Last Changed 15.01.2001*/
 nodeptr current;
 mygraph->nodecount++;
 mygraph->nodes = alloc(mygraph->nodes, mygraph->nodecount * sizeof(struct node), mygraph->nodecount);
 current = &(mygraph->nodes[mygraph->nodecount - 1]);
 current->value_count = 0;
 current->parents = 0;
 current->table_count = 1;
 current->pointer = -1;
 current->name = strcopy(current->name, st);
 return current;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x10(%rdi), %rdx
incq %rdx
movl %edx, 0x10(%rdi)
movq 0x8(%rdi), %rdi
imulq $0x48, %rdx, %rsi
callq 0x34f30
movq %rax, 0x8(%r14)
movslq 0x10(%r14), %rcx
imulq $0x48, %rcx, %rcx
leaq (%rax,%rcx), %r14
addq $-0x48, %r14
andl $0x0, 0x10(%r14)
andl $0x0, 0x20(%r14)
movq $0x1, 0x28(%r14)
orl $-0x1, 0x30(%r14)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3604c
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: find_arc_with_no
int find_arc_with_no(bayesiangraphptr mygraph, int arc_no, int *from, int *to, int *from_order, int *before)
{
/*!Last Changed 25.02.2001*/
 int i, pos1;
 for (i = 0; i < mygraph->nodecount; i++)
  {
   pos1 = mygraph->nodes[i].pointer;
   if (pos1 == -1)
     continue;
   *from_order = 0;
   *before = -1;
   if (pos1 == arc_no)
    {
     *to = i;
     *from = mygraph->dest[arc_no];
     return arc_no;
    }
   else
     while (mygraph->arcs[pos1].pointer != -1)
      {
       (*from_order)++;
       *before = pos1;
       if (mygraph->arcs[pos1].pointer == arc_no)
        {
         *from = mygraph->dest[arc_no];
         *to = i;
         return pos1;
        }
       pos1 = mygraph->arcs[pos1].pointer;
      }
  }
 return -1;
}

// Assembly:
pushq %r14
pushq %rbx
movl %esi, %eax
xorl %esi, %esi
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movslq 0x10(%rdi), %r11
cmpq %r11, %rsi
jge 0x4746b
movq 0x8(%rdi), %r11
imulq $0x48, %rsi, %rbx
movl 0x30(%r11,%rbx), %ebx
cmpl $-0x1, %ebx
je 0x47452
andl $0x0, (%r8)
orl $-0x1, (%r9)
cmpl %eax, %ebx
je 0x47470
movq 0x18(%rdi), %r14
movl %ebx, %r11d
movslq %ebx, %rbx
cmpl $-0x1, (%r14,%rbx,4)
je 0x47452
incl (%r8)
movl %ebx, (%r9)
movl (%r14,%rbx,4), %ebx
cmpl %eax, %ebx
jne 0x47435
jmp 0x47457
incq %rsi
jmp 0x4740a
movq 0x28(%rdi), %rdi
cltq
movl (%rdi,%rax,4), %eax
movl %eax, (%rdx)
movl %esi, (%rcx)
movl %r11d, %eax
popq %rbx
popq %r14
retq
movl %r10d, %eax
jmp 0x47467
movl %esi, (%rcx)
movq 0x28(%rdi), %rcx
movslq %eax, %rsi
movl (%rcx,%rsi,4), %ecx
movl %ecx, (%rdx)
jmp 0x47467
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: modify_one_arc
void modify_one_arc(bayesiangraphptr G, int arc_no, int *from, int *to, int *from_order)
{
 /*!Last Changed 25.02.2001*/
 int before = -1;
 find_arc_with_no(G, arc_no, from, to, from_order, &before);
 if (before == -1)
   G->nodes[*to].pointer = G->arcs[arc_no].pointer;
 else
   G->arcs[before].pointer = G->arcs[arc_no].pointer;
 before = G->nodes[*from].pointer;
 if (before == -1)
   G->nodes[*from].pointer = arc_no;
 else
  {
   while (G->arcs[before].pointer != -1)
     before = G->arcs[before].pointer;
   G->arcs[before].pointer = arc_no;
  }
 G->arcs[arc_no].pointer = -1;
 G->dest[arc_no] = *to;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
leaq 0xc(%rsp), %r12
orl $-0x1, (%r12)
movq %r12, %r9
callq 0x473fd
movslq (%r12), %rdx
movq 0x18(%r14), %rcx
movslq %ebp, %rax
movl (%rcx,%rax,4), %esi
cmpq $-0x1, %rdx
je 0x474c6
movl %esi, (%rcx,%rdx,4)
movq 0x8(%r14), %rdx
jmp 0x474d5
movq 0x8(%r14), %rdx
movslq (%rbx), %rdi
imulq $0x48, %rdi, %rdi
movl %esi, 0x30(%rdx,%rdi)
movslq (%r15), %rsi
imulq $0x48, %rsi, %rdi
movl 0x30(%rdx,%rdi), %esi
cmpl $-0x1, %esi
je 0x474f5
movslq %esi, %rdx
movl (%rcx,%rdx,4), %esi
cmpl $-0x1, %esi
jne 0x474e5
movl %ebp, (%rcx,%rdx,4)
jmp 0x474fe
addq %rdi, %rdx
addq $0x30, %rdx
movl %ebp, (%rdx)
orl $-0x1, (%rcx,%rax,4)
movl (%rbx), %ecx
movq 0x28(%r14), %rdx
movl %ecx, (%rdx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: delete_one_arc
void delete_one_arc(bayesiangraphptr mygraph, int arc_no, int *from, int *to, int *from_order)
{
 /*!Last Changed 07.03.2001*/
 int i, dummy;
/*Once silinecek arcin yeri bulunuyor ve ondan sonra gelen parentlarin yerleri bir one aliniyor*/
 find_arc_with_no(mygraph, arc_no, from, to, from_order, &dummy);
 if (mygraph->nodes[*to].pointer == arc_no)
   mygraph->nodes[*to].pointer = mygraph->arcs[arc_no].pointer;
 else
   mygraph->arcs[dummy].pointer = mygraph->arcs[arc_no].pointer;
/*Silinecek arcdan sonrakileri teker teker kaydir*/
 for (i = arc_no; i < mygraph->arccount - 1; i++)
  {
   mygraph->arcs[i].pointer = mygraph->arcs[i + 1].pointer;
   mygraph->dest[i] = mygraph->dest[i + 1];
  }
/*Silinecek arcdan daha yuksek arc numarasi olanlarin arc numarasini bir azalt*/
 for (i = 0; i < mygraph->nodecount; i++)
   if (mygraph->nodes[i].pointer > arc_no)
     mygraph->nodes[i].pointer--;
 for (i = 0; i < mygraph->arccount; i++)
   if (mygraph->arcs[i].pointer > arc_no)
     mygraph->arcs[i].pointer--;
/*Arc ve desti yeniden realloc et*/
 mygraph->arccount--;
 mygraph->arcs = alloc(mygraph->arcs, mygraph->arccount * sizeof(struct arc), mygraph->arccount);
 mygraph->dest = alloc(mygraph->dest, mygraph->arccount * sizeof(int), mygraph->arccount);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %r9
callq 0x473fd
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movslq (%r14), %rcx
imulq $0x48, %rcx, %rdx
movslq %ebp, %rsi
movl (%rdi,%rsi,4), %ecx
cmpl %ebp, 0x30(%rax,%rdx)
jne 0x47558
addq %rax, %rdx
addq $0x30, %rdx
movl %ecx, (%rdx)
jmp 0x47577
movslq 0xc(%rsp), %rdx
movl %ecx, (%rdi,%rdx,4)
jmp 0x47577
movl 0x4(%rdi,%rsi,4), %ecx
movl %ecx, (%rdi,%rsi,4)
movq 0x28(%rbx), %rcx
movl 0x4(%rcx,%rsi,4), %edx
movl %edx, (%rcx,%rsi,4)
incq %rsi
movslq 0x20(%rbx), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rdx, %rsi
jl 0x47562
movl 0x10(%rbx), %r8d
xorl %esi, %esi
testl %r8d, %r8d
cmovlel %esi, %r8d
imulq $0x48, %r8, %r8
cmpq %rsi, %r8
je 0x475b2
movl 0x30(%rax,%rsi), %r9d
cmpl %ebp, %r9d
jle 0x475ac
decl %r9d
movl %r9d, 0x30(%rax,%rsi)
addq $0x48, %rsi
jmp 0x47595
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
cmpq %rax, %rcx
je 0x475cf
movl (%rdi,%rax,4), %esi
cmpl %ebp, %esi
jle 0x475ca
decl %esi
movl %esi, (%rdi,%rax,4)
incq %rax
jmp 0x475b9
movl %edx, 0x20(%rbx)
movq %rdx, %rsi
shlq $0x2, %rsi
callq 0x34f30
movq %rax, 0x18(%rbx)
movq 0x28(%rbx), %rdi
movslq 0x20(%rbx), %rdx
movq %rdx, %rsi
shlq $0x2, %rsi
callq 0x34f30
movq %rax, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: add_one_arc
Arcptr add_one_arc(bayesiangraphptr mygraph)
{
/*!Last Changed 25.02.2001*/
 mygraph->arccount++;
 mygraph->arcs = alloc(mygraph->arcs, mygraph->arccount * sizeof(struct arc), mygraph->arccount);
 mygraph->dest = alloc(mygraph->dest, mygraph->arccount * sizeof(int), mygraph->arccount);
 mygraph->arcs[mygraph->arccount - 1].pointer = -1;
 return &mygraph->arcs[mygraph->arccount - 1];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x20(%rdi), %rax
leaq 0x1(%rax), %rdx
movl %edx, 0x20(%rdi)
movq 0x18(%rdi), %rdi
leaq 0x4(,%rax,4), %rsi
callq 0x34f30
movq %rax, 0x18(%rbx)
movq 0x28(%rbx), %rdi
movslq 0x20(%rbx), %rdx
movq %rdx, %rsi
shlq $0x2, %rsi
callq 0x34f30
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rax
movslq 0x20(%rbx), %rcx
leaq (%rax,%rcx,4), %rax
addq $-0x4, %rax
orl $-0x1, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: add_one_pointer
void add_one_pointer(bayesiangraphptr mygraph, nodeptr src, int dest)
{
 /*!Last Changed 23.12.2000*/
 int where;
 if (src->pointer == -1)
   src->pointer = mygraph->arccount - 1;
 else
  {
   where = src->pointer;
   while (mygraph->arcs[where].pointer != -1)
     where = mygraph->arcs[where].pointer;
   mygraph->arcs[where].pointer = mygraph->arccount - 1;
  }
 mygraph->dest[mygraph->arccount - 1] = dest;
}

// Assembly:
movl 0x30(%rsi), %ecx
cmpl $-0x1, %ecx
je 0x47678
movq 0x18(%rdi), %rax
movslq %ecx, %rsi
movl (%rax,%rsi,4), %ecx
cmpl $-0x1, %ecx
jne 0x47660
movl 0x20(%rdi), %ecx
leal -0x1(%rcx), %r8d
movl %r8d, (%rax,%rsi,4)
jmp 0x47681
movl 0x20(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x30(%rsi)
movq 0x28(%rdi), %rax
movslq %ecx, %rcx
movl %edx, -0x4(%rax,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: delete_parent_counts
void delete_parent_counts(nodeptr Node, int parent_order)
{ /*Delete one parent from the parent_counts array*/
/*!Last Changed 25.02.2001*/
 int i;
 Node->table_count/=Node->parent_counts[parent_order];
 for (i=parent_order;i<Node->parents-1;i++)
   Node->parent_counts[i]=Node->parent_counts[i+1];
 Node->parents--;/*Yer kucultmede alloc yapma*/
 Node->parent_counts = alloc(Node->parent_counts, Node->parents * sizeof(int), Node->parents);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x28(%rbx), %rax
movslq %esi, %rcx
movslq (%rdi,%rcx,4), %rsi
cqto
idivq %rsi
movq %rax, 0x28(%rbx)
movslq 0x20(%rbx), %rdx
decq %rdx
cmpq %rdx, %rcx
jge 0x476c1
movl 0x4(%rdi,%rcx,4), %eax
movl %eax, (%rdi,%rcx,4)
incq %rcx
jmp 0x476a9
movl %edx, 0x20(%rbx)
movq %rdx, %rsi
shlq $0x2, %rsi
callq 0x34f30
movq %rax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: add_parent_counts
void add_parent_counts(bayesiangraphptr mygraph,nodeptr Node,int parent)
{ /*Add one parent in the parent_counts array*/
/*!Last Changed 23.12.2000*/
 Node->parents++;
 Node->parent_counts=alloc(Node->parent_counts,Node->parents*sizeof(int),Node->parents);
 Node->parent_counts[Node->parents-1]=mygraph->nodes[parent].value_count;
 Node->table_count*=mygraph->nodes[parent].value_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movslq 0x20(%rsi), %rax
leaq 0x1(%rax), %rdx
movl %edx, 0x20(%rsi)
movq 0x18(%rsi), %rdi
leaq 0x4(,%rax,4), %rsi
callq 0x34f30
movq %rax, 0x18(%r14)
movq 0x8(%r15), %rcx
movslq %ebx, %rdx
imulq $0x48, %rdx, %rdx
movslq 0x10(%rcx,%rdx), %rcx
movslq 0x20(%r14), %rdx
movl %ecx, -0x4(%rax,%rdx,4)
imulq 0x28(%r14), %rcx
movq %rcx, 0x28(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: add_one_value
void add_one_value(nodeptr current,char *st)
{/*Verilmis bir node a bir deger ekliyor*/
/*!Last Changed 15.01.2001*/
 current->value_count++;
 current->values=alloc(current->values,current->value_count*sizeof(char *),current->value_count);
 current->values[current->value_count-1]=strcopy(current->values[current->value_count-1],st);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x10(%rdi), %rax
leaq 0x1(%rax), %rdx
movl %edx, 0x10(%rdi)
movq 0x8(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x34f30
movq %rax, 0x8(%r14)
movslq 0x10(%r14), %rcx
movq -0x8(%rax,%rcx,8), %rdi
movq %rbx, %rsi
callq 0x3604c
movq 0x8(%r14), %rcx
movslq 0x10(%r14), %rdx
movq %rax, -0x8(%rcx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: find_parent_order
int find_parent_order(bayesiangraphptr G,int parent,int node)
{
/* parentin nodeun kacinci parenti olduguna doner,
   eger parent bulunamazsa -1 e doner */
/*!Last Changed 03.01.2001*/
 int where=G->nodes[node].pointer,order=-1;
 while (where!=-1)
  {
   order++;
   if (G->dest[where]==parent)
     return order;
   where=G->arcs[where].pointer;
  }
 return -1;
}

// Assembly:
movq 0x8(%rdi), %rax
movslq %edx, %rcx
imulq $0x48, %rcx, %rcx
leaq (%rax,%rcx), %rdx
addq $0x30, %rdx
xorl %ecx, %ecx
pushq $-0x1
popq %rax
movslq (%rdx), %rdx
cmpq $-0x1, %rdx
je 0x477d9
movq 0x28(%rdi), %r8
cmpl %esi, (%r8,%rdx,4)
je 0x477d7
shlq $0x2, %rdx
addq 0x18(%rdi), %rdx
incl %ecx
jmp 0x477b8
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: find_arc_no
int find_arc_no(bayesiangraphptr G,int from, int to, int *arc_no, int *before)
{
/* eger belirtilen arc yoksa 0 a varsa 1 e donsun....*/
/* arc_no from-->to arcinin numarasi, before bundan bir oncekinin numarasi*/
/*!Last Changed 03.01.2001*/
 *before = -1;
 if ((to<0)||(to>=G->nodecount))
   return 0;
 if ((from<0)||(from>=G->nodecount))
   return 0;
 *arc_no=G->nodes[to].pointer;
 while ((*arc_no!=-1)&&(G->dest[*arc_no]!=from))
  {
   *before=*arc_no;
   *arc_no=G->arcs[*arc_no].pointer;
  }
 if (*arc_no==-1)
   return 0;
 else
   return 1;
}

// Assembly:
orl $-0x1, (%r8)
xorl %eax, %eax
testl %edx, %edx
js 0x4783c
movl 0x10(%rdi), %r9d
cmpl %edx, %r9d
jle 0x4783c
testl %esi, %esi
sets %r10b
cmpl %esi, %r9d
setle %r9b
orb %r10b, %r9b
jne 0x4783c
movq 0x8(%rdi), %rax
movl %edx, %edx
imulq $0x48, %rdx, %rdx
addq %rdx, %rax
addq $0x30, %rax
movslq (%rax), %rdx
movl %edx, (%rcx)
cmpq $-0x1, %rdx
je 0x47834
movq 0x28(%rdi), %rax
cmpl %esi, (%rax,%rdx,4)
je 0x47834
movl %edx, (%r8)
movslq (%rcx), %rax
shlq $0x2, %rax
addq 0x18(%rdi), %rax
jmp 0x47810
xorl %eax, %eax
cmpl $-0x1, %edx
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: create_graph
bayesiangraphptr create_graph(char *graph_name)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 07.03.2001*/
 bayesiangraphptr result;
 result = (bayesiangraphptr)safemalloc(sizeof(bayesiangraph), "create_graph", 2);
 result->nodecount=0;
 result->arccount=0;
 result->ordering=NULL;
 result->independence=NULL;
 result->one_independence=NULL;
 result->name=strcopy(result->name,graph_name);
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x52e34(%rip), %rsi     # 0x9a67f
pushq $0x48
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r14
andl $0x0, 0x10(%rax)
andl $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
andq $0x0, 0x40(%rax)
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3604c
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: deallocate_graph
void deallocate_graph(bayesiangraphptr G)
{
 /*!Last Changed 07.03.2001*/
 int i;
 safe_free(G->name);
 for (i = 0; i < G->nodecount; i++)
  {
   safe_free(G->nodes[i].name);
			free_2d((void**)G->nodes[i].values, G->nodes[i].value_count);
   if (G->nodes[i].parents)
     safe_free(G->nodes[i].parent_counts);
			free_2d((void**)G->nodes[i].table, G->nodes[i].table_count);
  }
 if (G->independence!=NULL)
		 free_2d((void**)G->independence, G->nodecount);
 if (G->one_independence!=NULL)
		 free_3d((void***)G->one_independence, G->nodecount, G->nodecount);
 safe_free(G->dest);
 safe_free(G->arcs);
 safe_free(G->nodes);
 safe_free(G);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x34ff7
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x10(%rbx), %rsi
cmpq %rsi, %r15
jge 0x478f7
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x34ff7
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
movl 0x10(%rax,%r14), %esi
callq 0x34fc3
movq 0x8(%rbx), %rax
cmpl $0x0, 0x20(%rax,%r14)
je 0x478df
movq 0x18(%rax,%r14), %rdi
callq 0x34ff7
movq 0x8(%rbx), %rax
movq 0x38(%rax,%r14), %rdi
movl 0x28(%rax,%r14), %esi
callq 0x34fc3
incq %r15
addq $0x48, %r14
jmp 0x4789c
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x47905
callq 0x34fc3
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x47918
movl 0x10(%rbx), %edx
movl %edx, %esi
callq 0x34ffc
movq 0x28(%rbx), %rdi
callq 0x34ff7
movq 0x18(%rbx), %rdi
callq 0x34ff7
movq 0x8(%rbx), %rdi
callq 0x34ff7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: swap_independence
void swap_independence(double **result,int i,int j)
{
/*!Last Changed 11.02.2001*/
 double temp;
 int k;
 for (k=0;k<3;k++)
  {
   temp=result[i][k];
   result[i][k]=result[j][k];
   result[j][k]=temp;
  }
}

// Assembly:
movslq %esi, %rax
movq (%rdi,%rax,8), %rax
movslq %edx, %rcx
movq (%rdi,%rcx,8), %rcx
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x4796f
movsd (%rax,%rdx,8), %xmm0
movsd (%rcx,%rdx,8), %xmm1
movsd %xmm1, (%rax,%rdx,8)
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
jmp 0x47950
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: qsort_independence
void qsort_independence(double **result,int left,int right)
{
/*!Last Changed 11.02.2001*/
 int i,last;
 if (left>=right)
   return;
 swap_independence(result,left,(left+right)/2);
 last=left;
 for (i=left+1;i<=right;i++)
   if (result[i][2]>result[left][2])
    {
     last++;
     swap_independence(result,last,i);
    }
 swap_independence(result,left,last);
 qsort_independence(result,left,last-1);
 qsort_independence(result,last+1,right);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rbp
movq %rdx, (%rsp)
cmpl %edx, %r15d
jge 0x47a07
leal (%r15,%rdx), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x47940
movslq %r15d, %rbx
movq %rbx, %r13
movl %r15d, %r12d
cmpq %rbp, %r13
jge 0x479dd
movq 0x8(%r14,%r13,8), %rax
incq %r13
movsd 0x10(%rax), %xmm0
movq (%r14,%rbx,8), %rax
ucomisd 0x10(%rax), %xmm0
jbe 0x479ad
incl %r12d
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x47940
jmp 0x479ad
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x47940
leal -0x1(%r12), %edx
movq %r14, %rdi
movl %r15d, %esi
callq 0x47970
incl %r12d
movl %r12d, %r15d
movq (%rsp), %rdx
jmp 0x47988
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq