LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x76c97
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
leaq -0x1c0(%rbp), %rdx
leaq -0x1c0(%rbp), %rcx
addq $0xc8, %rcx
movq -0x10(%rbp), %rax
movl 0x98(%rax), %r8d
callq 0xdd8e0
jmp 0x76cce
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x48(%rcx), %xmm0
leaq -0x1c0(%rbp), %rcx
leaq -0x1c0(%rbp), %r8
addq $0xc8, %r8
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
callq 0x6f960
leaq -0x1c0(%rbp), %rdi
movl $0x32, %esi
callq 0x50070
movl %eax, -0x1c8(%rbp)
leaq -0x1c0(%rbp), %rdi
addq $0xc8, %rdi
movl $0x32, %esi
callq 0x50070
movl %eax, -0x1cc(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x1c4(%rbp)
movl -0x1c4(%rbp), %eax
leaq 0x8eafe(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x76dd8
movslq -0x1c4(%rbp), %rax
movl -0x1c0(%rbp,%rax,4), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movslq -0x1c4(%rbp), %rax
movl -0xf8(%rbp,%rax,4), %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x1c4(%rbp), %eax
cmpl -0x1c8(%rbp), %eax
je 0x76d9e
movslq -0x1c4(%rbp), %rax
movl -0x1c0(%rbp,%rax,4), %ecx
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x1c4(%rbp), %eax
cmpl -0x1cc(%rbp), %eax
je 0x76dc2
movslq -0x1c4(%rbp), %rax
movl -0xf8(%rbp,%rax,4), %ecx
movq -0x30(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x76dc4
movl -0x1c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c4(%rbp)
jmp 0x76d35
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x50490
movl %eax, -0x38(%rbp)
cmpl $-0x1, -0x38(%rbp)
jne 0x76e3d
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
jmp 0x76f5e
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x76e64
jmp 0x76e49
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x76ec3
jmp 0x76e53
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x76efe
jmp 0x76f57
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x6bbd3(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x76e7f
jp 0x76e7f
jmp 0x76e90
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x6bba7(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x76eab
jp 0x76eab
jmp 0x76ebe
cmpl $0x3, -0x34(%rbp)
jne 0x76ebe
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59ea0
jmp 0x76f57
movq -0x28(%rbp), %rax
movl $0xfffffffe, 0x30(%rax) # imm = 0xFFFFFFFE
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x6bb69(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x76ee9
jp 0x76ee9
jmp 0x76efc
cmpl $0x3, -0x34(%rbp)
jne 0x76efc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59ea0
jmp 0x76f57
movq -0x28(%rbp), %rax
movl $0xfffffffd, 0x30(%rax) # imm = 0xFFFFFFFD
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x6bb2e(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x76f24
jp 0x76f24
jmp 0x76f35
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x77ec0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xdec70
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x77ebe
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, -0x4(%rbp)
jmp 0x78023
jmp 0x77f0a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %ecx
movsd -0x28(%rbp), %xmm0
leaq -0x1e8(%rbp), %rsi
leaq -0x1d8(%rbp), %rdx
callq 0x6fd20
cmpl $0x0, %eax
jne 0x77f08
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0x59ea0
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, -0x4(%rbp)
jmp 0x78023
jmp 0x77f0a
cmpl $0x0, -0x1c(%rbp)
jne 0x77f44
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movsd -0x1d0(%rbp), %xmm0
leaq -0x1c0(%rbp), %rdx
leaq -0x1c0(%rbp), %rcx
addq $0xc8, %rcx
movl $0x2, %r8d
callq 0xdd8e0
jmp 0x77f7b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movsd -0x1d8(%rbp), %xmm0
leaq -0x1c0(%rbp), %rcx
leaq -0x1c0(%rbp), %r8
addq $0xc8, %r8
movq -0x1e8(%rbp), %rsi
movq -0x1e0(%rbp), %rdx
callq 0x6f960
leaq -0x1c0(%rbp), %rdi
movl $0x32, %esi
callq 0x50070
movl %eax, -0x1c4(%rbp)
leaq -0x1c0(%rbp), %rdi
addq $0xc8, %rdi
movl $0x32, %esi
callq 0x50070
movl %eax, -0x1c8(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x77fdb
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
movsd -0x1d0(%rbp), %xmm0
movl -0x1c4(%rbp), %edx
movl -0x1c8(%rbp), %ecx
callq 0xdbac0
movl %eax, -0x4(%rbp)
jmp 0x78023
movq -0x18(%rbp), %rdi
movsd -0x1d8(%rbp), %xmm0
movl -0x1c4(%rbp), %ecx
movl -0x1c8(%rbp), %r8d
movq -0x1e8(%rbp), %rsi
movq -0x1e0(%rbp), %rdx
callq 0x6e0c0
movl %eax, -0x30(%rbp)
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0x59ea0
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsd %xmm0, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x4c, %eax
je 0x7809c
jmp 0x78055
movl -0x24(%rbp), %eax
subl $0x51, %eax
je 0x780b4
jmp 0x7805f
movl -0x24(%rbp), %eax
subl $0x55, %eax
je 0x78087
jmp 0x78069
movl -0x24(%rbp), %eax
subl $0x6c, %eax
je 0x7809c
jmp 0x78073
movl -0x24(%rbp), %eax
subl $0x71, %eax
je 0x780b4
jmp 0x7807d
movl -0x24(%rbp), %eax
subl $0x75, %eax
jne 0x780cc
jmp 0x78087
movq -0x10(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
xorl %esi, %esi
callq 0x76f70
movl %eax, -0x4(%rbp)
jmp 0x780e1
movq -0x10(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x76f70
movl %eax, -0x4(%rbp)
jmp 0x780e1
movq -0x10(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x76f70
movl %eax, -0x4(%rbp)
jmp 0x780e1
leaq 0x6f283(%rip), %rdi     # 0xe7356
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x781c7
movq -0x20(%rbp), %rax
leaq 0x6f390(%rip), %rcx     # 0xe74b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x77790
movl %eax, -0x4(%rbp)
jmp 0x781ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x77100
movl %eax, -0x4(%rbp)
jmp 0x781ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x77290
movl %eax, -0x4(%rbp)
jmp 0x781ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x77440
movl %eax, -0x4(%rbp)
jmp 0x781ce
jmp 0x781c7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
xorl %esi, %esi
callq 0x76f70
movl %eax, -0x4(%rbp)
jmp 0x781ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x76f70
movl %eax, -0x4(%rbp)
jmp 0x781ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x76f70
movl %eax, -0x4(%rbp)
jmp 0x781ce
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, 0x98(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29340
cmpl $0x0, %eax
jne 0x78219
movl $0x1, -0x4(%rbp)
jmp 0x7827c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x780f0
cmpl $0x0, %eax
jne 0x7823d
movq -0x10(%rbp), %rdi
callq 0x28a30
movl $0x1, -0x4(%rbp)
jmp 0x7827c
movq -0x10(%rbp), %rdi
callq 0x6f570
cmpl $0x0, %eax
jne 0x78254
movl $0x1, -0x4(%rbp)
jmp 0x7827c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x781e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x781e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x786a0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x787cc
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x787bc
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movslq -0x10(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x787ac
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x48, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jle 0x787ac
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x533d0
jmp 0x787ae
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x78723
jmp 0x787be
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7870c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x78d68
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x52e80
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x78da0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x78d6f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x78e41
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rsi
shlq $0x2, %rsi
movl -0x10(%rbp), %edx
callq 0x52d10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
jmp 0x78de0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/ordering.c
// Function: find_nodecount_before
int find_nodecount_before(bayesiangraphptr mygraph,int node)
{
 /*!Verilmis bir node icin orderingde ondan once gelen tum nodelarin sayisini donduruyor*/
 /*!Last changed 01.06.2001*/
 int count = 0, where;
 where = mygraph->ordering[count];
 while (where != node)
  {
   count++;
   where = mygraph->ordering[count];
  }
 return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x78e99
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
jmp 0x78e74
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/parameter.c
// Function: parameter_index
int parameter_index(char* name)
{
 /*!Last Changed 09.08.2007*/
 int i;
 for (i = 0; i < parametercount; i++)
   if (strIcmp(parameters[i].name, name) == 0)
     return i;
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x8c5fc(%rip), %eax     # 0x1054b8
jge 0x78ef6
movq 0x8c5fb(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0x78ee9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x78efd
jmp 0x78eeb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x78eb3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/parameter.c
// Function: get_parameter_i
int get_parameter_i(char* name)
{
 /*!Last Changed 09.08.2007*/
 int index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == INTEGER_PARAMETER)
   return parameters[index].value.intvalue;
 else
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x78f60
movq 0x8c58b(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x78f60
movq 0x8c573(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x78f67
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/parameter.c
// Function: get_parameter_f
double get_parameter_f(char* name)
{
 /*!Last Changed 09.08.2007*/
 int index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == FLOAT_PARAMETER)
   return parameters[index].value.floatvalue;
 else
   return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x79094
movq 0x8c45b(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
jne 0x79094
movq 0x8c443(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7909c
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/parameter.c
// Function: get_parameter_s
char* get_parameter_s(char* name)
{
 /*!Last Changed 09.08.2007*/
 int index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == STRING_PARAMETER)
   return parameters[index].value.stringvalue;
 else
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x791e2
movq 0x8c30b(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jne 0x791e2
movq 0x8c2f3(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x791ea
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x792aa
movq 0x8c293(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jne 0x792aa
movq 0x8c27b(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
je 0x79272
movq 0x8c262(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movq 0x8c247(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq 0x8c225(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/parameter.c
// Function: get_parameter_l
int get_parameter_l(char* name)
{
 /*!Last Changed 09.08.2007*/
 int index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == LIST_PARAMETER)
   return parameters[index].value.listvalue;
 else
   return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x79300
movq 0x8c1eb(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x3, 0x8(%rax)
jne 0x79300
movq 0x8c1d3(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x79307
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
je 0x79437
movq 0x8c17f(%rip), %rax     # 0x1054c0
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x3, 0x8(%rax)
jne 0x79437
movq -0x10(%rbp), %rdi
movq 0x8c15f(%rip), %rax     # 0x1054c0
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movq 0x8c149(%rip), %rax     # 0x1054c0
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0xc(%rax), %edx
callq 0x54910
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x793b0
movl -0x24(%rbp), %ecx
movq 0x8c123(%rip), %rax     # 0x1054c0
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
jmp 0x79435
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb $0x0, %al
callq 0x4030
leaq 0x6e1f8(%rip), %rdi     # 0xe75be
movb $0x0, %al
callq 0x4030
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x8c0e2(%rip), %rcx     # 0x1054c0
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jge 0x79433
movq 0x8c0cb(%rip), %rax     # 0x1054c0
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6b685(%rip), %rdi     # 0xe4a98
movb $0x0, %al
callq 0x4030
leaq 0x6c91a(%rip), %rdi     # 0xe5d3b
movb $0x0, %al
callq 0x4030
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x793d4
jmp 0x79435
jmp 0x79437
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/parameter.c
// Function: get_parameter_o
int get_parameter_o(char* name)
{
 /*!Last Changed 09.08.2007*/
 int index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == ONOFF_PARAMETER)
   return parameters[index].value.onoffvalue;
 else
   return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x79490
movq 0x8c05b(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jne 0x79490
movq 0x8c043(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x79497
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x79527
movq 0x8bff7(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jne 0x79527
movq -0x10(%rbp), %rdi
leaq 0x8bb3b(%rip), %rsi     # 0x105020
movl $0x2, %edx
callq 0x54910
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x79517
movl $0x1, %ecx
subl -0x18(%rbp), %ecx
movq 0x8bfb9(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
jmp 0x79525
leaq 0x6e0b2(%rip), %rdi     # 0xe75d0
movb $0x0, %al
callq 0x4030
jmp 0x79527
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/parameter.c
// Function: get_parameter_a
void* get_parameter_a(char* name)
{
 /*!Last Changed 09.08.2007*/
 int index;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == ARRAY_PARAMETER)
   return parameters[index].value.arrayvalue;
 else
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x79582
movq 0x8bf6b(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x5, 0x8(%rax)
jne 0x79582
movq 0x8bf53(%rip), %rax     # 0x1054c0
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7958a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x79672
movq 0x8bef0(%rip), %rax     # 0x1054c0
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x5, 0x8(%rax)
jne 0x79672
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq 0x8beca(%rip), %rdx     # 0x1054c0
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, -0x1d(%rbp)
jge 0x79617
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x79620
jmp 0x79670
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8be8d(%rip), %rax     # 0x1054c0
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movsd 0x6df1b(%rip), %xmm0    # 0xe7570
movsd 0x6df1b(%rip), %xmm1    # 0xe7578
callq 0x53d70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x795ec
jmp 0x79672
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x78ea0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x79749
movq 0x8be10(%rip), %rax     # 0x1054c0
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x5, 0x8(%rax)
jne 0x79749
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq 0x8bdea(%rip), %rdx     # 0x1054c0
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, -0x1d(%rbp)
jge 0x796f7
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x79700
jmp 0x79747
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8bdad(%rip), %rax     # 0x1054c0
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl $0x80000001, %edx       # imm = 0x80000001
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
callq 0x53cc0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x796cc
jmp 0x79749
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x8b6d0(%rip), %eax     # 0x1054b8
jge 0x79ef9
movq 0x8b6cb(%rip), %rax     # 0x1054c0
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rdi
callq 0x52e80
movq 0x8b6b3(%rip), %rax     # 0x1054c0
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
movl 0x8(%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
subl $0x3, %eax
je 0x79e5e
jmp 0x79e23
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x79e3e
jmp 0x79e2d
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x79eca
jmp 0x79ee7
movq 0x8b67b(%rip), %rax     # 0x1054c0
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x52e80
jmp 0x79ee9
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq 0x8b651(%rip), %rcx     # 0x1054c0
movslq -0x4(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jge 0x79ead
movq 0x8b63a(%rip), %rax     # 0x1054c0
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x79e65
movq 0x8b60c(%rip), %rax     # 0x1054c0
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x52e80
jmp 0x79ee9
movq 0x8b5ef(%rip), %rax     # 0x1054c0
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x52e80
jmp 0x79ee9
jmp 0x79ee9
jmp 0x79eeb
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x79ddf
movq 0x8b5c0(%rip), %rdi     # 0x1054c0
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
je 0x7a01b
leaq 0x8b903(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x79fd0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x8b8d2(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movq -0x10(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x79fce
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x79f10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x79fc1
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x79fc3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x79f64
jmp 0x7a019
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x79f10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x79ff3
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x79f10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7a017
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x7a019
jmp 0x7a056
movq -0x10(%rbp), %rax
cmpl $0x0, 0x130(%rax)
je 0x7a054
movq -0x10(%rbp), %rax
movl 0x84(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x7a054
movq -0x10(%rbp), %rax
movl 0x84(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7a05e
jmp 0x7a056
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x8b781(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x7a168
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x8b74c(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movq -0x10(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x7a166
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x160, %rcx, %rcx      # imm = 0x160
addq %rcx, %rax
cmpl $-0x1, 0x30(%rax)
jne 0x7a150
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x160, %rcx, %rcx      # imm = 0x160
addq %rcx, %rax
cmpl $0x0, 0x130(%rax)
jne 0x7a159
movl $0x0, -0x4(%rbp)
jmp 0x7a1bf
jmp 0x7a15b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7a0ea
jmp 0x7a1b8
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x7a185
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x130(%rax)
jne 0x7a18e
movl $0x0, -0x4(%rbp)
jmp 0x7a1bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x7a1ad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x130(%rax)
jne 0x7a1b6
movl $0x0, -0x4(%rbp)
jmp 0x7a1bf
jmp 0x7a1b8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
je 0x7a20a
movq -0x38(%rbp), %rdi
callq 0x7a0b0
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x7a216
jmp 0x7a29a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29e30
movl %eax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29e30
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x7a266
movl $0x0, -0x4(%rbp)
jmp 0x7a2b1
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq -0x38(%rbp), %rsi
callq 0x29160
movq -0x38(%rbp), %rdi
callq 0x2a250
movq -0x38(%rbp), %rdi
callq 0x28a30
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x7a1ec
cmpq $0x0, -0x38(%rbp)
je 0x7a2aa
movl $0x1, -0x4(%rbp)
jmp 0x7a2b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/part.c
// Function: learn_ruleset_part
Ruleset learn_ruleset_part(Instanceptr* instances, Instanceptr* cvdata)
{
 int* counts;
 Instanceptr covered = NULL, cvcovered = NULL;
 Ruleset result;
 Decisionruleptr newrule;
 Decisionnodeptr rootnode;
 empty_ruleset(&result);
 counts = find_class_counts(*instances);
 result.defaultclass = find_max_in_list(counts, current_dataset->classno);
 safe_free(counts);
 while (data_size(*instances) > 0)
  {
   rootnode = createnewnode(NULL, 1);
   rootnode->instances = *instances;
   create_partial_tree(rootnode, *cvdata);
   newrule = extract_rule_from_partial_tree(rootnode);
   add_rule(&result, newrule);
   *instances = NULL;
   accumulate_instances_tree(instances, rootnode);
   deallocate_tree(rootnode);
   safe_free(rootnode);
   remove_covered(instances, &covered, newrule);
   remove_covered(cvdata, &cvcovered, newrule);
  }
 merge_instancelist(instances, covered);
 merge_instancelist(cvdata, cvcovered);
 return result; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
callq 0xade30
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x183a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x8b2d5(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50070
movq -0x40(%rbp), %rdi
movl %eax, 0x14(%rdi)
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x449f0
cmpl $0x0, %eax
jle 0x7a637
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7a2c0
movq -0x38(%rbp), %rdi
callq 0x7a070
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0xaea30
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x29160
movq -0x38(%rbp), %rdi
callq 0x2a030
movq -0x38(%rbp), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0xdb5b0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0xdb5b0
jmp 0x7a586
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44f40
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x44f40
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)