LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_omnildt
void* train_omnildt(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 24.11.2004 added univariate and multivariate condition counts*/
 /*!Last Changed 22.11.2004 added possible conditioncount*/
 /*!Last Changed 04.10.2004 added writerules*/
 /*!Last Changed 23.09.2004*/
 Decisionnodeptr rootnode;
 Multildt_parameterptr p;
 p = (Multildt_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->possibleconditioncount = possible_condition_count(*trdata);
 create_omnildtchildren(rootnode, p);
 if (in_list(p->c45param.prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
  {
   if (p->c45param.prunetype == VALIDATIONPRUNING || (p->c45param.prunetype == MODELSELECTIONPRUNING && p->modelselectionmethod == MODEL_SELECTION_CV))
     prune_tree(rootnode, rootnode, *cvdata);
   else
     prune_tree_according_to_model_selection_method(rootnode, p->modelselectionmethod);
  }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd9890
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8c(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x781e0
movq -0x28(%rbp), %rax
movl (%rax), %edi
movl $0x2, %edx
movl $0x1, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x10544
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
je 0x1051c
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x10532
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x10532
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x2a370
jmp 0x10542
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x765a0
jmp 0x10544
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_softtree
void* train_softtree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Decisionnodeptr treenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 treenode = createnewnode(NULL, 1);
 treenode->weight = 1.0;
 treenode->instances = *trdata;
 if (current_dataset->classno == 2)
  {
   treenode->leaftype = p->leaftype;
   if (p->leaftype == CONSTANTLEAF)
     treenode->w0 = produce_random_value(-0.01, +0.01);
   else
     treenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
   create_softtree(treenode, treenode, *cvdata, p);
  }
 else
  {
   treenode->leaftype = CONSTANTLEAF;
   treenode->w0s = random_array_double(current_dataset->classno, -0.01, +0.01);
   treenode->outputs = safemalloc(current_dataset->classno * sizeof(double), "train_softtree", 14);
   create_softtree_K_class(treenode, treenode, *cvdata, p);
  }
	*trdata = NULL;
	return treenode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd 0xd178e(%rip), %xmm0    # 0xe2018
movsd %xmm0, 0x78(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0xf4f9b(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0x10953
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x108e8
movsd 0xd2188(%rip), %xmm0    # 0xe2a58
movsd 0xd1748(%rip), %xmm1    # 0xe2020
callq 0x545a0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x48(%rax)
jmp 0x10939
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0xf4f49(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %edi
movl $0x1, %esi
movsd 0xd214b(%rip), %xmm0    # 0xe2a58
movsd 0xd170b(%rip), %xmm1    # 0xe2020
callq 0x5a130
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0xc07d0
jmp 0x109d1
movq -0x20(%rbp), %rax
movl $0x0, 0x60(%rax)
leaq 0xf4edb(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %edi
movsd 0xd20e5(%rip), %xmm0    # 0xe2a58
movsd 0xd16a5(%rip), %xmm1    # 0xe2020
callq 0x546c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
leaq 0xf4eae(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0xd22ba(%rip), %rsi     # 0xe2c5e
movl $0xe, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0xc0740
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_softtree
Prediction test_softtree(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int i;
	Decisionnodeptr treenode;
 Prediction predicted;
 double* output;
	treenode = (Decisionnodeptr) model;
 if (current_dataset->classno == 2)
  {
   posterior[1] = sigmoid(soft_tree_output(treenode, data));
   posterior[0] = 1 - posterior[1];
   if (posterior[0] > posterior[1])
     predicted.classno = 0;
   else
     predicted.classno = 1;
  }
 else
  {
   output = soft_tree_output_K_class(treenode, data);
   softmax(output, current_dataset->classno);
   for (i = 0; i < current_dataset->classno; i++)
     posterior[i] = output[i];
   predicted.classno = find_max_in_list_double(posterior, current_dataset->classno);
  }
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xf4e21(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0x10a8c
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbed30
callq 0x7aab0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movsd 0xd15c9(%rip), %xmm0    # 0xe2018
subsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0x10a7c
movq -0x48(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x10a87
movq -0x48(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x10b10
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbebf0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0xf4d98(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x7ab00
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0xf4d7c(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x10af1
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10aba
movq -0x20(%rbp), %rdi
leaq 0xf4d44(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x500d0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_logistic
Prediction test_logistic(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 17.04.2005*/
 double** w, *y;
 int i, j;
 Prediction predicted;
 w = (double**) model;
 y = safemalloc(current_dataset->classno * sizeof(double), "logistic", 6);
 for (i = 0; i < current_dataset->classno; i++)
  {
   y[i] = w[i][0];
   for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
     y[i] += w[i][j + 1] * real_feature(data, j);
  }
 predicted.classno = findMaxOutput(y, current_dataset->classno);
 softmax(y, current_dataset->classno);
 for (i = 0; i < current_dataset->classno; i++)
   posterior[i] = y[i]; 
 safe_free(y);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xf48e1(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0xd1cfc(%rip), %rsi     # 0xe2c6d
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
leaq 0xf48b0(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x11042
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
leaq 0xf4876(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x11032
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x42c40
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x10fc0
jmp 0x11034
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10f86
movq -0x30(%rbp), %rdi
leaq 0xf47f3(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x505f0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rdi
leaq 0xf47d4(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x7ab00
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
leaq 0xf47b8(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x110b5
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1107e
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_svm
void* train_svm(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 03.05.2005*/
 Partition dummyp;
 Svm_modelptr model;
 Svm_problem prob;
 Svm_parameterptr param;
 dummyp = get_two_class_partition();
 prepare_svm_problem(&prob, C_SVC, *trdata, dummyp);
 free_partition(dummyp);
 param = (Svm_parameter*) parameters;
 model = svm_train(prob, *param, 1);
 return model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x78(%rbp), %rdi
movb $0x0, %al
callq 0x7a760
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xcaf10
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7aa80
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq 0x50(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x70(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x60(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x50(%rax)
movups %xmm2, 0x40(%rax)
movups %xmm1, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
callq 0xc7240
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_svm
Prediction test_svm(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 03.05.2005*/
 Prediction predicted;
 double* dec_values;
 int classno, y;
 Svm_nodeptr node;
 Svm_modelptr m;
 m = (Svm_modelptr) model;
 node = instance_to_svmnode(data);
 svm_predict_probability(m, node, posterior);
 if (m->nr_class == 2)
  {
   dec_values = safemalloc(sizeof(double), "test_svm", 7);
   svm_predict_values(m, node, dec_values);
   classno = give_classno(data);
   y = 1 - 2 * classno;
   predicted.hingeloss = hinge_loss(y, dec_values[0]);
   safe_free(dec_values);
  }
 predicted.classno = (int) svm_predict(m, node);
 safe_free(node);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42b00
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc9af0
movq -0x40(%rbp), %rax
cmpl $0x2, 0x58(%rax)
jne 0x1128a
movl $0x8, %edi
leaq 0xd1a4a(%rip), %rsi     # 0xe2c76
movl $0x7, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc85c0
movq -0x8(%rbp), %rdi
callq 0x43530
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
shll %ecx
movl $0x1, %eax
subl %ecx, %eax
movl %eax, -0x30(%rbp)
cvtsi2sdl -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
callq 0x65cb0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc9ce0
movq -0x50(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x52e80
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_simplexsvm
void* train_simplexsvm(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 03.05.2005*/
 Svm_simplex_parameterptr param;
 param = (Svm_simplex_parameterptr) parameters;
 if (current_dataset->classno == 2)
   return solve_binary_svm(*trdata, param, 0);
 else
   if (param->problem_type == ONE_VS_ONE)
     return solve_one_vs_one_svm(trdata, param);
   else
     return solve_one_vs_rest_svm(*trdata, param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xf455d(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0x11304
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0xcd010
movq %rax, -0x8(%rbp)
jmp 0x11335
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x11321
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xcd6e0
movq %rax, -0x8(%rbp)
jmp 0x11335
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xcd940
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_simplexsvm
Prediction test_simplexsvm(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 03.05.2005*/
 Svm_simplex_parameterptr param;
 Prediction predicted;
 param = (Svm_simplex_parameterptr) parameters;
 if (current_dataset->classno == 2)
  {
   if (test_binary_svm((Svm_binary_modelptr) model, param, data) < 0)
     predicted.classno = 0;
   else
     predicted.classno = 1;
  }
 else
   if (param->problem_type == ONE_VS_ONE)
     predicted.classno = test_one_vs_one_svm((Svm_simplex_modelptr) model, param, data);
  else
     predicted.classno = test_one_vs_rest_svm((Svm_simplex_modelptr) model, param, data);
  return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xf44d1(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0x113af
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0xcd510
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x113a2
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x113ad
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x113f1
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x113d5
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0xcd820
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x113ef
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0xcda60
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x113f1
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/clustering.c
// Function: find_nearest_mean
Instanceptr find_nearest_mean(Instanceptr means, Instanceptr data, int* index)
{
	/*!Last Changed 22.03.2005*/
	double mindist, dist;
	Instanceptr temp, minindex = NULL;
	int i;
 mindist = +INT_MAX;
 i = 0;
 temp = means;
 while (temp)
  {
   dist = distance_between_instances(temp, data);
   if (dist < mindist)
    {
     mindist = dist;
     *index = i;
					minindex = temp;
    }
   temp = temp->next;
   i++;
  }
	return minindex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movsd 0xd06ec(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x11993
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x442e0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1197c
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11938
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/clustering.c
// Function: cluster_spreads
double* cluster_spreads(Instanceptr data, Instanceptr means, int k)
{
	/*!Last Changed 20.08.2007*/
	int i, minindex;
	double* result, dist;
	Instanceptr tmp;
	result = safecalloc(k, sizeof(double), "cluster_spreads", 3);
	tmp = data;
	while (tmp)
	 {
		 find_nearest_mean(means, tmp, &minindex);
			dist = distance_between_instances(tmp, data_x(means, minindex));
			if (dist > result[minindex])
				 result[minindex] = dist;
		 tmp = tmp->next;
	 }
	for (i = 0; i < k; i++)
   if (result[i] == 0)
     result[i] = 1.0;
   else
		   result[i] = sqrt(result[i]) / 2;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
movl $0x8, %esi
leaq 0xd12e5(%rip), %rdx     # 0xe2ca8
movl $0x3, %ecx
callq 0x52f40
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x11a4a
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x11900
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x46c40
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x442e0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x11a3c
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x119d9
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11ac0
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x11a88
jp 0x11a88
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd 0xd0597(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax,%rcx,8)
jmp 0x11ab3
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x42a0
movsd 0xd11fe(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x11ab5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11a51
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/clustering.c
// Function: calculate_mean_of_nearest_distance
double calculate_mean_of_nearest_distance(Instanceptr data)
{
 Instanceptr temp, mininst;
 double S = 0.0;
 int N;
 int index;
 temp = data;
 N = data_size(data);
 while (temp)
  {
  	mininst = find_nearest_mean(data, temp, &index);
	  S = S + sqrt(distance_between_instances(mininst, temp));
 	 temp = temp->next;
  }
 S = S / N;
 return S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x449f0
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11f1f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x11900
movq %rax, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x442e0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x11ec8
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/cn2.c
// Function: is_better_candidate
int is_better_candidate(Ruleset newstar, int maxstar, double laplaceestimate)
{
 if (newstar.rulecount < maxstar)
   return YES;
 if (laplace_estimate_of_rule(*(newstar.end)) > laplaceestimate)
   return YES;
 return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
jge 0x11f69
movl $0x1, -0x4(%rbp)
jmp 0x11fae
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaee50
ucomisd -0x10(%rbp), %xmm0
jbe 0x11fa7
movl $0x1, -0x4(%rbp)
jmp 0x11fae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/cn2.c
// Function: generate_candidate_for_newstar
Decisionruleptr generate_candidate_for_newstar(Decisionruleptr current, int fno, char comparison, double split, int falsepositives, int covered)
{
 Decisionruleptr result;
 Decisionconditionptr newcondition;
 result = create_copy_of_rule(current);
 newcondition = empty_condition();
 newcondition->conditiontype = UNIVARIATE_CONDITION;
 newcondition->freeparam = 1;
 newcondition->featureindex = fno;
 newcondition->comparison = comparison;
 newcondition->value = split;
 result->falsepositives = falsepositives;
 result->covered = covered;
 add_condition(result, newcondition);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xad610
movq %rax, -0x28(%rbp)
movb $0x0, %al
callq 0xadea0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0x3c(%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movb -0xd(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, 0x4(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xad950
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/cn2.c
// Function: add_candidate_to_newstar
void add_candidate_to_newstar(Decisionruleptr candidate, Ruleset* newstar, int maxstar)
{
 Decisionruleptr tmp, tmpbefore = NULL, deleted;
 tmp = newstar->start;
 while (tmp)
  {
   if (laplace_estimate_of_rule(*tmp) > laplace_estimate_of_rule(*candidate))
     break;
   tmpbefore = tmp;
   tmp = tmp->next;
  }
 add_rule_after(newstar, tmpbefore, candidate);
 if (newstar->rulecount > maxstar)
  {
   deleted = newstar->end;
   remove_rule(newstar, newstar->end);
   free_rule(*deleted);
   safe_free(deleted);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12113
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaee50
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaee50
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x120fa
jmp 0x12113
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12086
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0xae7d0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0x12180
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xae9c0
movq -0x30(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xadd10
movq -0x30(%rbp), %rdi
callq 0x52e80
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/cn2.c
// Function: rule_significantly_better
int rule_significantly_better(Decisionruleptr current, double positive_ratio)
{
 double pvalue, sum = 0.0;
 double falsepositives, covered;
 if (current->covered == 0 || error_rate_of_rule(*current) > 0.5)
   return NO;
 covered = positive_ratio * (current->covered + current->falsepositives);
 falsepositives = (1 - positive_ratio) * (current->covered + current->falsepositives);
 if (current->covered != 0 && covered != 0.0)
   sum += current->covered * log(current->covered / covered);
 if (current->falsepositives != 0 && falsepositives != 0.0)
   sum += current->falsepositives * log(current->falsepositives / falsepositives);
 sum *= 2;
 pvalue = chi_square(1, sum);
 if (pvalue > get_parameter_f("confidencelevel"))
   return NO;
 return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1275e
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaedc0
movsd 0xd0260(%rip), %xmm1    # 0xe29b8
ucomisd %xmm1, %xmm0
jbe 0x1276a
movl $0x0, -0x4(%rbp)
jmp 0x128ba
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x8(%rcx), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0xcf886(%rip), %xmm0    # 0xe2018
subsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x8(%rcx), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x12809
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x127ce
jp 0x127ce
jmp 0x12809
movq -0x10(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm0
divsd -0x38(%rbp), %xmm0
callq 0x4120
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x12860
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x12825
jp 0x12825
jmp 0x12860
movq -0x10(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
divsd -0x30(%rbp), %xmm0
callq 0x4120
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xd0438(%rip), %xmm0    # 0xe2ca0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movl $0x1, %edi
callq 0x2d5e0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
leaq 0xcfe06(%rip), %rdi     # 0xe269d
callq 0x79040
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x128b3
movl $0x0, -0x4(%rbp)
jmp 0x128ba
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/combine.c
// Function: mean_combine
int mean_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classtotal;
 classtotal = (double *) safecalloc(numclass, sizeof(double), "mean_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   for (j = 0 ; j < numlearner ; j++)
			 {
     classtotal[i] += posteriors.values[j][i];
			 }
	 }
 res = find_max_in_list_double(classtotal, numclass);
 safe_free(classtotal);
 return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movslq -0x24(%rbp), %rdi
movl $0x8, %esi
leaq 0xcff88(%rip), %rdx     # 0xe2cdf
movl $0x5, %ecx
callq 0x52f40
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x12dc2
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x12db5
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x12d7b
jmp 0x12db7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12d6c
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x500d0
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/combine.c
// Function: max_combine
int max_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classmax, max;
 classmax = (double *) safecalloc(numclass, sizeof(double), "max_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   max = -1.0;
   for (j = 0 ; j < numlearner ; j++)
    {
     if (posteriors.values[j][i] > max)
					 {
	      classmax[i] = posteriors.values[j][i];
					 }	  
			 }
	 }
 res = find_max_in_list_double(classmax, numclass);
 safe_free(classmax);
 return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movslq -0x24(%rbp), %rdi
movl $0x8, %esi
leaq 0xcfec5(%rip), %rdx     # 0xe2cec
movl $0x5, %ecx
callq 0x52f40
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x12eb8
movsd 0xcfbfc(%rip), %xmm0    # 0xe2a48
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x12eab
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x12e9e
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x12ea0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x12e58
jmp 0x12ead
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12e3c
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x500d0
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/combine.c
// Function: min_combine
int min_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classmin, min;
 classmin = (double *) safecalloc(numclass, sizeof(double), "min_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   min = 2.0;
   for (j = 0 ; j < numlearner ; j++)
			 {
     if (posteriors.values[j][i] < min)
					 {
	      classmin[i] = posteriors.values[j][i];
					 }
			 }
	 }
 res = find_max_in_list_double(classmin, numclass);
 safe_free(classmin);
 return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movslq -0x24(%rbp), %rdi
movl $0x8, %esi
leaq 0xcfde1(%rip), %rdx     # 0xe2cf8
movl $0x5, %ecx
callq 0x52f40
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x12fac
movsd 0xcfd64(%rip), %xmm0    # 0xe2ca0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x12f9f
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x12f92
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x12f94
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x12f48
jmp 0x12fa1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12f2c
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x500d0
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/combine.c
// Function: prod_combine
int prod_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classprod;
 classprod = (double *) safecalloc(numclass, sizeof(double), "prod_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   classprod[i] = 1.0;
   for (j = 0 ; j < numlearner ; j++)
    {
     classprod[i] *= posteriors.values[j][i];
			 }
	 }
 res = find_max_in_list_double(classprod, numclass);
 safe_free(classprod);
 return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movslq -0x24(%rbp), %rdi
movl $0x8, %esi
leaq 0xcfcfd(%rip), %rdx     # 0xe2d04
movl $0x5, %ecx
callq 0x52f40
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x13087
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0xcefe4(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1307a
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13040
jmp 0x1307c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1301c
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x500d0
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/combine.c
// Function: median_combine
int median_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classmedian;
 double *foldmedian;
 classmedian = (double *) safecalloc(numclass, sizeof(double), "median_combine", 5);
 foldmedian = (double *) safecalloc(numlearner, sizeof(double), "median_combine", 6);
 for (i = 0; i < numclass; i++)
	 { 
   foldmedian[i] = 1.0;
   for (j = 0 ; j < numlearner ; j++)
			 {
     foldmedian[i] *= posteriors.values[j][i];
			 }
   classmedian[i] = find_median_in_list_double(foldmedian, numlearner);
	 }
 res = find_max_in_list_double(classmedian, numclass);
 safe_free(classmedian);
 return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movslq -0x24(%rbp), %rdi
movl $0x8, %esi
leaq 0xcfc2a(%rip), %rdx     # 0xe2d11
movl $0x5, %ecx
callq 0x52f40
movq %rax, -0x38(%rbp)
movslq -0x28(%rbp), %rdi
movl $0x8, %esi
leaq 0xcfc0c(%rip), %rdx     # 0xe2d11
movl $0x6, %ecx
callq 0x52f40
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1319f
movq -0x40(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0xceee6(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x13178
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x40(%rbp), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1313e
movq -0x40(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x50440
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1311a
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x500d0
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: get_order_index
int get_order_index(char* order)
{
	/*!Last Changed 08.01.2006*/
	int i;
	if (!order)
		 return -2;
	for (i = 0; i < ordercount; i++)
		 if (strcmp(order, orders[i].command) == 0)
				 return i;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x131fc
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1324d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xf2274(%rip), %eax     # 0x105480
jge 0x13246
movq -0x10(%rbp), %rdi
movq 0xf225f(%rip), %rax     # 0x105478
movslq -0x14(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x13239
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1324d
jmp 0x1323b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13203
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: search_help
void search_help(char* st)
{
	/*!Last Changed 19.01.2005 changed the instr*/
	/*!Last Changed 03.02.2004*/
	int i;
	for (i = 0; i < ordercount; i++)
		 if (instr(orders[i].command, st) != -1)
				 printf("%s ", orders[i].command);
			else
				 if (instr(orders[i].usage, st) != -1)
						 printf("%s ", orders[i].command);
					else
						 if (instr(orders[i].help_messages, st) != -1)
								 printf("%s ", orders[i].command);
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xf2204(%rip), %eax     # 0x105480
jge 0x13371
movq 0xf21ef(%rip), %rax     # 0x105478
movslq -0xc(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x54840
cmpl $-0x1, %eax
je 0x132cd
movq 0xf21cc(%rip), %rax     # 0x105478
movslq -0xc(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0xda1fa(%rip), %rdi     # 0xed4bb
movb $0x0, %al
callq 0x4030
jmp 0x13361
movq 0xf21a4(%rip), %rax     # 0x105478
movslq -0xc(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x54840
cmpl $-0x1, %eax
je 0x13316
movq 0xf2180(%rip), %rax     # 0x105478
movslq -0xc(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0xda1ae(%rip), %rdi     # 0xed4bb
movb $0x0, %al
callq 0x4030
jmp 0x1335f
movq 0xf215b(%rip), %rax     # 0x105478
movslq -0xc(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x54840
cmpl $-0x1, %eax
je 0x1335d
movq 0xf2137(%rip), %rax     # 0x105478
movslq -0xc(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0xda165(%rip), %rdi     # 0xed4bb
movb $0x0, %al
callq 0x4030
jmp 0x1335f
jmp 0x13361
jmp 0x13363
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13273
leaq 0xd29c3(%rip), %rdi     # 0xe5d3b
movb $0x0, %al
callq 0x4030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: print_order
void print_order(int res)
{
 int i;
 char tmp[MAXLENGTH];
 printf("%s %s\n", m1284, orders[res].command);
 printf("%s %s\n", m1285, orders[res].command_group);
 printf("%s %s\n", m1286, orders[res].command_subgroup);
 printf("%s %s\n", m1287, orders[res].grammar);
	printf("%s %s\n", m1288, orders[res].function_return);
 printf("%s %s\n", m1289, orders[res].usage);
 printf("%s %s\n", m1290, orders[res].help_messages);
 for (i = 0; i < orders[res].examplecount; i++)
  {
   printf("%s %d\n", m1412, i + 1);
   sprintf(tmp, "examples/%s", orders[res].examples[i]);
   display_file(tmp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a130, %rsp          # imm = 0x7A130
movl %edi, -0x4(%rbp)
movq 0xf1ed3(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0xcf78a(%rip), %rdi     # 0xe2d44
leaq 0xcf78a(%rip), %rsi     # 0xe2d4b
movb $0x0, %al
callq 0x4030
movq 0xf1ea9(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq 0xcf75f(%rip), %rdi     # 0xe2d44
leaq 0xcf768(%rip), %rsi     # 0xe2d54
movb $0x0, %al
callq 0x4030
movq 0xf1e7e(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
leaq 0xcf734(%rip), %rdi     # 0xe2d44
leaq 0xcf74c(%rip), %rsi     # 0xe2d63
movb $0x0, %al
callq 0x4030
movq 0xf1e53(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdx
leaq 0xcf709(%rip), %rdi     # 0xe2d44
leaq 0xcf733(%rip), %rsi     # 0xe2d75
movb $0x0, %al
callq 0x4030
movq 0xf1e28(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdx
leaq 0xcf6de(%rip), %rdi     # 0xe2d44
leaq 0xcf711(%rip), %rsi     # 0xe2d7e
movb $0x0, %al
callq 0x4030
movq 0xf1dfd(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdx
leaq 0xcf6b3(%rip), %rdi     # 0xe2d44
leaq 0xcf6ef(%rip), %rsi     # 0xe2d87
movb $0x0, %al
callq 0x4030
movq 0xf1dd2(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rdx
leaq 0xcf688(%rip), %rdi     # 0xe2d44
leaq 0xcf6cb(%rip), %rsi     # 0xe2d8e
movb $0x0, %al
callq 0x4030
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq 0xf1d9d(%rip), %rcx     # 0x105478
movslq -0x4(%rbp), %rdx
imulq $0x68, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x60(%rcx), %eax
jge 0x1374d
movl -0x8(%rbp), %edx
addl $0x1, %edx
leaq 0xd4edc(%rip), %rdi     # 0xe85d4
leaq 0xcf69c(%rip), %rsi     # 0xe2d9b
movb $0x0, %al
callq 0x4030
leaq -0x7a130(%rbp), %rdi
movq 0xf1d64(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq 0x38(%rax,%rcx,8), %rdx
leaq 0xcf674(%rip), %rsi     # 0xe2da3
movb $0x0, %al
callq 0x4170
leaq -0x7a130(%rbp), %rdi
callq 0xbda20
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x136d1
addq $0x7a130, %rsp          # imm = 0x7A130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: add_command_child
Command_nodeptr add_command_child(Command_nodeptr root, char* st)
{
	/*!Last Changed 23.10.2005*/
	Command_nodeptr tmp = root->child, before = NULL, newnode;
 newnode = safemalloc(sizeof(Command_node), "add_command_child", 2);
	newnode->command = strcopy(newnode->command, st);
	newnode->child = NULL;
	newnode->next = NULL;
 while (tmp)
		{
	  if (strIcmp(st, tmp->command) < 0)
		  	break;
			before = tmp;
			tmp = tmp->next;
		}
	if (before)
		{
  	newnode->next = before->next;
			before->next = newnode;
		}
	else
		{
			newnode->next = root->child;
			root->child = newnode;
		}
	return newnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x18, %edi
leaq 0xcf238(%rip), %rsi     # 0xe2e28
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x13c64
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x54990
cmpl $0x0, %eax
jge 0x13c4e
jmp 0x13c64
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13c30
cmpq $0x0, -0x20(%rbp)
je 0x13c89
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x13ca5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop