LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x555e1(%rip), %rdi     # 0xa8c98
callq 0x54920
movl %eax, %ebp
movq 0x20(%rbx), %rdi
callq 0x30309
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 0x531f9
testl %ebp, %ebp
jle 0x537a5
movl %ebp, %r12d
xorl %r13d, %r13d
movsd 0x20(%rsp,%r13,8), %xmm0
ucomisd 0x526a1(%rip), %xmm0    # 0xa5da8
jne 0x5370f
jnp 0x53799
cmpl $0x2, %r13d
je 0x5375a
cmpl $0x1, %r13d
je 0x5373c
testl %r13d, %r13d
jne 0x5377d
movq 0x20(%rbx), %rdi
movl 0x30(%rbx), %esi
movsd 0x28(%rbx), %xmm0
movl 0x2c(%r14), %edx
callq 0xa2a22
movl $0x2, %eax
jmp 0x53783
movsd 0x48(%rbx), %xmm0
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
callq 0x4e038
movl 0x90(%rbx), %eax
jmp 0x53779
movq 0x20(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4e038
movl 0x94(%rbx), %eax
incl %eax
jmp 0x53783
xorpd %xmm0, %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movl %r15d, %edi
callq 0x47cd7
movsd %xmm0, 0x20(%rsp,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x536f8
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %r8d
callq 0x533cf
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_error_and_free_matrix
int find_error_and_free_matrix(Instanceptr* train, Instanceptr test, NODE_TYPE node_type, double variance_explained)
{
 /*!Last Changed 03.12.2004*/
 int bestfeature, error, counts[2][MAXCLASSES], leftclass, rightclass;
 double split, w0;
 matrix w;
 if (node_type == UNIVARIATE)
  {
   bestfeature = find_best_ldt_feature_for_realized(*train, &split);
   if (bestfeature == -1)
     return data_size(test);
  }
 else
   if (!find_best_multi_ldt_split(train, &w, &w0, node_type, variance_explained))
    {
     matrix_free(w);
     return data_size(test);
    }
 if (node_type == UNIVARIATE)
   find_counts_for_split(*train, bestfeature, split, counts[0], counts[1], HYBRID_CONDITION);
 else
   find_counts_for_multivariate_split(*train, w, w0, counts[0], counts[1]);
 leftclass = find_max_in_list(counts[0], MAXCLASSES);
 rightclass = find_max_in_list(counts[1], MAXCLASSES);
 if (node_type == UNIVARIATE)
   return test_univariate(test, bestfeature, split, leftclass, rightclass);
 else
  {
   error = test_multivariate(test, w, w0, leftclass, rightclass);
   matrix_free(w);
   return error;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testl %edx, %edx
je 0x53fc9
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0x4e089
testl %eax, %eax
je 0x5405c
movq (%r15), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0xe8(%rsp), %r8
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x4de0c
jmp 0x54005
movq (%r15), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa211d
cmpl $-0x1, %eax
je 0x5406a
movl %eax, %r14d
movq (%r15), %rdi
movsd 0x18(%rsp), %xmm0
leaq 0xe8(%rsp), %rcx
leaq 0x20(%rsp), %rdx
movl %eax, %esi
movl $0x2, %r8d
callq 0xa11fa
leaq 0x20(%rsp), %rdi
movl $0x32, %esi
callq 0x38002
movl %eax, %r15d
leaq 0xe8(%rsp), %rdi
movl $0x32, %esi
callq 0x38002
testl %ebp, %ebp
je 0x54074
movsd 0x10(%rsp), %xmm0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r15d, %ecx
movl %eax, %r8d
callq 0x4d04a
movl %eax, %ebx
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3ed51
jmp 0x5408c
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3ed51
movq %rbx, %rdi
callq 0x30309
jmp 0x5408a
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x9fc64
movl %eax, %ebx
movl %ebx, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split_according_char
int find_best_hybrid_ldt_split_according_char(Decisionnodeptr node, char model, double variance_explained)
{
 /*!Last Changed 01.07.2006*/
 switch (model){
   case 'U':
   case 'u':return find_best_hybrid_ldt_split_single_model(node, UNIVARIATE, variance_explained);
            break;
   case 'L':
   case 'l':return find_best_hybrid_ldt_split_single_model(node, LINEAR, variance_explained);
            break;
   case 'Q':
   case 'q':return find_best_hybrid_ldt_split_single_model(node, QUADRATIC, variance_explained);
            break;
   default :printf(m1325);
            return NO;
            break;
 }
}

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

// Assembly:
pushq %rbx
movl 0x18(%rsi), %ecx
xorl %eax, %eax
cmpq $0x7, %rcx
ja 0x5419b
movq %rdi, %rbx
leaq 0x5687e(%rip), %rdx     # 0xaa9b0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
popq %rbx
jmp 0x53a17
movsd 0x20(%rsi), %xmm0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
jmp 0x54169
movq %rbx, %rdi
popq %rbx
jmp 0x53577
movsd 0x20(%rsi), %xmm0
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
popq %rbx
jmp 0x534c7
movq %rbx, %rdi
popq %rbx
jmp 0x5369c
movq %rbx, %rdi
popq %rbx
jmp 0x537d4
movq 0x20(%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0xa211d
movl %eax, %ecx
movl %eax, 0x30(%rbx)
xorl %eax, %eax
cmpl $-0x1, %ecx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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(%rdi)
callq 0x1d053
testl %eax, %eax
je 0x541fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5411c
testl %eax, %eax
je 0x541f6
movq %rbx, %rdi
callq 0x4db5c
testl %eax, %eax
je 0x541fe
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x5419d
movq 0x8(%rbx), %rbx
movl $0x2, 0x98(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x541b1
movq %rbx, %rdi
callq 0x1cab0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/operator.c
// Function: remove_operator
BOOLEAN remove_operator(bayesiangraphptr mygraph)
{
/*!Last Changed 02.03.2001*/
 int arc_no, from, to, from_order;
 double before, after;
 if (mygraph->arccount == mygraph->nodecount - 1)
   return BOOLEAN_FALSE;
 arc_no = myrand() % mygraph->arccount;
 before = likelihood_of_data(mygraph, cv);
 delete_one_arc(mygraph, arc_no, &from, &to, &from_order);
 delete_parent_counts(&mygraph->nodes[to], from_order);
 free_2d((void **) mygraph->nodes[to].table, mygraph->nodes[to].table_count);
 make_one_conditional_table(mygraph, to);
 if (connected(mygraph))
  {
   after = likelihood_of_data(mygraph, cv);
   if (after > before)
     return BOOLEAN_TRUE;
  }
 free_2d((void **) mygraph->nodes[to].table, mygraph->nodes[to].table_count);
 add_parent_counts(mygraph, &mygraph->nodes[to], from);
 add_one_arc(mygraph);
 add_one_pointer(mygraph, &mygraph->nodes[to], from);
 make_one_conditional_table(mygraph, to);
 return BOOLEAN_FALSE;
}

// Assembly:
movl 0x10(%rdi), %ecx
decl %ecx
xorl %eax, %eax
cmpl %ecx, 0x20(%rdi)
je 0x54351
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x3af20
cltd
idivl 0x20(%rbx)
movl %edx, %ebp
leaq 0x81289(%rip), %r12     # 0xd54c8
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2733e
movsd %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %r14
leaq 0x1c(%rsp), %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x4e783
movslq (%r14), %rax
leaq (%rax,%rax,8), %rdi
shlq $0x3, %rdi
addq 0x8(%rbx), %rdi
movl (%r15), %esi
callq 0x4e90e
movq 0x8(%rbx), %rax
movslq (%r14), %rcx
leaq (%rcx,%rcx,8), %rcx
movq 0x38(%rax,%rcx,8), %rdi
movl 0x28(%rax,%rcx,8), %esi
callq 0x3a14b
movl (%r14), %esi
movq %rbx, %rdi
callq 0x4f5ca
movq %rbx, %rdi
callq 0x4ee60
testl %eax, %eax
je 0x542da
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2733e
movl $0x1, %eax
ucomisd 0x10(%rsp), %xmm0
ja 0x54345
movq 0x8(%rbx), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,8), %rcx
movq 0x38(%rax,%rcx,8), %rdi
movl 0x28(%rax,%rcx,8), %esi
callq 0x3a14b
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movl 0xc(%rsp), %edx
movq %rbx, %rdi
callq 0x4e964
movq %rbx, %rdi
callq 0x4e881
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movl 0xc(%rsp), %edx
movq %rbx, %rdi
callq 0x4e8d5
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x4f5ca
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5450c
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x545a6
xorl %r14d, %r14d
testl %eax, %eax
jle 0x5459b
movl $0x4, %r15d
leaq (%r14,%r14,8), %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x40(%rbx), %rsi
movl (%rsi,%r14,4), %ecx
cmpl (%rsi,%r13), %ecx
jge 0x54588
movq 0x8(%rbx), %rcx
movl 0x10(%rcx,%r12,8), %edx
cmpl (%rcx,%r15,4), %edx
jle 0x54588
leaq (%rsi,%r14,4), %rdi
addq %r13, %rsi
callq 0x3a5af
movl 0x10(%rbx), %eax
incq %rbp
movslq %eax, %rcx
addq $0x4, %r13
addq $0x12, %r15
cmpq %rcx, %rbp
jl 0x5455c
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x54549
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x54829
callq 0x3a180
cmpl $0x0, 0x10(%r14)
jle 0x54848
movq 0x40(%r14), %rax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
movslq 0x10(%r14), %rdx
cmpq %rdx, %rcx
jl 0x54836
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/ordering.c
// Function: find_nodes_before
int* find_nodes_before(bayesiangraphptr mygraph, int node)
{
 /*!Verilmis bir node icin orderingde ondan once gelen tum nodelari donduruyor*/
 /*!Last changed 01.06.2001*/
 int i = 0, where, *result = NULL;
 where = mygraph->ordering[i];
 while (where != node)
  {
   i++;
   result = alloc(result, i * sizeof(int), i);
   result[i - 1] = mygraph->ordering[i - 1];
   where = mygraph->ordering[i];
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rax
cmpl %esi, (%rax)
jne 0x54863
xorl %eax, %eax
jmp 0x5489f
movl %esi, %ebx
movq %rdi, %r14
movl $0x4, %r15d
movl $0x1, %ebp
xorl %eax, %eax
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x3a0b4
movq 0x40(%r14), %rcx
movl -0x4(%rcx,%r15), %edx
movl %edx, -0x4(%rax,%r15)
leaq 0x4(%r15), %rdx
incl %ebp
cmpl %ebx, (%rcx,%r15)
movq %rdx, %r15
jne 0x54875
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x548c4
cmpl $-0x1, %eax
je 0x54af4
movq 0x80a3d(%rip), %rcx     # 0xd54f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x4, 0x8(%rcx,%r14)
jne 0x54af4
leaq (%rcx,%r14), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x54adb
callq 0x3a180
movq 0x80a15(%rip), %rcx     # 0xd54f0
movq 0x18(%rcx,%r14), %rdi
movq %rbx, %rsi
callq 0x3b494
movq 0x80a01(%rip), %rcx     # 0xd54f0
movq %rax, 0x18(%rcx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/parameter.c
// Function: set_parameter_l
void set_parameter_l(char* name, char* value, char* errormessage)
{
 /*!Last Changed 09.08.2007*/
 int i, index, val;
 index = parameter_index(name);
 if (index != -1 && parameters[index].type == LIST_PARAMETER)
  {
   val = listindex(value, parameters[index].listvalues, parameters[index].arraysize);
   if (val != -1)
     parameters[index].value.listvalue = val;
   else
    {
     printf(errormessage, value);
     printf(m1276);
     for (i = 0; i < parameters[index].arraysize; i++)
      {
       printf("%s", parameters[index].listvalues[i]);
       printf("\n");
      }     
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
callq 0x548c4
cmpl $-0x1, %eax
je 0x54be6
movq 0x809a5(%rip), %rcx     # 0xd54f0
movslq %eax, %r15
shlq $0x5, %r15
cmpl $0x3, 0x8(%rcx,%r15)
jne 0x54be6
addq %r15, %rcx
movq 0x10(%rcx), %rsi
movl 0xc(%rcx), %edx
movq %rbx, %rdi
callq 0x3b355
cmpl $-0x1, %eax
je 0x54b83
movq 0x80974(%rip), %rcx     # 0xd54f0
movl %eax, 0x18(%rcx,%r15)
jmp 0x54be6
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4030
leaq 0x55fef(%rip), %rdi     # 0xaab86
callq 0x4090
movq 0x8094d(%rip), %rax     # 0xd54f0
cmpl $0x0, 0xc(%rax,%r15)
jle 0x54be6
leaq 0x5339e(%rip), %rbx     # 0xa7f50
xorl %r14d, %r14d
movq 0x10(%rax,%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movl $0xa, %edi
callq 0x40d0
incq %r14
movq 0x80914(%rip), %rax     # 0xd54f0
movslq 0xc(%rax,%r15), %rcx
cmpq %rcx, %r14
jl 0x54bb5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x548c4
cmpl $-0x1, %eax
je 0x54c6e
movq 0x808bd(%rip), %rcx     # 0xd54f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x2, 0x8(%rcx,%r14)
jne 0x54c6e
leaq 0x80407(%rip), %rsi     # 0xd5050
movq %rbx, %rdi
movl $0x2, %edx
callq 0x3b355
cmpl $-0x1, %eax
je 0x54c76
movl $0x1, %ecx
subl %eax, %ecx
movq 0x80887(%rip), %rax     # 0xd54f0
movl %ecx, 0x18(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x55f1a(%rip), %rdi     # 0xaab97
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 0x548c4
cmpl $-0x1, %eax
je 0x54d40
movq 0x8081a(%rip), %rcx     # 0xd54f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x5, 0x8(%rcx,%r14)
jne 0x54d40
testl %ebp, %ebp
jle 0x54d40
cmpl $0x0, 0xc(%rcx,%r14)
jle 0x54d40
movl %ebp, %r15d
movl $0x1, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13), %rdi
movq 0x18(%rcx,%r14), %rsi
addq %r13, %rsi
movsd 0x55e07(%rip), %xmm0    # 0xaab18
movsd 0x55e07(%rip), %xmm1    # 0xaab20
callq 0x3aa07
cmpq %r15, %r12
jae 0x54d40
movq 0x807c6(%rip), %rcx     # 0xd54f0
movslq 0xc(%rcx,%r14), %rax
addq $0x8, %r13
leaq 0x1(%r12), %rdx
cmpq %rax, %r12
movq %rdx, %r12
jl 0x54cfd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x548c4
cmpl $-0x1, %eax
je 0x54dd4
movq 0x80780(%rip), %rcx     # 0xd54f0
movslq %eax, %r14
shlq $0x5, %r14
cmpl $0x5, 0x8(%rcx,%r14)
jne 0x54dd4
testl %ebp, %ebp
jle 0x54dd4
cmpl $0x0, 0xc(%rcx,%r14)
jle 0x54dd4
movl %ebp, %r15d
movl $0x1, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,2), %rdi
movq 0x18(%rcx,%r14), %rsi
addq %r13, %rsi
movl $0x80000001, %edx       # imm = 0x80000001
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
callq 0x3a98c
cmpq %r15, %r12
jae 0x54dd4
movq 0x80732(%rip), %rcx     # 0xd54f0
movslq 0xc(%rcx,%r14), %rax
addq $0x4, %r13
leaq 0x1(%r12), %rdx
cmpq %rax, %r12
movq %rdx, %r12
jl 0x54d97
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/parameter.c
// Function: free_program_parameters
void free_program_parameters()
{
 /*!Last Changed 08.08.2007*/
 int i, j;
 for (i = 0; i < parametercount; i++)
  {
   safe_free(parameters[i].name);
   switch (parameters[i].type)
    {
     case STRING_PARAMETER:safe_free(parameters[i].value.stringvalue);
                           break;
     case   LIST_PARAMETER:for (j = 0; j < parameters[i].arraysize; j++)
                             safe_free(parameters[i].listvalues[j]);
                           safe_free(parameters[i].listvalues);
                           break;
     case  ARRAY_PARAMETER:safe_free(parameters[i].value.arrayvalue);
                           break;
     default              :break;
    }
  }
 safe_free(parameters);
}

// Assembly:
cmpl $0x0, 0x802d2(%rip)     # 0xd54e8
jle 0x552b4
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
movq 0x802c6(%rip), %rax     # 0xd54f0
movq %rbx, %r14
shlq $0x5, %r14
movq (%rax,%r14), %rdi
callq 0x3a180
movq 0x802af(%rip), %rax     # 0xd54f0
leaq (%rax,%r14), %rcx
movl 0x8(%rax,%r14), %edx
cmpl $0x5, %edx
je 0x55290
cmpl $0x4, %edx
je 0x55290
cmpl $0x3, %edx
jne 0x5529c
cmpl $0x0, 0xc(%rax,%r14)
jle 0x55286
xorl %r15d, %r15d
movq 0x10(%rax,%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x3a180
incq %r15
movq 0x80274(%rip), %rax     # 0xd54f0
movslq 0xc(%rax,%r14), %rcx
cmpq %rcx, %r15
jl 0x55264
leaq (%rax,%r14), %rcx
addq $0x10, %rcx
jmp 0x55294
addq $0x18, %rcx
movq (%rcx), %rdi
callq 0x3a180
incq %rbx
movslq 0x80242(%rip), %rax     # 0xd54e8
cmpq %rax, %rbx
jl 0x55223
popq %rbx
popq %r14
popq %r15
movq 0x80235(%rip), %rdi     # 0xd54f0
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/part.c
// Function: extract_best_leaf_from_partial_tree
Decisionnodeptr extract_best_leaf_from_partial_tree(Decisionnodeptr rootnode, int* bestscore)
{
 int i;
 Decisionnodeptr best = NULL, current;
 if (rootnode->featureno != LEAF_NODE)
  {
   if (current_dataset->features[rootnode->featureno].type == STRING)
    {
     for (i = 0; i < current_dataset->features[rootnode->featureno].valuecount; i++)
      {
       current = extract_best_leaf_from_partial_tree(&(rootnode->string[i]), bestscore);
       if (current)
         best = current;
      }
    }
   else
    {
     current = extract_best_leaf_from_partial_tree(rootnode->left, bestscore);
     if (current)
       best = current;
     current = extract_best_leaf_from_partial_tree(rootnode->right, bestscore);
     if (current)
       best = current;
    } 
  }
 else
   if (rootnode->expanded && rootnode->covered > *bestscore)
    {
     *bestscore = rootnode->covered;
     return rootnode;    
    }
 return best;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x30(%rdi), %rcx
cmpq $-0x1, %rcx
je 0x5534a
leaq 0x8058e(%rip), %r12     # 0xd5870
movq (%r12), %rax
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x1, 0x30f08(%rax,%rcx)
jne 0x5536b
addq $0x30f08, %rax          # imm = 0x30F08
cmpl $0x0, 0x18(%rax,%rcx)
jle 0x55366
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x10(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x552c0
testq %rax, %rax
cmovneq %rax, %r15
incq %rbp
movq (%r12), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %rax
addq $0x160, %r13            # imm = 0x160
cmpq %rax, %rbp
jl 0x5530c
jmp 0x5538c
cmpl $0x0, 0x130(%r14)
je 0x55366
movl 0x84(%r14), %eax
cmpl (%rbx), %eax
jle 0x55366
movl %eax, (%rbx)
movq %r14, %r15
jmp 0x5538c
xorl %r15d, %r15d
jmp 0x5538c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x552c0
movq %rax, %r15
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x552c0
testq %rax, %rax
cmovneq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x804b0(%rip), %rax     # 0xd5870
movq (%rax), %rax
movslq 0x30(%rdi), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x1, 0x30f08(%rax,%rcx)
jne 0x55416
addq $0x30f08, %rax          # imm = 0x30F08
movslq 0x18(%rax,%rcx), %rax
testq %rax, %rax
jle 0x5543e
movq 0x10(%rdi), %rcx
imulq $0x160, %rax, %rdx      # imm = 0x160
xorl %eax, %eax
xorl %esi, %esi
cmpl $-0x1, 0x30(%rcx,%rsi)
jne 0x55421
cmpl $0x0, 0x130(%rcx,%rsi)
je 0x55421
addq $0x160, %rsi            # imm = 0x160
cmpq %rsi, %rdx
jne 0x553f7
jmp 0x5543e
movq (%rdi), %rcx
xorl %eax, %eax
cmpl $-0x1, 0x30(%rcx)
je 0x55422
retq
cmpl $0x0, 0x130(%rcx)
je 0x55421
movq 0x8(%rdi), %rcx
cmpl $-0x1, 0x30(%rcx)
jne 0x55421
cmpl $0x0, 0x130(%rcx)
je 0x55421
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rsi, %rsi
je 0x554db
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r15, %rdi
callq 0x553b9
movl %eax, %ebp
testl %eax, %eax
je 0x554c4
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d5ec
movl %eax, %r13d
movl 0x30(%r15), %ebx
movl $0xffffffff, 0x30(%r15) # imm = 0xFFFFFFFF
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d5ec
movl %ebx, 0x30(%r15)
cmpl %r13d, %eax
jl 0x554cb
leaq 0x20(%r15), %rdi
movq %r15, %rsi
callq 0x1cef5
movq %r15, %rdi
callq 0x1d8e3
movq %r15, %rdi
callq 0x1cab0
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x55463
xorl $0x1, %ebp
movl %ebp, %eax
jmp 0x554cd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %r12d, %r12d
movq %r12, 0x10(%rsp)
movq %r12, 0x8(%rsp)
callq 0x7c32b
movq (%r15), %rdi
callq 0x115a6
movq %rax, %r13
leaq 0x80173(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r13, %rdi
callq 0x38002
movl %eax, 0x14(%rbx)
movq %r13, %rdi
callq 0x3a180
movq (%r15), %rdi
callq 0x30309
testl %eax, %eax
jle 0x557cd
leaq 0x8(%rsp), %rbp
xorl %edi, %edi
movl $0x1, %esi
callq 0x1d107
movq %rax, %r12
movq (%r15), %rax
movq %rax, 0x20(%r12)
movq (%r14), %rsi
movq %r12, %rdi
callq 0x554dc
movl $0x0, 0x4(%rsp)
movq %r12, %rdi
leaq 0x4(%rsp), %rsi
callq 0x552c0
movq %rax, %rdi
callq 0x7bef7
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c9c6
movq $0x0, (%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1cef5
movq %r12, %rdi
callq 0x1d74c
movq %r12, %rdi
callq 0x3a180
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x9f94e
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x9f94e
movq (%r15), %rdi
callq 0x30309
testl %eax, %eax
jg 0x5572b
movq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x30648
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x30648
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x553b2(%rip), %rsi     # 0xaabc5
movl $0x3, %edx
callq 0x3a0e1
movq %rax, (%rbx)
movslq 0x10(%r14), %rdi
testq %rdi, %rdi
jle 0x5583f
xorl %ecx, %ecx
movl %ecx, (%rax,%rcx,4)
incq %rcx
movl 0x10(%r14), %edx
movslq %edx, %rdi
cmpq %rdi, %rcx
jl 0x5582b
jmp 0x55841
movl %edi, %edx
movl %edx, 0x10(%rbx)
shlq $0x2, %rdi
leaq 0x55376(%rip), %rsi     # 0xaabc5
movl $0x7, %edx
callq 0x3a0e1
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x10(%r14)
jle 0x55880
movl %ebp, %ecx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rcx
setne %sil
movl %esi, (%rax,%rdx,4)
incq %rdx
movslq 0x10(%r14), %rsi
cmpq %rsi, %rdx
jl 0x55868
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x520bb(%rip), %r14     # 0xa7952
movl $0x8, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, (%rbx)
movabsq $0x100000000, %r15      # imm = 0x100000000
movq %r15, (%rax)
movl $0x2, 0x10(%rbx)
movl $0x8, %edi
movq %r14, %rsi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, 0x8(%rbx)
movq %r15, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x18(%rsp), %rax
testq %rax, %rax
jle 0x55906
leaq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
addl (%rdx,%rsi,4), %ecx
incq %rsi
cmpq %rsi, %rax
jne 0x558f9
jmp 0x55908
xorl %ecx, %ecx
cmpl %eax, %ecx
sete %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movslq 0x30(%rsp), %rbx
testq %rbx, %rbx
jle 0x55984
leaq 0x20(%rsp), %r14
movq (%r14), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
cmpl %edi, %edx
cmovgl %edx, %edi
incq %rcx
cmpq %rcx, %rbx
jne 0x55935
incl %edi
shlq $0x2, %rdi
leaq 0x5529a(%rip), %rsi     # 0xaabec
movl $0x5, %edx
callq 0x3a0e1
testl %ebx, %ebx
jle 0x5597c
movq (%r14), %rcx
movq 0x8(%r14), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
movslq (%rcx,%rsi,4), %r8
movl %edi, (%rax,%r8,4)
incq %rsi
cmpq %rsi, %rbx
jne 0x55969
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x55261(%rip), %rsi     # 0xaabec
xorl %edi, %edi
movl $0x5, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a0e1
// File: /workspace/github_c_makefile_star2_O3/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 0x559bd
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 0x559a1
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x40(%rsp), %r15
movl %r15d, 0x10(%rdi)
leaq (,%r15,4), %r14
leaq 0x55222(%rip), %rsi     # 0xaac03
movq %r14, %rdi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, 0x8(%rbx)
testq %r15, %r15
jle 0x55a43
leaq 0x30(%rsp), %r12
movq 0x8(%r12), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x55a03
leaq 0x551eb(%rip), %rsi     # 0xaac03
movq %r14, %rdi
movl $0x7, %edx
callq 0x3a0e1
movq %rax, (%rbx)
testl %r15d, %r15d
jle 0x55a5a
movq (%r12), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x55a33
jmp 0x55a5a
leaq 0x551b9(%rip), %rsi     # 0xaac03
movq %r14, %rdi
movl $0x7, %edx
callq 0x3a0e1
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x55b0b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movsd %xmm1, (%rsp)
movsd (%rbx,%r15,8), %xmm0
callq 0x39bb5
movsd (%rsp), %xmm1
movsd %xmm0, (%rbx,%r15,8)
addsd %xmm0, %xmm1
incq %r15
cmpq %r15, %r14
jne 0x55abe
testl %ebp, %ebp
jle 0x55b01
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x55aeb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %esi, %ebx
movl %edi, %ebp
leaq 0x550e8(%rip), %r8      # 0xaac0f
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x3a3ac
movq %rax, %r14
testl %ebp, %ebp
jle 0x55b8d
movl %ebp, %r15d
movl %ebx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x55b85
xorl %ebp, %ebp
movsd 0x5024a(%rip), %xmm0    # 0xa5da8
movsd 0x4f9ba(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
movq (%r14,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r12
jne 0x55b56
incq %r13
cmpq %r15, %r13
jne 0x55b50
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %edi, %ebp
movslq %edi, %r14
leaq (,%r14,8), %rdi
leaq 0x5506b(%rip), %rsi     # 0xaac2a
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
testl %r14d, %r14d
jle 0x55bff
movl %ebp, %r14d
xorl %r15d, %r15d
movsd 0x501c9(%rip), %xmm0    # 0xa5da8
movsd 0x4f939(%rip), %xmm1    # 0xa5520
callq 0x3af6a
mulsd (%rsp), %xmm0
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x55bd7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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, 0x10(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r12d
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x506f4(%rip), %xmm1    # 0xa6330
movsd %xmm1, (%rsp)
movq %rax, 0x8(%rsp)
movapd %xmm0, %xmm1
mulsd 0x54ff6(%rip), %xmm1    # 0xaac48
addsd 0x521c6(%rip), %xmm1    # 0xa7e20
xorpd %xmm2, %xmm2
xorl %r13d, %r13d
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
mulsd 0x54fcd(%rip), %xmm2    # 0xaac48
addsd 0x5219d(%rip), %xmm2    # 0xa7e20
xorpd %xmm3, %xmm3
testl %ebp, %ebp
jle 0x55ce9
xorl %ebx, %ebx
movsd %xmm2, 0x30(%rsp)
movsd %xmm3, 0x40(%rsp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd (%rax,%rbx,8), %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
callq 0x55a80
movsd 0x40(%rsp), %xmm3
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm1
movsd 0x38(%rsp), %xmm4
subsd %xmm0, %xmm4
mulsd %xmm4, %xmm4
addsd %xmm4, %xmm3
incq %rbx
cmpq %rbx, %r12
jne 0x55c93
movsd (%rsp), %xmm0
ucomisd %xmm3, %xmm0
jbe 0x55d07
movsd %xmm1, (%r14)
movq 0x10(%rsp), %rax
movsd %xmm2, (%rax)
movsd %xmm3, (%rsp)
movsd 0x20(%rsp), %xmm2
addsd 0x4f80b(%rip), %xmm2    # 0xa5520
incl %r13d
cmpl $0x64, %r13d
movsd 0x18(%rsp), %xmm0
jne 0x55c6d
addsd 0x4f7f0(%rip), %xmm0    # 0xa5520
movq 0x8(%rsp), %rax
incl %eax
cmpl $0x64, %eax
jne 0x55c41
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x78, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm1
movsd 0x50024(%rip), %xmm0    # 0xa5da0
divsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x30(%rsp)
subsd %xmm2, %xmm3
divsd %xmm0, %xmm3
movsd %xmm3, 0x38(%rsp)
movl %esi, %r12d
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x50585(%rip), %xmm1    # 0xa6330
movsd %xmm1, 0x8(%rsp)
movsd 0x4f767(%rip), %xmm1    # 0xa5520
movsd 0x4ffe7(%rip), %xmm2    # 0xa5da8
movq %rax, 0x20(%rsp)
movsd 0x18(%rsp), %xmm3
mulsd %xmm0, %xmm3
addsd 0x10(%rsp), %xmm3
movl $0x1, %r13d
movapd %xmm1, %xmm4
movsd %xmm0, 0x40(%rsp)
movsd %xmm3, 0x50(%rsp)
movsd 0x38(%rsp), %xmm5
movsd %xmm4, 0x48(%rsp)
mulsd %xmm4, %xmm5
addsd 0x30(%rsp), %xmm5
testl %ebp, %ebp
jle 0x55e8e
movapd %xmm5, %xmm0
mulsd 0x54e3a(%rip), %xmm0    # 0xaac50
movsd %xmm0, 0x58(%rsp)
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
movsd %xmm5, 0x60(%rsp)
movsd %xmm1, 0x70(%rsp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movsd (%rcx,%rbx,8), %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x68(%rsp)
movsd (%rax,%rbx,8), %xmm0
movapd %xmm3, %xmm1
movapd %xmm5, %xmm2
callq 0x8dd8e
movsd 0x70(%rsp), %xmm1
movsd 0x60(%rsp), %xmm5
movsd 0x50(%rsp), %xmm3
movsd 0x4ff38(%rip), %xmm2    # 0xa5da8
mulsd 0x58(%rsp), %xmm0
addsd 0x68(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %rbx
cmpq %rbx, %r12
jne 0x55e28
jmp 0x55e92
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x55eb2
movsd %xmm3, (%r14)
movq 0x28(%rsp), %rax
movsd %xmm5, (%rax)
movsd %xmm1, 0x8(%rsp)
movsd 0x4f666(%rip), %xmm1    # 0xa5520
movsd 0x48(%rsp), %xmm4
addsd %xmm1, %xmm4
incl %r13d
cmpl $0x64, %r13d
movsd 0x40(%rsp), %xmm0
jne 0x55dec
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
incl %eax
cmpl $0x64, %eax
jne 0x55dc1
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq