LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x4cff9(%rip), %rdi     # 0x98c18
callq 0x4cd35
movl %eax, %ebp
movq 0x20(%rbx), %rdi
callq 0x2c3cc
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 0x4b77a
xorl %r12d, %r12d
testl %ebp, %ebp
movl %ebp, %r13d
cmovlel %r12d, %r13d
cmpq %r12, %r13
je 0x4bd0b
movsd 0x20(%rsp,%r12,8), %xmm0
ucomisd 0x4a13a(%rip), %xmm0    # 0x95db0
jne 0x4bc7e
jnp 0x4bd03
cmpl $0x2, %r12d
je 0x4bcc7
cmpl $0x1, %r12d
je 0x4bca9
testl %r12d, %r12d
jne 0x4bcea
movq 0x20(%rbx), %rdi
movl 0x30(%rbx), %esi
movsd 0x28(%rbx), %xmm0
movl 0x2c(%r14), %edx
callq 0x933e6
pushq $0x2
popq %rax
jmp 0x4bcf0
movsd 0x48(%rbx), %xmm0
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
callq 0x46dc7
movl 0x90(%rbx), %eax
jmp 0x4bce6
movq 0x20(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x46dc7
movl 0x94(%rbx), %eax
incl %eax
jmp 0x4bcf0
xorpd %xmm0, %xmm0
xorl %eax, %eax
cvtsi2sd %eax, %xmm1
movl %r15d, %edi
callq 0x40fa5
movsd %xmm0, 0x20(%rsp,%r12,8)
incq %r12
jmp 0x4bc5e
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %r8d
callq 0x4b945
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testl %edx, %edx
je 0x4c492
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0x46e18
testl %eax, %eax
je 0x4c523
movq (%r15), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0xe8(%rsp), %r8
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x46bb8
jmp 0x4c4cc
movq (%r15), %rdi
leaq 0x18(%rsp), %rsi
callq 0x92b17
cmpl $-0x1, %eax
je 0x4c531
movl %eax, %r14d
movq (%r15), %rdi
movsd 0x18(%rsp), %xmm0
leaq 0xe8(%rsp), %rcx
leaq 0x20(%rsp), %rdx
pushq $0x2
popq %r8
movl %eax, %esi
callq 0x91c39
leaq 0x20(%rsp), %rdi
pushq $0x32
popq %r12
movl %r12d, %esi
callq 0x336b5
movl %eax, %r15d
leaq 0xe8(%rsp), %rdi
movl %r12d, %esi
callq 0x336b5
testl %ebp, %ebp
je 0x4c53b
movsd 0x10(%rsp), %xmm0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r15d, %ecx
movl %eax, %r8d
callq 0x45e3a
movl %eax, %ebx
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3929f
jmp 0x4c553
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3929f
movq %rbx, %rdi
callq 0x2c3cc
jmp 0x4c551
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x90888
movl %eax, %ebx
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x18(%rsi), %eax
cmpq $0x7, %rax
ja 0x4c5df
leaq 0x4e30f(%rip), %rcx     # 0x9a8e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x4bf7f
xorl %eax, %eax
retq
movsd 0x20(%rsi), %xmm0
pushq $-0x2
jmp 0x4c5f7
jmp 0x4bad9
movsd 0x20(%rsi), %xmm0
pushq $-0x3
popq %rsi
jmp 0x4ba38
jmp 0x4bc04
jmp 0x4bd3a
movsd 0x20(%rsi), %xmm0
xorl %esi, %esi
jmp 0x4ba38
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2, 0x98(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1abee
testl %eax, %eax
je 0x4c66a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c5c1
testl %eax, %eax
je 0x4c662
movq %rbx, %rdi
callq 0x4692e
testl %eax, %eax
je 0x4c66a
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4c613
movq 0x8(%rbx), %rbx
jmp 0x4c61d
movq %rbx, %rdi
callq 0x1a6ac
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x10(%rdi), %eax
decl %eax
xorl %ebx, %ebx
cmpl %eax, 0x20(%rdi)
je 0x4c7a1
movq %rdi, %r14
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x35c7f
cltd
idivl 0x20(%r14)
movl %edx, %ebp
leaq 0x80e18(%rip), %r13     # 0xcd4c8
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x23f34
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %rsp, %r15
leaq 0x14(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rcx
movq %r12, %r8
callq 0x47518
movslq (%r15), %rax
imulq $0x48, %rax, %rdi
addq 0x8(%r14), %rdi
movl (%r12), %esi
callq 0x4768d
movq 0x8(%r14), %rax
movslq (%r15), %rcx
imulq $0x48, %rcx, %rcx
movq 0x38(%rax,%rcx), %rdi
movl 0x28(%rax,%rcx), %esi
callq 0x34fc3
movl (%r15), %esi
movq %r14, %rdi
callq 0x48183
movq %r14, %rdi
callq 0x47b1e
testl %eax, %eax
je 0x4c744
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x23f34
ucomisd 0x8(%rsp), %xmm0
jbe 0x4c744
pushq $0x1
popq %rbx
jmp 0x4c7a1
movq 0x8(%r14), %rax
movslq (%rsp), %rcx
imulq $0x48, %rcx, %rcx
movq 0x38(%rax,%rcx), %rdi
movl 0x28(%rax,%rcx), %esi
callq 0x34fc3
movslq (%rsp), %rax
imulq $0x48, %rax, %rsi
addq 0x8(%r14), %rsi
movl 0x4(%rsp), %edx
movq %r14, %rdi
callq 0x476d6
movq %r14, %rdi
callq 0x47603
movslq (%rsp), %rax
imulq $0x48, %rax, %rsi
addq 0x8(%r14), %rsi
movl 0x4(%rsp), %edx
movq %r14, %rdi
callq 0x47654
movl (%rsp), %esi
movq %r14, %rdi
callq 0x48183
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x4c960
movl 0x10(%rbx), %eax
xorl %r14d, %r14d
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x4c9f3
imulq $0x48, %r14, %r12
pushq $0x4
popq %r13
xorl %ebp, %ebp
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x4c9ee
movq 0x40(%rbx), %rsi
movl (%rsi,%r14,4), %ecx
cmpl (%rsi,%rbp), %ecx
jge 0x4c9e1
movq 0x8(%rbx), %rcx
movl 0x10(%rcx,%r12), %edx
cmpl (%rcx,%r13,4), %edx
jle 0x4c9e1
leaq (%rsi,%r14,4), %rdi
addq %rbp, %rsi
callq 0x3537f
movl 0x10(%rbx), %eax
incq %r15
addq $0x4, %rbp
addq $0x12, %r13
jmp 0x4c9ae
incq %r14
jmp 0x4c999
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4cc5e
callq 0x34ff7
xorl %eax, %eax
movslq 0x10(%r14), %rcx
cmpq %rcx, %rax
jge 0x4cc78
movl (%rbx,%rax,4), %ecx
movq 0x40(%r14), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
jmp 0x4cc60
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
movq 0x40(%rdi), %rcx
pushq $0x4
popq %r15
pushq $0x1
popq %rbp
xorl %eax, %eax
cmpl %ebx, (%rcx)
je 0x4ccc3
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x34f30
movq 0x40(%r14), %rcx
movl -0x4(%rcx,%r15), %edx
addq %r15, %rcx
movl %edx, -0x4(%rax,%r15)
addq $0x4, %r15
incl %ebp
jmp 0x4cc99
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4cce4
cmpl $-0x1, %eax
je 0x4cf09
movq 0x80628(%rip), %rcx     # 0xcd4f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x4, 0x8(%rcx,%r14)
jne 0x4cf09
leaq (%rcx,%r14), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x4cef0
callq 0x34ff7
movq 0x80600(%rip), %rcx     # 0xcd4f0
movq 0x18(%rcx,%r14), %rdi
movq %rbx, %rsi
callq 0x3604c
movq 0x805ec(%rip), %rcx     # 0xcd4f0
movq %rax, 0x18(%rcx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
callq 0x4cce4
cmpl $-0x1, %eax
je 0x4cf8e
movq 0x80594(%rip), %rcx     # 0xcd4f0
movslq %eax, %r15
shlq $0x5, %r15
cmpl $0x3, 0x8(%rcx,%r15)
jne 0x4cf8e
addq %r15, %rcx
movq 0x10(%rcx), %rsi
movl 0xc(%rcx), %edx
movq %rbx, %rdi
callq 0x35f17
cmpl $-0x1, %eax
je 0x4cf99
movq 0x80567(%rip), %rcx     # 0xcd4f0
movl %eax, 0x18(%rcx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4030
leaq 0x4db09(%rip), %rdi     # 0x9aab6
callq 0x4090
leaq 0x4af17(%rip), %rbx     # 0x97ed0
pushq $0xa
popq %rbp
xorl %r14d, %r14d
movq 0x8052a(%rip), %rax     # 0xcd4f0
movslq 0xc(%rax,%r15), %rcx
cmpq %rcx, %r14
jge 0x4cf8e
addq %r15, %rax
movq 0x10(%rax), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movl %ebp, %edi
callq 0x40d0
incq %r14
jmp 0x4cfbf
// File: /workspace/github_c_makefile_star2_O2/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 0x4cce4
cmpl $-0x1, %eax
je 0x4d06d
movq 0x804ba(%rip), %rcx     # 0xcd4f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x2, 0x8(%rcx,%r14)
jne 0x4d06d
leaq 0x80004(%rip), %rsi     # 0xcd050
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x35f17
cmpl $-0x1, %eax
je 0x4d075
pushq $0x1
popq %rcx
subl %eax, %ecx
movq 0x80488(%rip), %rax     # 0xcd4f0
movl %ecx, 0x18(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4da4b(%rip), %rdi     # 0x9aac7
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/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 0x4cce4
cmpl $-0x1, %eax
je 0x4d12f
movq 0x8041b(%rip), %rcx     # 0xcd4f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x5, 0x8(%rcx,%r14)
jne 0x4d12f
movslq %ebp, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r15, %r13
jge 0x4d12f
movslq 0xc(%rcx,%r14), %rax
cmpq %rax, %r13
jge 0x4d12f
addq %r14, %rcx
movq (%rbx,%r12), %rdi
movq 0x18(%rcx), %rsi
addq %r12, %rsi
movsd 0x4d936(%rip), %xmm0    # 0x9aa48
movsd 0x4d936(%rip), %xmm1    # 0x9aa50
callq 0x3578f
incq %r13
movq 0x803c7(%rip), %rcx     # 0xcd4f0
addq $0x8, %r12
jmp 0x4d0ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4cce4
cmpl $-0x1, %eax
je 0x4d1b3
movq 0x80391(%rip), %rcx     # 0xcd4f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x5, 0x8(%rcx,%r14)
jne 0x4d1b3
movslq %ebp, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r15, %r13
jge 0x4d1b3
movslq 0xc(%rcx,%r14), %rax
cmpq %rax, %r13
jge 0x4d1b3
addq %r14, %rcx
movq (%rbx,%r12,2), %rdi
movq 0x18(%rcx), %rsi
addq %r12, %rsi
movl $0x80000001, %edx       # imm = 0x80000001
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
callq 0x35716
incq %r13
movq 0x80343(%rip), %rcx     # 0xcd4f0
addq $0x4, %r12
jmp 0x4d177
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
movslq 0x7ff0f(%rip), %rax     # 0xcd4e8
movq 0x7ff10(%rip), %rdi     # 0xcd4f0
cmpq %rax, %rbx
jge 0x4d651
movq %rbx, %r14
shlq $0x5, %r14
movq (%rdi,%r14), %rdi
callq 0x34ff7
movq 0x7fef4(%rip), %rcx     # 0xcd4f0
leaq (%rcx,%r14), %rax
movl 0x8(%rcx,%r14), %edx
cmpl $0x5, %edx
je 0x4d640
cmpl $0x4, %edx
je 0x4d640
cmpl $0x3, %edx
jne 0x4d64c
xorl %r15d, %r15d
leaq (%rcx,%r14), %rax
addq $0x10, %rax
movslq -0x4(%rax), %rcx
cmpq %rcx, %r15
jge 0x4d644
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
callq 0x34ff7
incq %r15
movq 0x7feb2(%rip), %rcx     # 0xcd4f0
jmp 0x4d617
addq $0x18, %rax
movq (%rax), %rdi
callq 0x34ff7
incq %rbx
jmp 0x4d5d2
popq %rbx
popq %r14
popq %r15
jmp 0x34ff7
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movslq 0x30(%rdi), %rax
cmpq $-0x1, %rax
je 0x4d6d8
leaq 0x801f2(%rip), %r15     # 0xcd870
movq (%r15), %rcx
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rdx)
jne 0x4d6f6
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r13d, %r13d
cltq
imulq $0x340, %rax, %rax      # imm = 0x340
movslq 0x30f20(%rcx,%rax), %rax
cmpq %rax, %rbp
jge 0x4d6f1
movq 0x10(%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0x4d65c
testq %rax, %rax
cmovneq %rax, %r13
incq %rbp
movq (%r15), %rcx
movl 0x30(%rbx), %eax
addq $0x160, %r12            # imm = 0x160
jmp 0x4d69a
cmpl $0x0, 0x130(%rbx)
je 0x4d71c
movl 0x84(%rbx), %eax
cmpl (%r14), %eax
jle 0x4d71c
movl %eax, (%r14)
jmp 0x4d71e
movq %r13, %rbx
jmp 0x4d71e
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4d65c
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4d65c
testq %rax, %rax
cmovneq %rax, %r15
movq %r15, %rbx
jmp 0x4d71e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x80121(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq 0x30(%rdi), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x1, 0x30f08(%rax,%rcx)
jne 0x4d7af
addq $0x30f08, %rax          # imm = 0x30F08
movl 0x18(%rax,%rcx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
imulq $0x160, %rax, %rdx      # imm = 0x160
addq $0x160, %rdx            # imm = 0x160
xorl %eax, %eax
leaq 0x160(%rcx), %rsi
cmpq %rsi, %rdx
je 0x4d7d6
movq 0x10(%rdi), %r8
cmpl $-0x1, 0x30(%r8,%rcx)
jne 0x4d7ae
cmpl $0x0, 0x130(%r8,%rcx)
movq %rsi, %rcx
jne 0x4d788
retq
movq (%rdi), %rcx
xorl %eax, %eax
cmpl $-0x1, 0x30(%rcx)
jne 0x4d7ae
cmpl $0x0, 0x130(%rcx)
je 0x4d7ae
movq 0x8(%rdi), %rcx
cmpl $-0x1, 0x30(%rcx)
jne 0x4d7ae
cmpl $0x0, 0x130(%rcx)
je 0x4d7ae
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rbx, %rbx
je 0x4d846
movq %rbx, %rdi
callq 0x4d748
testl %eax, %eax
je 0x4d846
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b165
movl %eax, %ebp
movl 0x30(%rbx), %r12d
orl $-0x1, 0x30(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b165
movl %r12d, 0x30(%rbx)
cmpl %ebp, %eax
jl 0x4d850
leaq 0x20(%rbx), %rdi
movq %rbx, %rsi
callq 0x1aad3
movq %rbx, %rdi
callq 0x1b42e
movq %rbx, %rdi
callq 0x1a6ac
movq 0x18(%rbx), %rbx
jmp 0x4d7eb
xorl %eax, %eax
testq %rbx, %rbx
setne %al
jmp 0x4d852
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
callq 0x71c9d
movq (%r15), %rdi
callq 0x108c8
movq %rax, %rbp
leaq 0x7fe1d(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %rbp, %rdi
callq 0x336b5
movl %eax, 0x14(%rbx)
movq %rbp, %rdi
callq 0x34ff7
pushq $0x1
popq %rbp
movq (%r15), %rdi
callq 0x2c3cc
testl %eax, %eax
jle 0x4daf4
xorl %edi, %edi
movl %ebp, %esi
callq 0x1ac98
movq %rax, %r12
movq (%r15), %rax
movq %rax, 0x20(%r12)
movq (%r14), %rsi
movq %r12, %rdi
callq 0x4d85b
movq %r12, %rdi
callq 0x4d730
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7228a
andq $0x0, (%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1aad3
movq %r12, %rdi
callq 0x1b2aa
movq %r12, %rdi
callq 0x34ff7
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x90582
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x90582
jmp 0x4da6f
movq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x2c6e4
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2c6e4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/partition.c
// Function: get_two_class_partition_for_one_vs_all
Partition get_two_class_partition_for_one_vs_all(Datasetptr d, int positive)
{
 /*!Last Changed 18.02.2008*/
 Partition result;
 int i;
 result.classes = (int *)safemalloc(d->classno * sizeof(int), "get_two_class_partition_for_one_vs_all", 3);
 for (i = 0; i < d->classno; i++)
   result.classes[i] = i;
 result.count = d->classno;
 result.assignments = (int *)safemalloc(d->classno * sizeof(int), "get_two_class_partition_for_one_vs_all", 7);
 for (i = 0; i < d->classno; i++)
   if (i != positive)
     result.assignments[i] = RIGHT;
   else
     result.assignments[i] = LEFT;
 return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x10(%rsi), %rdi
shlq $0x2, %rdi
leaq 0x4cfba(%rip), %rsi     # 0x9aaf5
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, (%rbx)
xorl %ecx, %ecx
movl 0x10(%r14), %edx
movslq %edx, %rdi
cmpq %rdi, %rcx
jge 0x4db5c
movl %ecx, (%rax,%rcx,4)
incq %rcx
jmp 0x4db48
movl %edi, 0x10(%rbx)
shlq $0x2, %rdi
leaq 0x4cf8b(%rip), %rsi     # 0x9aaf5
pushq $0x7
popq %rdx
callq 0x34f59
movq %rax, 0x8(%rbx)
movl %ebp, %ecx
xorl %edx, %edx
movslq 0x10(%r14), %rsi
cmpq %rsi, %rdx
jge 0x4db94
xorl %esi, %esi
cmpq %rdx, %rcx
setne %sil
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x4db7a
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/partition.c
// Function: get_two_class_partition
Partition get_two_class_partition()
{
	/*!Last Changed 21.06.2005*/
 Partition result;
 result.classes = (int *)safemalloc(2 * sizeof(int), "get_initial_partition", 2);
	result.classes[0] = 0;
	result.classes[1] = 1;
 result.count = 2;
 result.assignments = (int *)safemalloc(2 * sizeof(int), "get_initial_partition", 6);
 result.assignments[0] = LEFT;
 result.assignments[1] = RIGHT;
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x49d24(%rip), %r14     # 0x978d2
pushq $0x8
popq %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x34f59
movq %rax, (%rbx)
movabsq $0x100000000, %r12      # imm = 0x100000000
movq %r12, (%rax)
movl $0x2, 0x10(%rbx)
pushq $0x6
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x34f59
movq %rax, 0x8(%rbx)
movq %r12, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/partition.c
// Function: all_same_side
BOOLEAN all_same_side(Partition p)
{
/*!Last Changed 16.04.2003*/
	int i, sum = 0;
	for (i = 0; i < p.count; i++)
		 sum += p.assignments[i];
	if ((sum == p.count) || (sum == 0))
		 return BOOLEAN_TRUE;
	return BOOLEAN_FALSE;
}

// Assembly:
movl 0x18(%rsp), %eax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
xorl %edi, %edi
cmpq %rdx, %rsi
je 0x4dc1f
addl (%rcx,%rdx,4), %edi
incq %rdx
jmp 0x4dc12
cmpl %eax, %edi
sete %al
testl %edi, %edi
sete %cl
orb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/partition.c
// Function: find_class_assignments
int* find_class_assignments(Partition p)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 16.03.2003*/
	int *classassignments, max = -1, i;
 for (i = 0; i < p.count; i++)
   if (p.classes[i] > max)
     max = p.classes[i];
 classassignments = (int *) safemalloc((max + 1) * sizeof(int), "find_class_assignments", 5);
 for (i = 0; i < p.count; i++)
   classassignments[p.classes[i]] = p.assignments[i];
	return classassignments;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x20(%rsp), %r15
movl 0x10(%r15), %ebx
movq (%r15), %r14
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
pushq $-0x1
popq %rdi
cmpq %rax, %rbx
je 0x4dc5d
movl (%r14,%rax,4), %ecx
cmpl %edi, %ecx
cmovgl %ecx, %edi
incq %rax
jmp 0x4dc4a
incl %edi
shlq $0x2, %rdi
leaq 0x4ceb2(%rip), %rsi     # 0x9ab1c
pushq $0x5
popq %rdx
callq 0x34f59
movq 0x8(%r15), %rcx
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x4dc8c
movl (%rcx,%rdx,4), %esi
movslq (%r14,%rdx,4), %rdi
movl %esi, (%rax,%rdi,4)
incq %rdx
jmp 0x4dc78
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/partition.c
// Function: increment_partition
void increment_partition(Partition* p)
{
/*!Last Changed 04.02.2003*/
	int i = (*p).count - 1;
	while (i >= 0)
	{
		(*p).assignments[i] = 1 - (*p).assignments[i];
		if ((*p).assignments[i] == LEFT)
			 break;
  else
		  i--;
	}
}

// Assembly:
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0x4dcb1
movq 0x8(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %edx
leal -0x1(%rdx), %esi
negl %esi
movl %esi, -0x4(%rcx,%rax,4)
decq %rax
decl %edx
jne 0x4dc95
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/partition.c
// Function: create_copy
Partition create_copy(Partition p)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 26.01.2003*/
 Partition result;
 int i;
 result.count = p.count;
 result.assignments = (int *)safemalloc((p.count)*sizeof(int), "create_copy", 4);
 for (i = 0; i < p.count; i++)
   result.assignments[i] = p.assignments[i];
 result.classes = (int *)safemalloc(p.count*sizeof(int), "create_copy", 7);
 for (i = 0; i<p.count; i++)
   result.classes[i] = p.classes[i];
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movslq 0x10(%r15), %r13
movl %r13d, 0x10(%rdi)
movq %r13, %r14
shlq $0x2, %r14
leaq 0x4ce5a(%rip), %rsi     # 0x9ab33
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x34f59
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rcx
xorl %edx, %edx
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
cmpq %rdx, %r12
je 0x4dd0b
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x4dcfb
leaq 0x4ce21(%rip), %rsi     # 0x9ab33
pushq $0x7
popq %rdx
movq %r14, %rdi
callq 0x34f59
movq %rax, (%rbx)
movq (%r15), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0x4dd35
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x4dd25
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/perceptron.c
// Function: softmax
void softmax(double *myarray, int size)
{
 int i;
 double sum = 0.0;
 for (i = 0; i < size; i++)
  {
   myarray[i] = safeexp(myarray[i]);
   sum += myarray[i];
  }
 for (i = 0; i < size; i++)
   myarray[i] /= sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
xorpd %xmm1, %xmm1
cmpq %r15, %rbx
je 0x4ddc2
movsd (%r14,%r15,8), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x34d50
movsd 0x8(%rsp), %xmm1
movsd %xmm0, (%r14,%r15,8)
addsd %xmm0, %xmm1
incq %r15
jmp 0x4dd97
xorl %eax, %eax
cmpq %rax, %rbx
je 0x4ddde
movsd (%r14,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0x4ddc4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/perceptron.c
// Function: two_dimensional_initialize
double **two_dimensional_initialize(int dim1, int dim2, double constant)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 int i,j;
 double **myarray;
 myarray = (double **)safemalloc_2d(sizeof(double *), sizeof(double), dim1, dim2, "two_dimensional_initialize", 3);
 for (i = 0; i < dim1; i++)
   for (j = 0; j < dim2; j++)
     myarray[i][j] = constant * ((double) produce_random_value(-1, 1));
 return myarray;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movl %edi, %r14d
leaq 0x4cd38(%rip), %r8      # 0x9ab3f
pushq $0x8
popq %rdi
pushq $0x3
popq %r9
movq %rdi, %rsi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x351c3
movq %rax, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
testl %r14d, %r14d
cmovlel %r12d, %r14d
cmpq %r14, %r12
je 0x4de6a
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x4de65
movsd 0x47f6d(%rip), %xmm0    # 0x95db0
movsd 0x476d5(%rip), %xmm1    # 0x95520
callq 0x35cae
mulsd 0x8(%rsp), %xmm0
movq (%r15,%r12,8), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x4de36
incq %r12
jmp 0x4de2e
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/perceptron.c
// Function: one_dimensional_initialize
double *one_dimensional_initialize(int dim, double constant)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 int i;
 double *myarray;
 myarray = safemalloc(dim*sizeof(double), "one_dimensional_initialize", 3);
 for (i = 0; i < dim; i++)
   myarray[i] = constant * ((double) produce_random_value(-1, 1));
 return myarray;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movslq %edi, %r14
leaq (,%r14,8), %rdi
leaq 0x4ccbe(%rip), %rsi     # 0x9ab5a
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %rbx
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x4dedc
movsd 0x47ef2(%rip), %xmm0    # 0x95db0
movsd 0x4765a(%rip), %xmm1    # 0x95520
callq 0x35cae
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx,%r15,8)
incq %r15
jmp 0x4deb1
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/plot.c
// Function: solve_sigmoid
void solve_sigmoid(double* observations[2], int obscount, double* besta, double* bestb)
{
 /*!Last Changed 27.10.2004*/
 int i, j, k;
 double sum, a, b, adiff, bdiff, power, bestsum = +LONG_MAX;
 adiff = 10.0 / DIVISIONS;
 bdiff = 10.0 / DIVISIONS;
 for (i = 0; i < DIVISIONS; i++)
   for (j = 0; j < DIVISIONS; j++)
    {
     sum = 0;
     a = -5 + adiff * i;
     b = -5 + bdiff * j;
     for (k = 0; k < obscount; k++)
      {
       power = observations[1][k] - sigmoid(a * observations[0][k] + b);
       sum += power * power;
      }
     if (sum < bestsum)
      {
       bestsum = sum;
       *besta = a;
       *bestb = b;
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r15d
movsd 0x4841a(%rip), %xmm0    # 0x96330
movsd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpl $0x64, %eax
je 0x4e032
movq %rax, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x4cc36(%rip), %xmm0    # 0x9ab78
addsd 0x49e56(%rip), %xmm0    # 0x97da0
movsd %xmm0, 0x18(%rsp)
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
cmpl $0x64, %ebp
je 0x4e012
movsd %xmm0, 0x30(%rsp)
mulsd 0x4cc0b(%rip), %xmm0    # 0x9ab78
addsd 0x49e2b(%rip), %xmm0    # 0x97da0
movsd %xmm0, 0x20(%rsp)
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x4dfd6
movq (%r12), %rax
movq 0x8(%r12), %rcx
movsd (%rcx,%r13,8), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd (%rax,%r13,8), %xmm0
mulsd 0x18(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm1, 0x40(%rsp)
callq 0x4dd58
movsd 0x40(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
incq %r13
jmp 0x4df82
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4dffd
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd %xmm1, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
addsd 0x47515(%rip), %xmm0    # 0x95520
incl %ebp
jmp 0x4df56
movsd 0x8(%rsp), %xmm0
addsd 0x47500(%rip), %xmm0    # 0x95520
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rax
incl %eax
jmp 0x4df26
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/plot.c
// Function: solve_inv_gauss
void solve_inv_gauss(double* observations[2], int obscount, double meanstart, double meanend, double stdevstart, double stdevend, double* mean, double* stdev)
{
 /*!Last Changed 27.10.2004*/
 int i, j, k;
 double sum, m, s, mdiff, sdiff, power, bestsum = +LONG_MAX;
 mdiff = (meanend - meanstart) / DIVISIONS;
 sdiff = (stdevend - stdevstart) / DIVISIONS;
 for (i = 0; i < DIVISIONS; i++)
   for (j = 1; j < DIVISIONS; j++)
    {
     sum = 0;
     m = meanstart + mdiff * i;
     s = stdevstart + sdiff * j;
     for (k = 0; k < obscount; k++)
      {
       power = observations[1][k] - 1 + s * sqrt(2 * PI) * gaussian(observations[0][k], m, s);
       sum += power * power;
      }
     if (sum < bestsum)
      {
       bestsum = sum;
       *mean = m;
       *stdev = s;
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movsd %xmm0, 0x20(%rsp)
subsd %xmm0, %xmm1
movsd 0x47d3b(%rip), %xmm0    # 0x95da8
divsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x38(%rsp)
subsd %xmm2, %xmm3
divsd %xmm0, %xmm3
movsd %xmm3, 0x40(%rsp)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r15d
movsd 0x48295(%rip), %xmm0    # 0x96330
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpl $0x64, %eax
je 0x4e1cc
movq %rax, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
mulsd (%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x47449(%rip), %xmm0    # 0x95520
pushq $0x1
popq %rbp
cmpl $0x64, %ebp
je 0x4e1ae
movsd 0x40(%rsp), %xmm1
movsd %xmm0, 0x48(%rsp)
mulsd %xmm0, %xmm1
addsd 0x38(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
mulsd 0x4ca79(%rip), %xmm1    # 0x9ab80
movsd %xmm1, 0x50(%rsp)
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x4e172
movq (%r12), %rax
movq 0x8(%r12), %rcx
movsd (%rcx,%r13,8), %xmm0
addsd 0x47c80(%rip), %xmm0    # 0x95db0
movsd %xmm0, 0x58(%rsp)
movsd (%rax,%r13,8), %xmm0
movsd %xmm1, 0x60(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x803b8
movsd 0x60(%rsp), %xmm1
mulsd 0x50(%rsp), %xmm0
addsd 0x58(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %r13
jmp 0x4e114
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4e199
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd %xmm1, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
addsd 0x47379(%rip), %xmm0    # 0x95520
incl %ebp
jmp 0x4e0da
movsd (%rsp), %xmm0
addsd 0x47365(%rip), %xmm0    # 0x95520
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rax
incl %eax
jmp 0x4e0aa
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/plot.c
// Function: box_plot
void box_plot(char** names, int filecount)
{
 /*!Last Changed 20.09.2006*/
 /*!Last Changed 11.07.2005*/
 int count, i;
 Point p1, p2, p3;
 char* plotname, st2[3];
 plotname = file_only_name(names[0]); 
 if (!get_parameter_o("hold"))
   clear_image();
 for (i = 0; i < filecount; i++)
  {
   p1.x = file_percentile(names[i], 50);
   p1.y = file_percentile(names[i], 25);
   p2.x = file_percentile(names[i], 75);
   p2.y = i;
   file_whiskers(names[i], p1.y, p2.x, &(p3.x), &(p3.y));
   sprintf(st2, "%d", img.xaxis.namesavailable);
   add_object(OBJECT_BOXPLOT, p1, p2, p3, st2);
  }
 img.xaxis.namesavailable++;
 count = img.xaxis.namesavailable;
 img.xaxis.names = alloc(img.xaxis.names, count * sizeof(char *), count); 
 img.xaxis.names[count - 1] = strcopy(img.xaxis.names[count - 1], plotname);
 safe_free(plotname);
 img.xaxis.limitsset = 1;
 img.xaxis.lim.division = img.xaxis.namesavailable;
 img.xaxis.lim.min = 0;
 img.xaxis.lim.max = img.xaxis.namesavailable;
 img.xaxis.lim.precision = 0;
 export_image();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %r14d
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x34033
movq %rax, 0x18(%rsp)
leaq 0x490ec(%rip), %rdi     # 0x9a6e5
callq 0x4cff1
testl %eax, %eax
jne 0x51609
xorl %eax, %eax
callq 0x2a510
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
leaq 0x358a9f(%rip), %rbp    # 0x3aa0b8
leaq 0x15(%rsp), %rbx
pushq $0x4
popq %r12
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x516e5
movq (%r15,%r13,8), %rdi
movsd 0x4955e(%rip), %xmm0    # 0x9ab98
callq 0x8154d
movsd %xmm0, 0x30(%rsp)
movq (%r15,%r13,8), %rdi
movsd 0x4954f(%rip), %xmm0    # 0x9aba0
callq 0x8154d
movsd %xmm0, 0x8(%rsp)
movq (%r15,%r13,8), %rdi
movsd 0x49540(%rip), %xmm0    # 0x9aba8
callq 0x8154d
movaps %xmm0, %xmm1
movsd %xmm0, 0x20(%rsp)
cvtsi2sd %r13d, %xmm0
movsd %xmm0, 0x28(%rsp)
movq (%r15,%r13,8), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x813e8
movl 0x38(%rbp), %edx
movq %rbx, %rdi
leaq 0x4f4b2(%rip), %rsi     # 0xa0b59
xorl %eax, %eax
callq 0x41b0
movsd 0x38(%rsp), %xmm4
movsd 0x40(%rsp), %xmm5
movl %r12d, %edi
movsd 0x30(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
movq %rbx, %rsi
callq 0x28f8d
incq %r13
jmp 0x51625
movslq 0x38(%rbp), %rbx
leaq 0x1(%rbx), %rdx
movl %edx, 0x38(%rbp)
movq 0x30(%rbp), %rdi
leaq 0x8(,%rbx,8), %rsi
callq 0x34f30
movq %rax, 0x30(%rbp)
movq (%rax,%rbx,8), %rdi
movq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x3604c
movq 0x30(%rbp), %rcx
movq %rax, (%rcx,%rbx,8)
movq %r14, %rdi
callq 0x34ff7
movl 0x38(%rbp), %eax
movl %eax, 0x20(%rbp)
andq $0x0, 0x10(%rbp)
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rbp)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x24(%rbp)
xorl %eax, %eax
callq 0x2a858
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/plot.c
// Function: plotmv
void plotmv(char** names, int filecount)
{
 /*!Last Changed 20.09.2006*/
 /*!Last Changed 11.07.2005*/
 int count, i;
 Point p1, p2;
 char* plotname;
 if (!get_parameter_o("hold"))
   clear_image();
 plotname = file_only_name(names[0]);
 for (i = 0; i < filecount; i++)
  {
   p1.x = file_mean(&(names[i]), 1);
   p1.y = file_variance(&(names[i]), 1);
   p2.x = img.xaxis.namesavailable;
   p2.y = i;
   add_object(OBJECT_MVBOX, p1, p2, dummyp, NULL);
  }
 img.xaxis.namesavailable++;
 count = img.xaxis.namesavailable;
 img.xaxis.names = alloc(img.xaxis.names, count * sizeof(char *), count); 
 img.xaxis.names[count - 1] = strcopy(img.xaxis.names[count - 1], plotname);
 safe_free(plotname);
 img.xaxis.lim.division = count;
 img.xaxis.lim.min = 0;
 img.xaxis.lim.max = count;
 img.xaxis.lim.precision = 0;
 export_image();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x48f6d(%rip), %rdi     # 0x9a6e5
callq 0x4cff1
testl %eax, %eax
jne 0x51788
xorl %eax, %eax
callq 0x2a510
movq (%r14), %rdi
callq 0x34033
xorl %r15d, %r15d
testl %ebx, %ebx
cmovlel %r15d, %ebx
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rbp
leaq 0x358910(%rip), %r13    # 0x3aa0b8
pushq $0x3
popq %r12
cmpq %r15, %rbx
je 0x51802
movq %r14, %rdi
movl %ebp, %esi
callq 0x8097f
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x81700
movaps %xmm0, %xmm1
cvtsi2sdl 0x38(%r13), %xmm2
cvtsi2sd %r15d, %xmm3
movsd 0x7b88f(%rip), %xmm4    # 0xcd070
movsd 0x7b88f(%rip), %xmm5    # 0xcd078
movl %r12d, %edi
movsd 0x10(%rsp), %xmm0
xorl %esi, %esi
callq 0x28f8d
incq %r15
addq $0x8, %r14
jmp 0x517ac
movslq 0x38(%r13), %r14
leaq 0x1(%r14), %rbx
movl %ebx, 0x38(%r13)
movq 0x30(%r13), %rdi
leaq 0x8(,%r14,8), %rsi
movl %ebx, %edx
callq 0x34f30
movq %rax, 0x30(%r13)
movq (%rax,%r14,8), %rdi
movq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x3604c
movq 0x30(%r13), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x34ff7
movl %ebx, 0x20(%r13)
andq $0x0, 0x10(%r13)
cvtsi2sd %ebx, %xmm0
movsd %xmm0, 0x18(%r13)
andl $0x0, 0x24(%r13)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a858