LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariaterule.c
// Function: generalization_error_after_pruning
double generalization_error_after_pruning(Ruleset r, Instanceptr data, int positive, int modelselectionmethod)
{
 /*!Last Changed 19.02.2005*/
 int *deleted, rulecount, i;
 double result, tmp;
 Decisionruleptr rule;
 deleted = safecalloc(r.rulecount, sizeof(int), "generalization_error_after_pruning", 4);
 result = generalization_error_of_ruleset_with_deleted_rules(r, data, deleted, positive, modelselectionmethod);
 rule = r.start;
 rulecount = 0;
 while (rule && rule->classno != positive)
  {
   rule = rule->next;
   rulecount++;
  }
 for (i = r.rulecount - 1; i >= rulecount; i--)
  {
   deleted[i] = 1;
   tmp = generalization_error_of_ruleset_with_deleted_rules(r, data, deleted, positive, modelselectionmethod);
   if (tmp > result)
     deleted[i] = 0;
   else
     result = tmp;
  }
 safe_free(deleted);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x80(%rsp), %r15
leaq 0x57b93(%rip), %rdx     # 0xa7877
movl $0x4, %esi
movq %r15, %rdi
movl $0x4, %ecx
callq 0x39210
movq %rax, %r12
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
movapd 0x70(%rsp), %xmm0
movapd 0x80(%rsp), %xmm1
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r14, 0x30(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ebx, %r14d
movl %ebx, %ecx
callq 0x4f9ca
movq 0x70(%rsp), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x4fd4f
cmpl %ebp, (%rcx)
je 0x4fd4f
incl %eax
movq 0x30(%rcx), %rcx
jmp 0x4fd3e
cmpl %eax, %r15d
jle 0x4fdc6
leaq 0x70(%rsp), %r13
movslq %eax, %rbx
movsd %xmm0, 0x28(%rsp)
movl $0x1, -0x4(%r12,%r15,4)
movq 0x20(%r13), %rax
movq %rax, 0x20(%rsp)
movupd (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x4f9ca
movapd %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x4fdb8
movl $0x0, -0x4(%r12,%r15,4)
movapd %xmm0, %xmm1
decq %r15
movapd %xmm1, %xmm0
cmpq %rbx, %r15
jg 0x4fd5c
jmp 0x4fdca
movapd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movq %r12, %rdi
callq 0x39194
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariaterule.c
// Function: growrule_omnivariate
Decisionruleptr growrule_omnivariate(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_hybrid_condition(&obey, positive, 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
movq $0x0, 0x80(%rsp)
movl %esi, %edi
callq 0x7a713
movq %rax, %r14
movq %rbx, 0x90(%rsp)
movq (%rbx), %rdi
movq %rdi, 0x78(%rsp)
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 0x7ad4b
testl %eax, %eax
je 0x504ac
setne %al
movzbl %al, %r15d
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq 0x98(%rsp), %rdx
callq 0x50cdd
testq %rax, %rax
je 0x504ac
movq %rax, %r13
cmpl $-0x1, (%rax)
je 0x50491
movq 0x78(%rsp), %r8
movq %r13, %rdi
leaq 0xa4(%rsp), %rsi
leaq 0x8c(%rsp), %rdx
movl %ebp, %ecx
callq 0x7984a
cmpl $0x0, 0x28(%r14)
movl 0x8c(%rsp), %ebx
je 0x5046a
cmpl %r15d, %ebx
je 0x50491
movq %r13, %rdi
movq %r12, %rsi
leaq 0x80(%rsp), %rdx
callq 0x9c270
movq %r14, %rdi
movq %r13, %rsi
callq 0x7a77b
movl %ebx, %r15d
testl %ebx, %ebx
jg 0x50419
jmp 0x504ac
movl $0xe, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x7a935
movq %r13, %rdi
callq 0x39194
cmpq $0x0, 0x80(%rsp)
je 0x504ce
movq 0x78(%rsp), %rsi
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
callq 0x2fd59
jmp 0x504d3
leaq 0x78(%rsp), %rbx
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_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: decisiontree_node_types
void decisiontree_node_types(Decisionnodeptr node, char st[READLINELENGTH], int level)
{
 int i;
 if (node->featureno != LEAF_NODE)
  {
   if (node->featureno >= 0)
     sprintf(st, "%s%d-U-%d;", st, level, node->covered);
   else
     if (node->featureno == LINEAR)
       sprintf(st, "%s%d-L-%d;", st, level, node->covered);
     else
       if (node->featureno == QUADRATIC) 
         sprintf(st, "%s%d-Q-%d;", st, level, node->covered);
       else
         if (node->featureno == DISCRETEMIX)
           sprintf(st, "%s%d-%d;", st, level, node->ksplit.featurecount);
   if (node->featureno >= 0 && current_dataset->features[node->featureno].type == STRING)
    {
     for (i = 0; i < current_dataset->features[node->featureno].valuecount; i++)
       decisiontree_node_types(&(node->string[i]), st, level + 1);
    }
   else
    {
     decisiontree_node_types(node->left, st, level + 1);
     decisiontree_node_types(node->right, st, level + 1);    
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x56376(%rip), %r12     # 0xa7930
leaq 0x812af(%rip), %rbp     # 0xd2870
leaq 0x56373(%rip), %r13     # 0xa793b
movl 0x30(%r15), %eax
cmpl $-0x1, %eax
je 0x516c4
testl %eax, %eax
js 0x51625
movl 0x84(%r15), %r8d
movq %r14, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x41b0
movslq 0x30(%r15), %rax
testq %rax, %rax
js 0x51610
movq (%rbp), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
je 0x5166c
movq (%r15), %rdi
incl %ebx
movq %r14, %rsi
movl %ebx, %edx
callq 0x515a0
movq 0x8(%r15), %r15
jmp 0x515c8
cmpl $-0x5, %eax
je 0x51656
cmpl $-0x3, %eax
je 0x51643
cmpl $-0x2, %eax
jne 0x515f2
movl 0x84(%r15), %r8d
movq %r14, %rdi
movq %r13, %rsi
jmp 0x515e6
movl 0x84(%r15), %r8d
movq %r14, %rdi
leaq 0x562f2(%rip), %rsi     # 0xa7946
jmp 0x515e6
movl 0x140(%r15), %r8d
movq %r14, %rdi
leaq 0x562ea(%rip), %rsi     # 0xa7951
jmp 0x515e6
movq (%rbp), %rax
movslq 0x30(%r15), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x0, 0x30f20(%rax,%rcx)
jle 0x516c4
incl %ebx
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
addq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x515a0
incq %r13
movq (%rbp), %rax
movslq 0x30(%r15), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %rax
addq $0x160, %r12            # imm = 0x160
cmpq %rax, %r13
jl 0x5168d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_uni_and_multi_splits
void find_uni_and_multi_splits(Decisionnodeptr node, matrix* qw, double* qw0, double points[3], double variance_explained, int hybridspace)
{
 /*!Last Changed 22.11.2004*/
 node->featureno = find_best_ldt_feature_for_realized(node->instances, &(node->split));
 points[0] = node->featureno;
 node->lineard = find_best_multi_ldt_split(&(node->instances), &(node->w), &(node->w0), MULTIVARIATE_LINEAR, variance_explained);
 points[1] = node->lineard - 1;
 if (points[1] == -1)
   matrix_free(node->w);
 points[2] = -1;
 if (hybridspace == 3)
  {
   node->quadraticd = find_best_multi_ldt_split(&(node->instances), qw, qw0, MULTIVARIATE_QUADRATIC, variance_explained);
   points[2] = node->quadraticd - 1;
   if (points[2] == -1)
     matrix_free(*qw);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movsd %xmm0, (%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rdi), %r13
movq 0x20(%rdi), %rdi
leaq 0x28(%r15), %rsi
callq 0x9f13b
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movl %eax, 0x30(%r15)
movsd %xmm0, (%r14)
leaq 0x38(%r15), %rsi
leaq 0x48(%r15), %rdx
movq %r13, %rdi
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movsd (%rsp), %xmm0
callq 0x4cbee
movl %eax, 0x90(%r15)
subl $0x1, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%r14)
jae 0x51d85
movq 0x38(%r15), %rdi
movq 0x40(%r15), %rsi
callq 0x3dbad
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%r14)
cmpl $0x3, %ebp
jne 0x51de3
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
movsd (%rsp), %xmm0
callq 0x4cbee
movl %eax, 0x94(%r15)
subl $0x1, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%r14)
jae 0x51de3
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3dbad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: calculate_counts_for_ldt_splits
void calculate_counts_for_ldt_splits(int univariate, Decisionnodeptr node, int *C, int *U, int *fp, int *fn)
{
 /*!Last Changed 22.11.2004*/
 int counts[2][MAXCLASSES], i, leftclass, rightclass;
 if (univariate)
   find_counts_for_split(node->instances, node->featureno, node->split, counts[0], counts[1], node->conditiontype);
 else
   find_counts_for_multivariate_split(node->instances, node->w, node->w0, counts[0], counts[1]);
 leftclass = find_max_in_list(counts[0], MAXCLASSES);
 rightclass = find_max_in_list(counts[1], MAXCLASSES);
 *C = 0;
 *U = 0;
 *fp = 0;
 *fn = 0;
 for (i = 0; i < current_dataset->classno; i++)
  {
   *C += counts[0][i];
   *U += counts[1][i];
   if (i != leftclass)
     *fp += counts[0][i];
   if (i != rightclass)
     *fn += counts[1][i];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %edi, %eax
movq 0x20(%rsi), %rdi
testl %eax, %eax
je 0x51e3a
movl 0x30(%rsi), %eax
movsd 0x28(%rsi), %xmm0
leaq 0xc8(%rsp), %rcx
movl 0x98(%rsi), %r8d
movq %rsp, %rdx
movl %eax, %esi
callq 0x9e1bf
jmp 0x51e5a
movsd 0x48(%rsi), %xmm0
leaq 0xc8(%rsp), %r8
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rdx
movq %rsp, %rcx
movq %rax, %rsi
callq 0x4c971
movq %rsp, %rdi
movl $0x32, %esi
callq 0x37504
movl %eax, %ebp
leaq 0xc8(%rsp), %rdi
movl $0x32, %esi
callq 0x37504
xorl %edx, %edx
movl %edx, (%r12)
movl %edx, (%r15)
movl %edx, (%r14)
movl %edx, (%rbx)
leaq 0x809e0(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
cmpl %edx, 0x10(%rcx)
jle 0x51ecb
movl %ebp, %edx
movl %eax, %eax
xorl %esi, %esi
movl (%rsp,%rsi,4), %r8d
addl %r8d, (%r12)
movl 0xc8(%rsp,%rsi,4), %edi
addl %edi, (%r15)
cmpq %rsi, %rdx
je 0x51eb8
addl %r8d, (%r14)
cmpq %rsi, %rax
je 0x51ebf
addl %edi, (%rbx)
incq %rsi
movslq 0x10(%rcx), %rdi
cmpq %rdi, %rsi
jl 0x51e9e
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: set_best_hybrid_split
int set_best_hybrid_split(double results[3], Decisionnodeptr node, matrix qw, double qw0, int hybridspace)
{
 /*!Last Changed 01.02.2005*/
 int bestmodel;
 bestmodel = find_min_in_list_double(results, hybridspace);
 if (bestmodel == -1)
  {
   node->featureno = LEAF_NODE;
   return 0;
  }
 switch (bestmodel)
  {
   case MODEL_UNI:if (results[1] != -1)
                    matrix_free(node->w);
                  if (results[2] != -1 && hybridspace == 3)
                    matrix_free(qw);
                  break;
   case MODEL_LIN:node->featureno = LINEAR;
                  if (results[2] != -1 && hybridspace == 3)
                    matrix_free(qw);
                  break;
   case MODEL_QUA:node->featureno = QUADRATIC;
                  if (results[1] != -1)
                    matrix_free(node->w);
                  node->w = qw;
                  node->w0 = qw0;
                  break;
  }
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movsd %xmm0, (%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %r8d, %esi
callq 0x37740
movl $0x1, %ebx
incl %eax
cmpl $0x3, %eax
ja 0x51fc2
leaq 0x559e7(%rip), %rcx     # 0xa7900
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, 0x30(%r12) # imm = 0xFFFFFFFF
xorl %ebx, %ebx
jmp 0x51fc2
movl $0xfffffffe, 0x30(%r12) # imm = 0xFFFFFFFE
jmp 0x51fa0
movl $0xfffffffd, 0x30(%r12) # imm = 0xFFFFFFFD
movsd 0x8(%r13), %xmm0
ucomisd 0x50e54(%rip), %xmm0    # 0xa2da8
jne 0x51f58
jnp 0x51f67
movq 0x38(%r12), %rdi
movq 0x40(%r12), %rsi
callq 0x3dbad
movq %r15, 0x38(%r12)
movq %r14, 0x40(%r12)
movsd (%rsp), %xmm0
movsd %xmm0, 0x48(%r12)
jmp 0x51fc2
movsd 0x8(%r13), %xmm0
ucomisd 0x50e1b(%rip), %xmm0    # 0xa2da8
jne 0x51f91
jnp 0x51fa0
movq 0x38(%r12), %rdi
movq 0x40(%r12), %rsi
callq 0x3dbad
cmpl $0x3, %ebp
jne 0x51fc2
movsd 0x10(%r13), %xmm0
ucomisd 0x50df5(%rip), %xmm0    # 0xa2da8
jne 0x51fb7
jnp 0x51fc2
movq %r15, %rdi
movq %r14, %rsi
callq 0x3dbad
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split_single_model
int find_best_hybrid_ldt_split_single_model(Decisionnodeptr node, NODE_TYPE model, double variance_explained)
{
 /*!Last Changed 13.02.2005*/
 switch (model)
  {
   case UNIVARIATE:node->featureno = find_best_ldt_feature_for_realized(node->instances, &(node->split));
                   if (node->featureno == -1)
                     return 0;
                   break;
   case     LINEAR:node->lineard = find_best_multi_ldt_split(&(node->instances), &(node->w), &(node->w0), MULTIVARIATE_LINEAR, variance_explained);
                   if (node->lineard == 0)
                    {
                     matrix_free(node->w);
                     node->featureno = LEAF_NODE;
                     return 0;
                    }
                   else
                     node->featureno = LINEAR;
                   break;
   case  QUADRATIC:node->quadraticd = find_best_multi_ldt_split(&(node->instances), &(node->w), &(node->w0), MULTIVARIATE_QUADRATIC, variance_explained);
                   if (node->quadraticd == 0)
                    {
                     matrix_free(node->w);
                     node->featureno = LEAF_NODE;
                     return 0;
                    }
                   else
                     node->featureno = QUADRATIC;
                   break;
   default        :node->featureno = LEAF_NODE;
                   printf("This node type is not supported\n");
                   break;
  }
 return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x3, %esi
je 0x52028
cmpl $-0x2, %esi
je 0x51fff
testl %esi, %esi
jne 0x52051
movq 0x20(%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0x9f13b
movl %eax, 0x30(%rbx)
cmpl $-0x1, %eax
jne 0x52064
jmp 0x5207f
leaq 0x20(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x48(%rbx), %rdx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x4cbee
movl %eax, 0x90(%rbx)
testl %eax, %eax
je 0x5206b
movl $0xfffffffe, 0x30(%rbx) # imm = 0xFFFFFFFE
jmp 0x52064
leaq 0x20(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x48(%rbx), %rdx
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
callq 0x4cbee
movl %eax, 0x94(%rbx)
testl %eax, %eax
je 0x5206b
movl $0xfffffffd, 0x30(%rbx) # imm = 0xFFFFFFFD
jmp 0x52064
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
leaq 0x5592a(%rip), %rdi     # 0xa7989
callq 0x4090
movl $0x1, %eax
jmp 0x52081
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x3dbad
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split_aic
int find_best_hybrid_ldt_split_aic(Decisionnodeptr node, Multildt_parameterptr param)
{
 /*!Last Changed 01.02.2005*/
 /*!Last Changed 22.11.2004*/
 int hybridspace = get_parameter_i("hybridspace");
 matrix qw;
 int d, i;
 double qw0, results[3], loglikelihood;
 find_uni_and_multi_splits(node, &qw, &qw0, results, param->variance_explained, hybridspace);
 for (i = 0; i < hybridspace; i++)
   if (results[i] != -1)
    {
     switch (i)
      {
       case 0:loglikelihood = log_likelihood_for_uni_ldt_splits(node->instances, node->featureno, node->split, param->conditiontype);
              d = 2;
              break;
       case 1:loglikelihood = log_likelihood_for_multi_ldt_splits(node->instances, node->w, node->w0);
              d = node->lineard + 1;
              break;
       case 2:loglikelihood = log_likelihood_for_multi_ldt_splits(node->instances, qw, qw0);
              d = node->quadraticd + 1;
              break;
       default:loglikelihood = 0.0;
               d = 0;
               break;
      }
     results[i] = aic_loglikelihood(loglikelihood, d);
    }
 return set_best_hybrid_split(results, node, qw, qw0, hybridspace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x53b84(%rip), %rdi     # 0xa5c20
callq 0x5341c
movl %eax, %ebp
movsd 0x20(%r14), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %r8d
callq 0x51d05
testl %ebp, %ebp
jle 0x5217b
movl %ebp, %r15d
xorl %r12d, %r12d
movsd 0x20(%rsp,%r12,8), %xmm0
ucomisd 0x50cc8(%rip), %xmm0    # 0xa2da8
jne 0x520e8
jnp 0x5216f
cmpl $0x2, %r12d
je 0x52133
cmpl $0x1, %r12d
je 0x52115
testl %r12d, %r12d
jne 0x52156
movq 0x20(%rbx), %rdi
movl 0x30(%rbx), %esi
movsd 0x28(%rbx), %xmm0
movl 0x2c(%r14), %edx
callq 0x9fa52
movl $0x2, %eax
jmp 0x5215c
movsd 0x48(%rbx), %xmm0
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
callq 0x4cb9d
movl 0x90(%rbx), %eax
jmp 0x52152
movq 0x20(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4cb9d
movl 0x94(%rbx), %eax
incl %eax
jmp 0x5215c
xorpd %xmm0, %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
callq 0x464c1
movsd %xmm0, 0x20(%rsp,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x520d1
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %r8d
callq 0x51edb
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split_bic
int find_best_hybrid_ldt_split_bic(Decisionnodeptr node, Multildt_parameterptr param)
{
 /*!Last Changed 01.02.2005*/
 /*!Last Changed 22.11.2004*/
 int hybridspace = get_parameter_i("hybridspace");
 int i, d, N = data_size(node->instances);
 matrix qw;
 double loglikelihood, qw0, results[3];
 find_uni_and_multi_splits(node, &qw, &qw0, results, param->variance_explained, hybridspace);
 for (i = 0; i < hybridspace; i++)
   if (results[i] != -1)
    {
     switch (i)
      {
       case 0:loglikelihood = log_likelihood_for_uni_ldt_splits(node->instances, node->featureno, node->split, param->conditiontype);
              d = 2;
              break;
       case 1:loglikelihood = log_likelihood_for_multi_ldt_splits(node->instances, node->w, node->w0);
              d = node->lineard + 1;
              break;
       case 2:loglikelihood = log_likelihood_for_multi_ldt_splits(node->instances, qw, qw0);
              d = node->quadraticd + 1;
              break;
       default:loglikelihood = 0.0;
               d = 0;
               break;
      }
     results[i] = bic_loglikelihood(loglikelihood, d, N);
    }
 return set_best_hybrid_split(results, node, qw, qw0, hybridspace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x53a5d(%rip), %rdi     # 0xa5c20
callq 0x5341c
movl %eax, %ebp
movq 0x20(%rbx), %rdi
callq 0x2fa14
movl %eax, %r15d
movsd 0x20(%r14), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %r8d
callq 0x51d05
testl %ebp, %ebp
jle 0x522b1
movl %ebp, %r12d
xorl %r13d, %r13d
movsd 0x20(%rsp,%r13,8), %xmm0
ucomisd 0x50b95(%rip), %xmm0    # 0xa2da8
jne 0x5221b
jnp 0x522a5
cmpl $0x2, %r13d
je 0x52266
cmpl $0x1, %r13d
je 0x52248
testl %r13d, %r13d
jne 0x52289
movq 0x20(%rbx), %rdi
movl 0x30(%rbx), %esi
movsd 0x28(%rbx), %xmm0
movl 0x2c(%r14), %edx
callq 0x9fa52
movl $0x2, %eax
jmp 0x5228f
movsd 0x48(%rbx), %xmm0
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
callq 0x4cb9d
movl 0x90(%rbx), %eax
jmp 0x52285
movq 0x20(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4cb9d
movl 0x94(%rbx), %eax
incl %eax
jmp 0x5228f
xorpd %xmm0, %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movl %r15d, %edi
callq 0x46930
movsd %xmm0, 0x20(%rsp,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x52204
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %r8d
callq 0x51edb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_error_and_free_matrix
int find_error_and_free_matrix(Instanceptr* train, Instanceptr test, NODE_TYPE node_type, double variance_explained)
{
 /*!Last Changed 03.12.2004*/
 int bestfeature, error, counts[2][MAXCLASSES], leftclass, rightclass;
 double split, w0;
 matrix w;
 if (node_type == UNIVARIATE)
  {
   bestfeature = find_best_ldt_feature_for_realized(*train, &split);
   if (bestfeature == -1)
     return data_size(test);
  }
 else
   if (!find_best_multi_ldt_split(train, &w, &w0, node_type, variance_explained))
    {
     matrix_free(w);
     return data_size(test);
    }
 if (node_type == UNIVARIATE)
   find_counts_for_split(*train, bestfeature, split, counts[0], counts[1], HYBRID_CONDITION);
 else
   find_counts_for_multivariate_split(*train, w, w0, counts[0], counts[1]);
 leftclass = find_max_in_list(counts[0], MAXCLASSES);
 rightclass = find_max_in_list(counts[1], MAXCLASSES);
 if (node_type == UNIVARIATE)
   return test_univariate(test, bestfeature, split, leftclass, rightclass);
 else
  {
   error = test_multivariate(test, w, w0, leftclass, rightclass);
   matrix_free(w);
   return error;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testl %edx, %edx
je 0x52a9e
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0x4cbee
testl %eax, %eax
jne 0x52ab3
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3dbad
jmp 0x52add
movq (%r15), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9f13b
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x52add
movq (%r15), %rdi
leaq 0xe8(%rsp), %r8
testl %ebp, %ebp
je 0x52aea
movsd 0x10(%rsp), %xmm0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x4c971
jmp 0x52b06
movq %rbx, %rdi
callq 0x2fa14
jmp 0x52b73
movsd 0x18(%rsp), %xmm0
leaq 0x20(%rsp), %rdx
movl %r14d, %esi
movq %r8, %rcx
movl $0x2, %r8d
callq 0x9e1bf
leaq 0x20(%rsp), %rdi
movl $0x32, %esi
callq 0x37504
movl %eax, %r15d
leaq 0xe8(%rsp), %rdi
movl $0x32, %esi
callq 0x37504
testl %ebp, %ebp
je 0x52b5d
movsd 0x10(%rsp), %xmm0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r15d, %ecx
movl %eax, %r8d
callq 0x4bba2
movl %eax, %ebx
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3dbad
jmp 0x52b75
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x9cc62
movl %eax, %ebx
movl %ebx, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split_according_char
int find_best_hybrid_ldt_split_according_char(Decisionnodeptr node, char model, double variance_explained)
{
 /*!Last Changed 01.07.2006*/
 switch (model){
   case 'U':
   case 'u':return find_best_hybrid_ldt_split_single_model(node, UNIVARIATE, variance_explained);
            break;
   case 'L':
   case 'l':return find_best_hybrid_ldt_split_single_model(node, LINEAR, variance_explained);
            break;
   case 'Q':
   case 'q':return find_best_hybrid_ldt_split_single_model(node, QUADRATIC, variance_explained);
            break;
   default :printf(m1325);
            return NO;
            break;
 }
}

// Assembly:
pushq %rbx
addl $-0x4c, %esi
cmpl $0x29, %esi
ja 0x52bf5
movq %rdi, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
btq %rsi, %rax
jb 0x52be7
movabsq $0x2000000020, %rax     # imm = 0x2000000020
btq %rsi, %rax
jb 0x52bdd
movabsq $0x20000000200, %rax    # imm = 0x20000000200
btq %rsi, %rax
jae 0x52bf5
movq 0x20(%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0x9f13b
movl %eax, %ecx
movl %eax, 0x30(%rbx)
xorl %eax, %eax
cmpl $-0x1, %ecx
setne %al
jmp 0x52c03
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
jmp 0x52bef
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
popq %rbx
jmp 0x51fd3
leaq 0x54b92(%rip), %rdi     # 0xa778e
callq 0x4090
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split
int find_best_hybrid_ldt_split(Decisionnodeptr node, Multildt_parameterptr param)
{
 /*!Last Changed 22.11.2004 can now find the best split using model selection methods other than cross-validation*/
 /*!Last Changed 23.09.2004*/
 switch (param->modelselectionmethod)
  {
   case MODEL_SELECTION_CV :return find_best_hybrid_ldt_split_crossvalidation(node, param);
                            break;
   case MODEL_SELECTION_AIC:return find_best_hybrid_ldt_split_aic(node, param);
                            break;
   case MODEL_SELECTION_BIC:return find_best_hybrid_ldt_split_bic(node, param);
                            break;
   case MODEL_SELECTION_SRM:return find_best_hybrid_ldt_split_srm(node, param);
                            break;
   case MODEL_SELECTION_MDL:break;
   case MODEL_SELECTION_UNI:return find_best_hybrid_ldt_split_single_model(node, UNIVARIATE, param->variance_explained);
                            break;
   case MODEL_SELECTION_LIN:return find_best_hybrid_ldt_split_single_model(node, LINEAR, param->variance_explained);
                            break;
   case MODEL_SELECTION_QUA:return find_best_hybrid_ldt_split_single_model(node, QUADRATIC, param->variance_explained);
                            break;
  }
 return 0;
}

// Assembly:
pushq %rbx
movl 0x18(%rsi), %ecx
xorl %eax, %eax
cmpq $0x7, %rcx
ja 0x52c84
movq %rdi, %rbx
leaq 0x54cf5(%rip), %rdx     # 0xa7910
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
popq %rbx
jmp 0x52523
movsd 0x20(%rsi), %xmm0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
jmp 0x52c52
movq %rbx, %rdi
popq %rbx
jmp 0x52083
movsd 0x20(%rsi), %xmm0
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
popq %rbx
jmp 0x51fd3
movq %rbx, %rdi
popq %rbx
jmp 0x521a8
movq %rbx, %rdi
popq %rbx
jmp 0x522e0
movq 0x20(%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0x9f13b
movl %eax, %ecx
movl %eax, 0x30(%rbx)
xorl %eax, %eax
cmpl $-0x1, %ecx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/omnivariatetree.c
// Function: create_omnildtchildren
int create_omnildtchildren(Decisionnodeptr node, Multildt_parameterptr param)
{
 /*!Last Changed 22.11.2004 added model selection method*/
 /*!Last Changed 23.09.2004*/
 node->conditiontype = HYBRID_CONDITION;
 if (!(can_be_divided(node, &(param->c45param))))
   return 1;
 if (!(find_best_hybrid_ldt_split(node, param)))
  {
   make_leaf_node(node);
   return 1;
  }
 if (!(make_multivariate_children(node)))
   return 1;
 create_omnildtchildren(node->left, param);
 create_omnildtchildren(node->right, param);
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %r12d
movl $0x2, 0x98(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c8e2
testl %eax, %eax
je 0x52cf5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52c05
testl %eax, %eax
je 0x52ced
movq %rbx, %rdi
callq 0x4c6b9
testl %eax, %eax
je 0x52cf5
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x52c86
movq 0x8(%rbx), %rbx
testb $0x1, %r15b
cmovel %r12d, %ebp
movb $0x1, %r15b
jmp 0x52c9d
movq %rbx, %rdi
callq 0x1c39c
testb $0x1, %r15b
movl $0x1, %eax
cmovnel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/operator.c
// Function: remove_operator
BOOLEAN remove_operator(bayesiangraphptr mygraph)
{
/*!Last Changed 02.03.2001*/
 int arc_no, from, to, from_order;
 double before, after;
 if (mygraph->arccount == mygraph->nodecount - 1)
   return BOOLEAN_FALSE;
 arc_no = myrand() % mygraph->arccount;
 before = likelihood_of_data(mygraph, cv);
 delete_one_arc(mygraph, arc_no, &from, &to, &from_order);
 delete_parent_counts(&mygraph->nodes[to], from_order);
 free_2d((void **) mygraph->nodes[to].table, mygraph->nodes[to].table_count);
 make_one_conditional_table(mygraph, to);
 if (connected(mygraph))
  {
   after = likelihood_of_data(mygraph, cv);
   if (after > before)
     return BOOLEAN_TRUE;
  }
 free_2d((void **) mygraph->nodes[to].table, mygraph->nodes[to].table_count);
 add_parent_counts(mygraph, &mygraph->nodes[to], from);
 add_one_arc(mygraph);
 add_one_pointer(mygraph, &mygraph->nodes[to], from);
 make_one_conditional_table(mygraph, to);
 return BOOLEAN_FALSE;
}

// Assembly:
movl 0x10(%rdi), %ecx
decl %ecx
xorl %eax, %eax
cmpl %ecx, 0x20(%rdi)
je 0x52e51
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x39f18
cltd
idivl 0x20(%rbx)
movl %edx, %ebp
leaq 0x7f789(%rip), %r12     # 0xd24c8
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x26bfe
movsd %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %r14
leaq 0x1c(%rsp), %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x4d31d
movslq (%r14), %rax
leaq (%rax,%rax,8), %rdi
shlq $0x3, %rdi
addq 0x8(%rbx), %rdi
movl (%r15), %esi
callq 0x4d4b0
movq 0x8(%rbx), %rax
movslq (%r14), %rcx
leaq (%rcx,%rcx,8), %rcx
movq 0x38(%rax,%rcx,8), %rdi
movl 0x28(%rax,%rcx,8), %esi
callq 0x3915f
movl (%r14), %esi
movq %rbx, %rdi
callq 0x4e149
movq %rbx, %rdi
callq 0x4da05
testl %eax, %eax
je 0x52dda
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x26bfe
movl $0x1, %eax
ucomisd 0x10(%rsp), %xmm0
ja 0x52e45
movq 0x8(%rbx), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,8), %rcx
movq 0x38(%rax,%rcx,8), %rdi
movl 0x28(%rax,%rcx,8), %esi
callq 0x3915f
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movl 0xc(%rsp), %edx
movq %rbx, %rdi
callq 0x4d508
movq %rbx, %rdi
callq 0x4d426
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movl 0xc(%rsp), %edx
movq %rbx, %rdi
callq 0x4d47a
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x4e149
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/ordering.c
// Function: state_ordering
void state_ordering(bayesiangraphptr mygraph)
{
 /*!Last Changed 30.05.2008 added random_ordering*/
 /*!Last Changed 23.12.2000*/
 int i, j;
 random_ordering(mygraph);
 for (i = 0; i < mygraph->nodecount; i++)
   for (j = 0; j < mygraph->nodecount; j++)
     if ((mygraph->ordering[i] < mygraph->ordering[j]) && (mygraph->nodes[i].value_count > mygraph->nodes[j].value_count))
       swap_int(&(mygraph->ordering[i]), &(mygraph->ordering[j]));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5300c
cmpl $0x0, 0x10(%rbx)
jle 0x530a6
xorl %r14d, %r14d
cmpl $0x0, 0x10(%rbx)
jle 0x5309a
movl $0x4, %r15d
leaq (%r14,%r14,8), %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x40(%rbx), %rsi
movl (%rsi,%r14,4), %eax
cmpl (%rsi,%r13), %eax
jge 0x53086
movq 0x8(%rbx), %rax
movl 0x10(%rax,%r12,8), %ecx
cmpl (%rax,%r15,4), %ecx
jle 0x53086
leaq (%rsi,%r14,4), %rdi
addq %r13, %rsi
callq 0x395a3
incq %rbp
movslq 0x10(%rbx), %rax
addq $0x4, %r13
addq $0x12, %r15
cmpq %rax, %rbp
jl 0x5305d
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x53048
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/ordering.c
// Function: manual_ordering
void manual_ordering(bayesiangraphptr mygraph, int *given_ordering)
{
 /*!Created 01.06.2001*/
 int i;
 if (mygraph->ordering)
   safe_free(mygraph->ordering);
 for (i = 0; i < mygraph->nodecount; i++)
	  mygraph->ordering[i] = given_ordering[i];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x53324
callq 0x39194
cmpl $0x0, 0x10(%r14)
jle 0x53343
movq 0x40(%r14), %rax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
movslq 0x10(%r14), %rdx
cmpq %rdx, %rcx
jl 0x53331
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/ordering.c
// Function: find_nodes_before
int* find_nodes_before(bayesiangraphptr mygraph, int node)
{
 /*!Verilmis bir node icin orderingde ondan once gelen tum nodelari donduruyor*/
 /*!Last changed 01.06.2001*/
 int i = 0, where, *result = NULL;
 where = mygraph->ordering[i];
 while (where != node)
  {
   i++;
   result = alloc(result, i * sizeof(int), i);
   result[i - 1] = mygraph->ordering[i - 1];
   where = mygraph->ordering[i];
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rax
cmpl %esi, (%rax)
jne 0x5335e
xorl %eax, %eax
jmp 0x5339a
movl %esi, %ebx
movq %rdi, %r14
movl $0x4, %r15d
movl $0x1, %ebp
xorl %eax, %eax
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x390c8
movq 0x40(%r14), %rcx
movl -0x4(%rcx,%r15), %edx
movl %edx, -0x4(%rax,%r15)
leaq 0x4(%r15), %rdx
incl %ebp
cmpl %ebx, (%rcx,%r15)
movq %rdx, %r15
jne 0x53370
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/parameter.c
// Function: set_parameter_s
void set_parameter_s(char* name, char* value)
{
 /*!Last Changed 09.08.2007*/
 int index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == STRING_PARAMETER)
  {
   if (parameters[index].value.stringvalue != NULL)
     safe_free(parameters[index].value.stringvalue);
   parameters[index].value.stringvalue = strcopy(parameters[index].value.stringvalue, value);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x533c0
cmpl $-0x1, %eax
je 0x535ef
movq 0x7ef41(%rip), %rcx     # 0xd24f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x4, 0x8(%rcx,%r14)
jne 0x535ef
addq %r14, %rcx
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x535cf
callq 0x39194
movq 0x7ef1a(%rip), %rax     # 0xd24f0
movq 0x18(%rax,%r14), %rdi
movq %rbx, %rsi
callq 0x3a404
movq 0x7ef06(%rip), %rcx     # 0xd24f0
movq %rax, 0x18(%rcx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/parameter.c
// Function: set_parameter_l
void set_parameter_l(char* name, char* value, char* errormessage)
{
 /*!Last Changed 09.08.2007*/
 int i, index, val;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == LIST_PARAMETER)
  {
   val = listindex(value, parameters[index].listvalues, parameters[index].arraysize);
   if (val != -1)
     parameters[index].value.listvalue = val;
   else
    {
     printf(errormessage, value);
     printf(m1276);
     for (i = 0; i < parameters[index].arraysize; i++)
      {
       printf("%s", parameters[index].listvalues[i]);
       printf("\n");
      }     
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
callq 0x533c0
cmpl $-0x1, %eax
je 0x536e1
movq 0x7eeaa(%rip), %rcx     # 0xd24f0
movslq %eax, %r15
shlq $0x5, %r15
cmpl $0x3, 0x8(%rcx,%r15)
jne 0x536e1
addq %r15, %rcx
movq 0x10(%rcx), %rsi
movl 0xc(%rcx), %edx
movq %rbx, %rdi
callq 0x3a2c5
cmpl $-0x1, %eax
je 0x5367e
movq 0x7ee79(%rip), %rcx     # 0xd24f0
movl %eax, 0x18(%rcx,%r15)
jmp 0x536e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4030
leaq 0x54444(%rip), %rdi     # 0xa7ad6
callq 0x4090
movq 0x7ee52(%rip), %rax     # 0xd24f0
cmpl $0x0, 0xc(%rax,%r15)
jle 0x536e1
leaq 0x5184b(%rip), %rbx     # 0xa4ef8
xorl %r14d, %r14d
movq 0x10(%rax,%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movl $0xa, %edi
callq 0x40d0
incq %r14
movq 0x7ee19(%rip), %rax     # 0xd24f0
movslq 0xc(%rax,%r15), %rcx
cmpq %rcx, %r14
jl 0x536b0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/parameter.c
// Function: set_parameter_o
void set_parameter_o(char* name, char* value)
{
 /*!Last Changed 09.08.2007*/
 int index, val;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == ONOFF_PARAMETER)
  {
   val = listindex(value, onoff_type, 2);
   if (val != -1)
     parameters[index].value.onoffvalue = 1 - val;
   else
     printf(m1043);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x533c0
cmpl $-0x1, %eax
je 0x53769
movq 0x7edc2(%rip), %rcx     # 0xd24f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x2, 0x8(%rcx,%r14)
jne 0x53769
leaq 0x7e90c(%rip), %rsi     # 0xd2050
movq %rbx, %rdi
movl $0x2, %edx
callq 0x3a2c5
cmpl $-0x1, %eax
je 0x53771
movl $0x1, %ecx
subl %eax, %ecx
movq 0x7ed8c(%rip), %rax     # 0xd24f0
movl %ecx, 0x18(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5436f(%rip), %rdi     # 0xa7ae7
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/parameter.c
// Function: set_parameter_af
void set_parameter_af(char* name, char** values, int arraysize)
{
 /*!Last Changed 09.08.2007*/
 int i, index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == ARRAY_PARAMETER)
  {
   for (i = 0; i < parameters[index].arraysize && i < arraysize; i++)
     atof_check(values[i], &(((double *)(parameters[index].value.arrayvalue))[i]), -DBL_MAX, +DBL_MAX);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
callq 0x533c0
cmpl $-0x1, %eax
je 0x53842
movq 0x7ed1f(%rip), %rcx     # 0xd24f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x5, 0x8(%rcx,%r14)
jne 0x53842
testl %ebp, %ebp
jle 0x53842
movq 0x7ed05(%rip), %rax     # 0xd24f0
cmpl $0x0, 0xc(%rax,%r14)
jle 0x53842
movl %ebp, %r15d
movl $0x1, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13), %rdi
movq 0x18(%rax,%r14), %rsi
addq %r13, %rsi
movsd 0x54255(%rip), %xmm0    # 0xa7a68
movsd 0x54255(%rip), %xmm1    # 0xa7a70
callq 0x399fb
cmpq %r15, %r12
jae 0x53842
movq 0x7ecc4(%rip), %rax     # 0xd24f0
movslq 0xc(%rax,%r14), %rcx
addq $0x8, %r13
leaq 0x1(%r12), %rdx
cmpq %rcx, %r12
movq %rdx, %r12
jl 0x537ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/parameter.c
// Function: set_parameter_ai
void set_parameter_ai(char* name, char** values, int arraysize)
{
 /*!Last Changed 09.08.2007*/
 int i, index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == ARRAY_PARAMETER)
  {
   for (i = 0; i < parameters[index].arraysize && i < arraysize; i++)
     atoi_check(values[i], &(((int *)(parameters[index].value.arrayvalue))[i]), -INT_MAX, +INT_MAX);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
callq 0x533c0
cmpl $-0x1, %eax
je 0x538dd
movq 0x7ec7e(%rip), %rcx     # 0xd24f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x5, 0x8(%rcx,%r14)
jne 0x538dd
testl %ebp, %ebp
jle 0x538dd
movq 0x7ec64(%rip), %rax     # 0xd24f0
cmpl $0x0, 0xc(%rax,%r14)
jle 0x538dd
movl %ebp, %r15d
movl $0x1, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,2), %rdi
movq 0x18(%rax,%r14), %rsi
addq %r13, %rsi
movl $0x80000001, %edx       # imm = 0x80000001
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
callq 0x39980
cmpq %r15, %r12
jae 0x538dd
movq 0x7ec29(%rip), %rax     # 0xd24f0
movslq 0xc(%rax,%r14), %rcx
addq $0x4, %r13
leaq 0x1(%r12), %rdx
cmpq %rcx, %r12
movq %rdx, %r12
jl 0x538a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/parameter.c
// Function: free_program_parameters
void free_program_parameters()
{
 /*!Last Changed 08.08.2007*/
 int i, j;
 for (i = 0; i < parametercount; i++)
  {
   safe_free(parameters[i].name);
   switch (parameters[i].type)
    {
     case STRING_PARAMETER:safe_free(parameters[i].value.stringvalue);
                           break;
     case   LIST_PARAMETER:for (j = 0; j < parameters[i].arraysize; j++)
                             safe_free(parameters[i].listvalues[j]);
                           safe_free(parameters[i].listvalues);
                           break;
     case  ARRAY_PARAMETER:safe_free(parameters[i].value.arrayvalue);
                           break;
     default              :break;
    }
  }
 safe_free(parameters);
}

// Assembly:
cmpl $0x0, 0x7e7c9(%rip)     # 0xd24e8
jle 0x53dc2
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
movq 0x7e7bd(%rip), %rax     # 0xd24f0
movq %rbx, %r14
shlq $0x5, %r14
movq (%rax,%r14), %rdi
callq 0x39194
movq 0x7e7a6(%rip), %rax     # 0xd24f0
movl 0x8(%rax,%r14), %ecx
addq %r14, %rax
cmpl $0x5, %ecx
je 0x53d9e
cmpl $0x4, %ecx
je 0x53d9e
cmpl $0x3, %ecx
jne 0x53daa
movq 0x7e788(%rip), %rax     # 0xd24f0
cmpl $0x0, 0xc(%rax,%r14)
jle 0x53d95
xorl %r15d, %r15d
movq 0x10(%rax,%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x39194
incq %r15
movq 0x7e765(%rip), %rax     # 0xd24f0
movslq 0xc(%rax,%r14), %rcx
cmpq %rcx, %r15
jl 0x53d73
addq %r14, %rax
addq $0x10, %rax
jmp 0x53da2
addq $0x18, %rax
movq (%rax), %rdi
callq 0x39194
incq %rbx
movslq 0x7e734(%rip), %rax     # 0xd24e8
cmpq %rax, %rbx
jl 0x53d2c
popq %rbx
popq %r14
popq %r15
movq 0x7e727(%rip), %rdi     # 0xd24f0
jmp 0x39194
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/part.c
// Function: extract_best_leaf_from_partial_tree
Decisionnodeptr extract_best_leaf_from_partial_tree(Decisionnodeptr rootnode, int* bestscore)
{
 int i;
 Decisionnodeptr best = NULL, current;
 if (rootnode->featureno != LEAF_NODE)
  {
   if (current_dataset->features[rootnode->featureno].type == STRING)
    {
     for (i = 0; i < current_dataset->features[rootnode->featureno].valuecount; i++)
      {
       current = extract_best_leaf_from_partial_tree(&(rootnode->string[i]), bestscore);
       if (current)
         best = current;
      }
    }
   else
    {
     current = extract_best_leaf_from_partial_tree(rootnode->left, bestscore);
     if (current)
       best = current;
     current = extract_best_leaf_from_partial_tree(rootnode->right, bestscore);
     if (current)
       best = current;
    } 
  }
 else
   if (rootnode->expanded && rootnode->covered > *bestscore)
    {
     *bestscore = rootnode->covered;
     return rootnode;    
    }
 return best;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x30(%rdi), %rax
cmpq $-0x1, %rax
je 0x53e6a
leaq 0x7ea7e(%rip), %r12     # 0xd2870
movq (%r12), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
jne 0x53e8b
movq (%r12), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x0, 0x30f20(%rax,%rcx)
jle 0x53e86
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x10(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x53dd0
testq %rax, %rax
cmovneq %rax, %r15
incq %rbp
movq (%r12), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %rax
addq $0x160, %r13            # imm = 0x160
cmpq %rax, %rbp
jl 0x53e2c
jmp 0x53eac
cmpl $0x0, 0x130(%r14)
je 0x53e86
movl 0x84(%r14), %eax
cmpl (%rbx), %eax
jle 0x53e86
movl %eax, (%rbx)
movq %r14, %r15
jmp 0x53eac
xorl %r15d, %r15d
jmp 0x53eac
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x53dd0
movq %rax, %r15
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x53dd0
testq %rax, %rax
cmovneq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/part.c
// Function: all_children_expanded_and_are_leaves
BOOLEAN all_children_expanded_and_are_leaves(Decisionnodeptr rootnode)
{
 int i;
 if (current_dataset->features[rootnode->featureno].type == STRING)
  {
   for (i = 0; i < current_dataset->features[rootnode->featureno].valuecount; i++)
     if (rootnode->string[i].featureno != LEAF_NODE || !rootnode->string[i].expanded)
       return BOOLEAN_FALSE;
  }
 else
  {
   if (rootnode->left->featureno != LEAF_NODE || !rootnode->left->expanded)
     return BOOLEAN_FALSE;
   if (rootnode->right->featureno != LEAF_NODE || !rootnode->right->expanded)
     return BOOLEAN_FALSE;
  }
 return BOOLEAN_TRUE;
}

// Assembly:
leaq 0x7e990(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq 0x30(%rdi), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x1, 0x30f08(%rax,%rcx)
jne 0x53f36
addq $0x30f08, %rax          # imm = 0x30F08
movslq 0x18(%rax,%rcx), %rax
testq %rax, %rax
jle 0x53f5e
movq 0x10(%rdi), %rcx
imulq $0x160, %rax, %rdx      # imm = 0x160
xorl %eax, %eax
xorl %esi, %esi
cmpl $-0x1, 0x30(%rcx,%rsi)
jne 0x53f41
cmpl $0x0, 0x130(%rcx,%rsi)
je 0x53f41
addq $0x160, %rsi            # imm = 0x160
cmpq %rsi, %rdx
jne 0x53f17
jmp 0x53f5e
movq (%rdi), %rcx
xorl %eax, %eax
cmpl $-0x1, 0x30(%rcx)
je 0x53f42
retq
cmpl $0x0, 0x130(%rcx)
je 0x53f41
movq 0x8(%rdi), %rcx
cmpl $-0x1, 0x30(%rcx)
jne 0x53f41
cmpl $0x0, 0x130(%rcx)
je 0x53f41
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/part.c
// Function: subtree_replacement
BOOLEAN subtree_replacement(Decisionnodeptr rootnode, Decisionnodeptr prunenode, Instanceptr validation)
{
 int tmp, performancebefore, performance;
 Decisionnodeptr current;
 current = prunenode;
 while (current && all_children_expanded_and_are_leaves(current))
  {
   performancebefore = test_tree(rootnode, validation);
   tmp = current->featureno;
   current->featureno = LEAF_NODE;
   performance = test_tree(rootnode, validation);
   current->featureno = tmp;
   if (performance < performancebefore)
     return BOOLEAN_FALSE;
   accumulate_instances_tree(&(current->instances), current);
   free_children(current);
   make_leaf_node(current);
   current = current->parent;            
  }
 if (current)
   return BOOLEAN_TRUE;
 else
   return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
setne %bpl
je 0x53fdf
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %r14, %rdi
callq 0x53ed9
testl %eax, %eax
je 0x53fdf
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1ce72
movl %eax, %ebp
movl 0x30(%r14), %r12d
movl $0xffffffff, 0x30(%r14) # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1ce72
movl %r12d, 0x30(%r14)
cmpl %ebp, %eax
jl 0x53fec
leaq 0x20(%r14), %rdi
movq %r14, %rsi
callq 0x1c787
movq %r14, %rdi
callq 0x1d173
movq %r14, %rdi
callq 0x1c39c
movq 0x18(%r14), %r14
testq %r14, %r14
setne %bpl
jne 0x53f7e
movzbl %bpl, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x53fe3